ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- Inclusion of the groupoid of `C^n` local diffeos in the groupoid of `C^m` local diffeos when
`m ≤ n` -/
theorem contDiffGroupoid_le (h : m ≤ n) : contDiffGroupoid n I ≤ contDiffGroupoid m I
-- Mathlib/Algebra/Algebra/Hom.lean
theorem coe_fn_injective : @Function.Injective (A →ₐ[R] B) (A → B) (↑)
-- Mathlib/Data/Fintype/Card.lean
@[simp] theorem card_eq_zero [IsEmpty α] : card α = 0
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
theorem gcd_eq_zero_iff (s : Multiset α) : s.gcd = 0 ↔ ∀ x : α, x ∈ s → x = 0
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- The category of cones on a given diagram. -/
@[simps]
instance Cone.category : Category (Cone F)
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem iUnion_mul_right_image : ⋃ a ∈ t, (· * a) '' s = s * t
-- Mathlib/Algebra/Lie/Submodule.lean
@[ext]
theorem ext (h : ∀ m, m ∈ N ↔ m ∈ N') : N = N'
-- Mathlib/Data/Finset/Lattice.lean
/-- To rewrite from right to left, use `Finset.inf'_comp_eq_image`. -/
@[simp]
theorem inf'_image [DecidableEq β] {s : Finset γ} {f : γ → β} (hs : (s.image f).Nonempty)
    (g : β → α)  :
    (s.image f).inf' hs g = s.inf' hs.of_image (g ∘ f)
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp] lemma insertNth_removeNth (p : Fin (n + 1)) (x) (f : ∀ j, α j) :
    insertNth p x (removeNth p f) = update f p x
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk_natCast (m : ℕ) : (mk m 1 : Localization M) = m
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem integrable_condexp : Integrable (μ[f|m]) μ
-- Mathlib/MeasureTheory/Covering/LiminfLimsup.lean
/-- This is really an auxiliary result en route to `blimsup_cthickening_mul_ae_eq`.

NB: The `: Set α` type ascription is present because of
https://github.com/leanprover-community/mathlib/issues/16932. -/
theorem blimsup_cthickening_ae_le_of_eventually_mul_le (p : ℕ → Prop) {s : ℕ → Set α} {M : ℝ}
    (hM : 0 < M) {r₁ r₂ : ℕ → ℝ} (hr : Tendsto r₁ atTop (𝓝[>] 0))
    (hMr : ∀ᶠ i in atTop, M * r₁ i ≤ r₂ i) :
    (blimsup (fun i => cthickening (r₁ i) (s i)) atTop p : Set α) ≤ᵐ[μ]
      (blimsup (fun i => cthickening (r₂ i) (s i)) atTop p : Set α)
-- Mathlib/Algebra/Algebra/Bilinear.lean
@[simp]
theorem mulRight_toAddMonoidHom (a : A) : (mulRight R a : A →+ A) = AddMonoidHom.mulRight a
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_top : ((⊤ : UpperSet α) : Set α) = ∅
-- Mathlib/Data/Matrix/Reflection.lean
/-- This can be used to prove
```lean
example [AddCommMonoid α] [Mul α] (a₁₁ a₁₂ a₂₁ a₂₂ b₁₁ b₁₂ b₂₁ b₂₂ : α) :
  !![a₁₁, a₁₂;
     a₂₁, a₂₂] * !![b₁₁, b₁₂;
                    b₂₁, b₂₂] =
  !![a₁₁*b₁₁ + a₁₂*b₂₁, a₁₁*b₁₂ + a₁₂*b₂₂;
     a₂₁*b₁₁ + a₂₂*b₂₁, a₂₁*b₁₂ + a₂₂*b₂₂] :=
(mulᵣ_eq _ _).symm
```
-/
@[simp]
theorem mulᵣ_eq [Mul α] [AddCommMonoid α] (A : Matrix (Fin l) (Fin m) α)
    (B : Matrix (Fin m) (Fin n) α) : mulᵣ A B = A * B
-- Mathlib/Analysis/Fourier/AddCircle.lean
@[simp]
theorem fourier_apply {n : ℤ} {x : AddCircle T} : fourier n x = toCircle (n • x :)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/MinMax.lean
protected theorem le_min_of_le_of_le {a b c : Nat} : a ≤ b → a ≤ c → a ≤ min b c
-- Mathlib/CategoryTheory/Sums/Basic.lean
@[aesop norm -10 destruct (rule_sets := [CategoryTheory])]
theorem hom_inr_inl_false {X : C} {Y : D} (f : Sum.inr X ⟶ Sum.inl Y) : False
-- .lake/packages/lean4/src/lean/Init/SizeOfLemmas.lean
@[simp] protected theorem UInt16.sizeOf (a : UInt16) : sizeOf a = a.toNat + 2
-- Mathlib/RingTheory/Multiplicity.lean
theorem min_le_multiplicity_add {p a b : α} :
    min (multiplicity p a) (multiplicity p b) ≤ multiplicity p (a + b)
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- The weighted sum, added to the base point, is independent of the
base point when the sum of the weights is 1. -/
theorem weightedVSubOfPoint_vadd_eq_of_sum_eq_one (w : ι → k) (p : ι → P) (h : ∑ i ∈ s, w i = 1)
    (b₁ b₂ : P) : s.weightedVSubOfPoint p b₁ w +ᵥ b₁ = s.weightedVSubOfPoint p b₂ w +ᵥ b₂
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem vadd_eq (a : A) (r : R) : r +ᵥ σ a = σ (↑ₐ r + a)
-- Mathlib/RingTheory/FiniteType.lean
/--
If the image of an element `m : M` in `R[M]` belongs the submodule generated by
the closure of some `S : Set M` then `m ∈ closure S`. -/
theorem mem_closure_of_mem_span_closure [Nontrivial R] {m : M} {S : Set M}
    (h : of' R M m ∈ span R (Submonoid.closure (of' R M '' S) : Set R[M])) :
    m ∈ closure S
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem filterMap_some (l : List α) : filterMap some l = l
-- Mathlib/Topology/Constructions.lean
theorem nhds_prod_eq {x : X} {y : Y} : 𝓝 (x, y) = 𝓝 x ×ˢ 𝓝 y
-- Mathlib/Algebra/Group/Invertible/Defs.lean
theorem mul_right_eq_iff_eq_mul_invOf : a * c = b ↔ a = b * ⅟c
-- Mathlib/Logic/Basic.lean
theorem exists₂_comm
    {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*} {p : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → Prop} :
    (∃ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∃ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂
-- Mathlib/Algebra/AddTorsor.lean
theorem vadd_eq_vadd_iff_neg_add_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
    v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ -v₁ + v₂ = p₁ -ᵥ p₂
-- Mathlib/LinearAlgebra/FreeModule/PID.lean
theorem eq_bot_of_generator_maximal_map_eq_zero (b : Basis ι R M) {N : Submodule R M}
    {ϕ : M →ₗ[R] R} (hϕ : ∀ ψ : M →ₗ[R] R, ¬N.map ϕ < N.map ψ) [(N.map ϕ).IsPrincipal]
    (hgen : generator (N.map ϕ) = (0 : R)) : N = ⊥
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem rightLim_eq_of_tendsto [TopologicalSpace α] [OrderTopology α] [T2Space β]
    {f : α → β} {a : α} {y : β} (h : 𝓝[>] a ≠ ⊥) (h' : Tendsto f (𝓝[>] a) (𝓝 y)) :
    Function.rightLim f a = y
-- Mathlib/Probability/Process/Stopping.lean
theorem measurable_stoppedValue [MetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    (hf_prog : ProgMeasurable f u) (hτ : IsStoppingTime f τ) :
    Measurable[hτ.measurableSpace] (stoppedValue u τ)
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[simp]
theorem coe_one : ((1 : Monoid.End M) : M → M) = id
-- Mathlib/Data/Set/Finite.lean
theorem iInf_iSup_of_monotone {ι ι' α : Type*} [Finite ι] [Preorder ι'] [Nonempty ι']
    [IsDirected ι' (swap (· ≤ ·))] [Order.Coframe α] {f : ι → ι' → α} (hf : ∀ i, Monotone (f i)) :
    ⨅ j, ⨆ i, f i j = ⨆ i, ⨅ j, f i j
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem fromBlocks_diagonal (d₁ : l → α) (d₂ : m → α) :
    fromBlocks (diagonal d₁) 0 0 (diagonal d₂) = diagonal (Sum.elim d₁ d₂)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem toFun_eq_coe (f : Π₀ i, β i) : f.toFun = f
-- Mathlib/Topology/Sheaves/LocalPredicate.lean
/-- Given a topological space `X : TopCat` and a type family `T : X → Type`,
a `P : LocalPredicate T` consists of:
* a family of predicates `P.pred`, one for each `U : Opens X`, of the form `(Π x : U, T x) → Prop`
* a proof that if `f : Π x : V, T x` satisfies the predicate on `V : Opens X`, then
  the restriction of `f` to any open subset `U` also satisfies the predicate, and
* a proof that given some `f : Π x : U, T x`,
  if for every `x : U` we can find an open set `x ∈ V ≤ U`
  so that the restriction of `f` to `V` satisfies the predicate,
  then `f` itself satisfies the predicate.
-/
structure LocalPredicate extends PrelocalPredicate T where
  /-- A local predicate must be local --- provided that it is locally satisfied, it is also globally
    satisfied -/
  locality :
    ∀ {U : Opens X} (f : ∀ x : U, T x)
      (_ : ∀ x : U, ∃ (V : Opens X) (_ : x.1 ∈ V) (i : V ⟶ U),
        pred fun x : V => f (i x : U)), pred f
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_le_pi_div_two_iff {z : ℂ} : arg z ≤ π / 2 ↔ 0 ≤ re z ∨ im z < 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Cauchy–Schwarz inequality for real inner products. -/
theorem real_inner_mul_inner_self_le (x y : F) : ⟪x, y⟫_ℝ * ⟪x, y⟫_ℝ ≤ ⟪x, x⟫_ℝ * ⟪y, y⟫_ℝ
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive]
lemma comp_eq_one_iff [One β] [One γ] (f : α → β) {g : β → γ} (hg : Injective g) (hg0 : g 1 = 1) :
    g ∘ f = 1 ↔ f = 1
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem card_zpowers_le (a : G) {k : ℕ} (k_pos : k ≠ 0)
    (ha : a ^ k = 1) : Fintype.card (Subgroup.zpowers a) ≤ k
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `lt_of_tsub_lt_tsub_left_of_le` for a weaker statement in a partial order. -/
theorem lt_of_tsub_lt_tsub_left (h : a - b < a - c) : c < b
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_nonneg]
lemma one_le_prod (hf : 1 ≤ f) : 1 ≤ ∏ i, f i
-- Mathlib/Data/Finset/Image.lean
theorem image_congr (h : (s : Set α).EqOn f g) : Finset.image f s = Finset.image g s
-- Mathlib/AlgebraicTopology/DoldKan/FunctorN.lean
@[simp]
lemma toKaroubiCompN₂IsoN₁_hom_app (X : SimplicialObject C) :
    (toKaroubiCompN₂IsoN₁.hom.app X).f = PInfty
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
lemma verts_coeSubgraph {G' : Subgraph G} (G'' : Subgraph G'.coe) :
    G''.coeSubgraph.verts = (G''.verts : Set V)
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Ioi [NoMinOrder α] : ⋃ a : α, Ioi a = univ
-- Mathlib/Algebra/Order/Ring/WithTop.lean
theorem top_pow {n : ℕ} (n_pos : 0 < n) : (⊤ : WithTop α) ^ n = ⊤
-- Mathlib/Analysis/NormedSpace/Exponential.lean
/-- In a commutative Banach-algebra `𝔸` over a normed field `𝕂` of characteristic zero,
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)` for all `x`, `y` in the disk of convergence. -/
theorem exp_add_of_mem_ball [CharZero 𝕂] {x y : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius)
    (hy : y ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem measure_inter_null_of_null_right (S : Set α) {T : Set α} (h : μ T = 0) : μ (S ∩ T) = 0
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Completeness.lean
/-- Let `s` be a bounded set in the space of continuous (semi)linear maps `E →SL[σ] F` taking values
in a proper space. Then `s` interpreted as a set in the space of maps `E → F` with topology of
pointwise convergence is precompact: its closure is a compact set. -/
theorem isCompact_closure_image_coe_of_bounded [ProperSpace F] {s : Set (E' →SL[σ₁₂] F)}
    (hb : IsBounded s) : IsCompact (closure (((↑) : (E' →SL[σ₁₂] F) → E' → F) '' s))
-- Mathlib/Data/Real/Irrational.lean
theorem irrational_sqrt_intCast_iff {z : ℤ} :
    Irrational (√z) ↔ ¬IsSquare z ∧ 0 ≤ z
-- Mathlib/Data/Set/Image.lean
theorem preimage_compl_eq_image_compl [BooleanAlgebra α] (S : Set α) :
    HasCompl.compl ⁻¹' S = HasCompl.compl '' S
-- Mathlib/RingTheory/Localization/FractionRing.lean
@[simp]
theorem mk'_eq_zero_iff_eq_zero [Algebra R K] [IsFractionRing R K] {x : R} {y : nonZeroDivisors R} :
    mk' K x y = 0 ↔ x = 0
-- Mathlib/Data/SetLike/Basic.lean
theorem exists_of_lt : p < q → ∃ x ∈ q, x ∉ p
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem imp_imp_imp {a b c d : Prop} (h₀ : c → a) (h₁ : b → d) : (a → b) → (c → d)
-- Mathlib/Topology/MetricSpace/PiNat.lean
@[simp]
theorem cylinder_zero (x : ∀ n, E n) : cylinder x 0 = univ
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive] lemma image_op_inv (s : Finset α) : s⁻¹.image op = (s.image op)⁻¹
-- Mathlib/FieldTheory/IsSepClosed.lean
theorem exists_aeval_eq_zero [IsSepClosed K] [Algebra k K] (p : k[X])
    (hp : p.degree ≠ 0) (hsep : p.Separable) : ∃ x : K, aeval x p = 0
-- Mathlib/Topology/UniformSpace/Basic.lean
@[mono]
theorem symmetrize_mono {V W : Set (α × α)} (h : V ⊆ W) : symmetrizeRel V ⊆ symmetrizeRel W
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_sub (a b : α) : |a - b| ≤ |a| + |b|
-- Mathlib/Order/CompactlyGenerated/Basic.lean
/-- An element `k` is compact if and only if any directed set with `sSup` above
`k` already got above `k` at some point in the set. -/
theorem isCompactElement_iff_le_of_directed_sSup_le (k : α) :
    IsCompactElement k ↔
      ∀ s : Set α, s.Nonempty → DirectedOn (· ≤ ·) s → k ≤ sSup s → ∃ x : α, x ∈ s ∧ k ≤ x
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem toString_toSubstring (s : String) : s.toSubstring.toString = s
-- Mathlib/Analysis/ODE/Gronwall.lean
/-- Local unqueness of ODE solutions. -/
theorem ODE_solution_unique_of_eventually
    (hf : ∀ᶠ t in 𝓝 t₀, HasDerivAt f (v t (f t)) t ∧ f t ∈ s t)
    (hg : ∀ᶠ t in 𝓝 t₀, HasDerivAt g (v t (g t)) t ∧ g t ∈ s t)
    (heq : f t₀ = g t₀) : f =ᶠ[𝓝 t₀] g
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem rightUnitor_inv_naturality {X X' : C} (f : X ⟶ X') :
    f ≫ (ρ_ X').inv = (ρ_ X).inv ≫ f ▷ _
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
@[simp]
protected theorem inv_mul_cancel (φ : MvPowerSeries σ k) (h : constantCoeff σ k φ ≠ 0) :
    φ⁻¹ * φ = 1
-- Mathlib/Order/Interval/Set/Basic.lean
theorem eq_right_or_mem_Ioo_of_mem_Ioc {x : α} (hmem : x ∈ Ioc a b) : x = b ∨ x ∈ Ioo a b
-- Mathlib/Analysis/PSeries.lean
theorem le_sum_condensed (hf : ∀ ⦃m n⦄, 0 < m → m ≤ n → f n ≤ f m) (n : ℕ) :
    (∑ k ∈ range (2 ^ n), f k) ≤ f 0 + ∑ k ∈ range n, 2 ^ k • f (2 ^ k)
-- Mathlib/Data/List/Range.lean
theorem chain'_range_succ (r : ℕ → ℕ → Prop) (n : ℕ) :
    Chain' r (range n.succ) ↔ ∀ m < n, r m m.succ
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem IsOpen.reProdIm (hs : IsOpen s) (ht : IsOpen t) : IsOpen (s ×ℂ t)
-- Mathlib/Computability/ContextFreeGrammar.lean
lemma Produces.trans_derives {u v w : List (Symbol T g.NT)}
    (huv : g.Produces u v) (hvw : g.Derives v w) :
    g.Derives u w
-- Mathlib/Topology/ContinuousFunction/Basic.lean
/--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term
-/
@[simps]
def piEquiv : (∀ i, C(A, X i)) ≃ C(A, ∀ i, X i)
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- The `covolume` can be computed by taking the `volume` of any given fundamental domain `s`. -/
@[to_additive]
lemma IsFundamentalDomain.covolume_eq_volume (ν : Measure α) [Countable G]
    [MeasurableSMul G α] [SMulInvariantMeasure G α ν] {s : Set α}
    (fund_dom_s : IsFundamentalDomain G s ν) : covolume G α ν = ν s
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- Given an equivalence `e : R ≃+* S` of semirings and a subsemiring `s` of `R`,
`subsemiring_map e s` is the induced equivalence between `s` and `s.map e` -/
@[simps!]
def subsemiringMap (e : R ≃+* S) (s : Subsemiring R) : s ≃+* s.map e.toRingHom
-- Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean
theorem le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {S : Submonoid M}
    (hS : (0 : M) ∉ S) : S ≤ M⁰
-- Mathlib/Order/Filter/Basic.lean
theorem mem_principal_self (s : Set α) : s ∈ 𝓟 s
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
theorem homothety_norm [RingHomIsometric σ₁₂] [Nontrivial E] (f : E →SL[σ₁₂] F) {a : ℝ}
    (hf : ∀ x, ‖f x‖ = a * ‖x‖) : ‖f‖ = a
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Existence of projections on complete subspaces.
Let `u` be a point in an inner product space, and let `K` be a nonempty complete subspace.
Then there exists a (unique) `v` in `K` that minimizes the distance `‖u - v‖` to `u`.
This point `v` is usually called the orthogonal projection of `u` onto `K`.
-/
theorem exists_norm_eq_iInf_of_complete_subspace (h : IsComplete (↑K : Set E)) :
    ∀ u : E, ∃ v ∈ K, ‖u - v‖ = ⨅ w : (K : Set E), ‖u - w‖
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- If the derivative of a function defined on the real line is integrable close to `-∞`, then
the function has a limit at `-∞`. -/
theorem tendsto_limUnder_of_hasDerivAt_of_integrableOn_Iic [CompleteSpace E]
    (hderiv : ∀ x ∈ Iic a, HasDerivAt f (f' x) x) (f'int : IntegrableOn f' (Iic a)) :
    Tendsto f atBot (𝓝 (limUnder atBot f))
-- Mathlib/CategoryTheory/Limits/Lattice.lean
/-- The binary coproduct in the category of a `SemilatticeSup` with `OrderBot` is the same as the
supremum.
-/
@[simp]
theorem coprod_eq_sup [SemilatticeSup α] [OrderBot α] (x y : α) : Limits.coprod x y = x ⊔ y
-- Mathlib/Combinatorics/Colex.lean
@[simp] lemma toColex_ofColex (s : Colex α) : toColex (ofColex s) = s
-- Mathlib/Data/Real/Irrational.lean
theorem rat_mul (h : Irrational x) {q : ℚ} (hq : q ≠ 0) : Irrational (q * x)
-- Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean
/-- Convergence in Lp implies convergence in measure. -/
theorem tendstoInMeasure_of_tendsto_Lp [hp : Fact (1 ≤ p)] {f : ι → Lp E p μ} {g : Lp E p μ}
    {l : Filter ι} (hfg : Tendsto f l (𝓝 g)) : TendstoInMeasure μ (fun n => f n) l g
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem limNthHom_spec (r : R) :
    ∀ ε : ℝ, 0 < ε → ∃ N : ℕ, ∀ n ≥ N, ‖limNthHom f_compat r - nthHom f r n‖ < ε
-- Mathlib/Topology/Order.lean
theorem nhds_mkOfNhds_filterBasis (B : α → FilterBasis α) (a : α) (h₀ : ∀ x, ∀ n ∈ B x, x ∈ n)
    (h₁ : ∀ x, ∀ n ∈ B x, ∃ n₁ ∈ B x, ∀ x' ∈ n₁, ∃ n₂ ∈ B x', n₂ ⊆ n) :
    @nhds α (TopologicalSpace.mkOfNhds fun x => (B x).filter) a = (B a).filter
-- Mathlib/Logic/Function/Basic.lean
theorem partialInv_left {α β} {f : α → β} (I : Injective f) : ∀ x, partialInv f (f x) = some x
-- Mathlib/Data/Multiset/Basic.lean
theorem not_mem_mono (h : s ⊆ t) : a ∉ t → a ∉ s
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem tendsto_testAgainstNN_of_tendsto_normalize_testAgainstNN_of_tendsto_mass {γ : Type*}
    {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    (μs_lim : Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize))
    (mass_lim : Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass)) (f : Ω →ᵇ ℝ≥0) :
    Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 (μ.testAgainstNN f))
-- Mathlib/Topology/Algebra/Module/Star.lean
/-- If `A` is a topological module over a commutative `R` with trivial star and compatible actions,
then `star` is a continuous linear equivalence. -/
@[simps!]
def starL' (R : Type*) {A : Type*} [CommSemiring R] [StarRing R] [TrivialStar R] [AddCommMonoid A]
    [StarAddMonoid A] [Module R A] [StarModule R A] [TopologicalSpace A] [ContinuousStar A] :
    A ≃L[R] A
-- Mathlib/CategoryTheory/Limits/Presheaf.lean
@[simp]
lemma compYonedaIsoYonedaCompLan_inv_app_app_apply_eq_id (X : C) :
    ((compYonedaIsoYonedaCompLan F).inv.app X).app (Opposite.op (F.obj X))
      ((F.op.lanUnit.app (yoneda.obj X)).app _ (𝟙 X)) = 𝟙 _
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
/-- A generalization of the fixed point lemma for normal functions: any family of normal functions
    has an unbounded set of common fixed points. -/
theorem fp_family_unbounded (H : ∀ i, IsNormal (f i)) :
    (⋂ i, Function.fixedPoints (f i)).Unbounded (· < ·)
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem mk_pow (a : G) (n : ℕ) : ((a ^ n : G) : Q) = (a : Q) ^ n
-- Mathlib/Topology/Separation.lean
theorem union_left : SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem map_id (S : Submonoid M) : S.map (MonoidHom.id M) = S
-- Mathlib/NumberTheory/LucasLehmer.lean
/-- A closed form for the recurrence relation. -/
theorem closed_form (i : ℕ) : (s i : X q) = (ω : X q) ^ 2 ^ i + (ωb : X q) ^ 2 ^ i
-- Mathlib/FieldTheory/Perfect.lean
theorem roots_expand_map_frobenius : (expand R p f).roots.map (frobenius R p) = p • f.roots
-- Mathlib/Data/Vector/MapLemmas.lean
theorem mapAccumr₂_bisim {ys : Vector β n} {f₁ : α → β → σ₁ → σ₁ × γ}
    {f₂ : α → β → σ₂ → σ₂ × γ} {s₁ : σ₁} {s₂ : σ₂}
    (R : σ₁ → σ₂ → Prop) (h₀ : R s₁ s₂)
    (hR :  ∀ {s q} a b, R s q → R (f₁ a b s).1 (f₂ a b q).1 ∧ (f₁ a b s).2 = (f₂ a b q).2) :
    R (mapAccumr₂ f₁ xs ys s₁).1 (mapAccumr₂ f₂ xs ys s₂).1
    ∧ (mapAccumr₂ f₁ xs ys s₁).2 = (mapAccumr₂ f₂ xs ys s₂).2
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
theorem decomp (f : V →ᴬ[R] W) : (f : V → W) = f.contLinear + Function.const V (f 0)
-- Mathlib/Data/Finset/Pairwise.lean
theorem pairwise_disjoint_of_coe_toFinset_pairwiseDisjoint {α ι} [SemilatticeInf α] [OrderBot α]
    [DecidableEq ι] {l : List ι} {f : ι → α} (hl : (l.toFinset : Set ι).PairwiseDisjoint f)
    (hn : l.Nodup) : l.Pairwise (_root_.Disjoint on f)
-- Mathlib/Data/Finset/Basic.lean
theorem disjoint_right : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ t → a ∉ s
-- Mathlib/Data/Nat/Defs.lean
protected lemma mul_div_mul_comm (hba : b ∣ a) (hdc : d ∣ c) : a * c / (b * d) = a / b * (c / d)
-- Mathlib/Data/Int/GCD.lean
theorem exists_mul_emod_eq_one_of_coprime {k n : ℕ} (hkn : Coprime n k) (hk : 1 < k) :
    ∃ m, n * m % k = 1
-- Mathlib/Topology/Inseparable.lean
@[simp]
theorem lift_comp_mk {f : X → α} (hf : ∀ x y, (x ~ᵢ y) → f x = f y) : lift f hf ∘ mk = f
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
/-- A multiplicative action is isometric if each map `x ↦ c • x` is an isometry. -/
@[to_additive]
class IsometricSMul [PseudoEMetricSpace X] [SMul M X] : Prop where
  protected isometry_smul : ∀ c : M, Isometry ((c • ·) : X → X)
-- Mathlib/Order/Filter/Prod.lean
/-- A useful lemma when dealing with uniformities. -/
theorem map_swap4_prod {h : Filter γ} {k : Filter δ} :
    map (fun p : (α × β) × γ × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) ((f ×ˢ g) ×ˢ (h ×ˢ k)) =
      (f ×ˢ h) ×ˢ (g ×ˢ k)
-- Mathlib/Algebra/Polynomial/Derivation.lean
lemma mkDerivation_one_eq_derivative' : mkDerivation R (1 : R[X]) = derivative'
-- Mathlib/Data/Complex/Abs.lean
theorem equiv_limAux (f : CauSeq ℂ Complex.abs) :
    f ≈ CauSeq.const Complex.abs (limAux f)
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp] theorem fst_natCast (n : ℕ) : (n : X q).fst = (n : ZMod q)
-- Mathlib/Topology/Separation.lean
theorem IsCompact.lift'_closure_nhdsSet {K : Set X} (hK : IsCompact K) :
    (𝓝ˢ K).lift' closure = 𝓝ˢ K
-- Mathlib/LinearAlgebra/Dimension/RankNullity.lean
theorem exists_linearIndependent_of_lt_rank [StrongRankCondition R]
    {s : Set M} (hs : LinearIndependent (ι := s) R Subtype.val) :
    ∃ t, s ⊆ t ∧ #t = Module.rank R M ∧ LinearIndependent (ι := t) R Subtype.val
-- Mathlib/CategoryTheory/Sites/Coherent/LocallySurjective.lean
lemma regularTopology.isLocallySurjective_iff [Preregular C] {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G) :
    Presheaf.IsLocallySurjective (regularTopology C) f ↔
      ∀ (X : C) (y : G.obj ⟨X⟩), (∃ (X' : C) (φ : X' ⟶ X) (_ : EffectiveEpi φ) (x : F.obj ⟨X'⟩),
        f.app ⟨X'⟩ x = G.map ⟨φ⟩ y)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem all_ae_ofReal_f_le_bound (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) :
    ∀ᵐ a ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)
-- Mathlib/Data/Int/GCD.lean
theorem gcd_dvd_iff {a b : ℤ} {n : ℕ} : gcd a b ∣ n ↔ ∃ x y : ℤ, ↑n = a * x + b * y
-- Mathlib/Logic/Function/Basic.lean
theorem Bijective.comp_right (hf : Bijective f) : Bijective fun g : β → γ ↦ g ∘ f
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem map_sub_rev (x y : V) : e (x - y) = e (y - x)
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt16.toNat_lt (x : UInt16) : x.toNat < 2 ^ 16
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b : β) :
    pkg.extend₂ pkg' f (ι a) (ι' b) = f a b
-- Mathlib/Topology/Separation.lean
@[simp]
theorem compl_singleton_mem_nhdsSet_iff [T1Space X] {x : X} {s : Set X} : {x}ᶜ ∈ 𝓝ˢ s ↔ x ∉ s
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem rightAssocTensor_map {X Y} (f : X ⟶ Y) : (rightAssocTensor C).map f = f.1 ⊗ f.2.1 ⊗ f.2.2
-- Mathlib/Data/Finset/Card.lean
lemma card_inter (s t : Finset α) : (s ∩ t).card = s.card + t.card - (s ∪ t).card
-- Mathlib/Order/Atoms.lean
theorem eq_bot_of_lt : a = ⊥
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem aleph'_isNormal : IsNormal (ord ∘ aleph')
-- Mathlib/Algebra/Group/WithOne/Defs.lean
@[to_additive (attr := simp, norm_cast)]
lemma coe_mul [Mul α] (a b : α) : (↑(a * b) : WithOne α) = a * b
-- Mathlib/Data/DFinsupp/Basic.lean
theorem support_zipWith {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i}
    {g₂ : Π₀ i, β₂ i} : (zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem AntitoneOn.Iic (hf : AntitoneOn f s) : AntitoneOn (fun x => Iic (f x)) s
-- Mathlib/RingTheory/FiniteType.lean
theorem equiv (hRA : FiniteType R A) (e : A ≃ₐ[R] B) : FiniteType R B
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncateFun_one : truncateFun n (1 : 𝕎 R) = 1