ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/List/Perm.lean
@[deprecated get_permutations'Aux (since := "2024-04-23")]
theorem nthLe_permutations'Aux (s : List α) (x : α) (n : ℕ)
    (hn : n < length (permutations'Aux x s)) :
    (permutations'Aux x s).nthLe n hn = s.insertNth n x
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem ball_subset_of_comp_subset {V W : Set (β × β)} {x y} (h : x ∈ ball y W) (h' : W ○ W ⊆ V) :
    ball x W ⊆ ball y V
-- Mathlib/Data/Finset/Density.lean
lemma dens_sdiff_comm (h : card s = card t) : dens (s \ t) = dens (t \ s)
-- Mathlib/Data/Finsupp/Order.lean
theorem tsub_apply (f g : ι →₀ α) (a : ι) : (f - g) a = f a - g a
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_mul_lt_iff' (h : 0 < b) : b⁻¹ * a < c ↔ a < c * b
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem eqOn_univ (f₁ f₂ : α → β) : EqOn f₁ f₂ univ ↔ f₁ = f₂
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem smooth_subtype_iff {U : Opens M} {f : M → M'} {x : U} :
    SmoothAt I I' (fun x : U ↦ f x) x ↔ SmoothAt I I' f x
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_lt_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) < (y : EReal) ↔ x < y
-- Mathlib/Data/Complex/Exponential.lean
theorem sinh_conj : sinh (conj x) = conj (sinh x)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem compl_empty : (∅ : Set α)ᶜ = univ
-- Mathlib/Topology/NhdsSet.lean
theorem Filter.Eventually.union_nhdsSet {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ (s ∪ t), p x) ↔ (∀ᶠ x in 𝓝ˢ s, p x) ∧ ∀ᶠ x in 𝓝ˢ t, p x
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem bot_coe_submodule : ((⊥ : LieSubalgebra R L) : Submodule R L) = ⊥
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
/--
Preliminary statement of the comultiplication for a tensor product of comonoids.
This version is the definitional equality provided by transport, and not quite as good as
the version provided in `tensorObj_comul` below.
-/
theorem tensorObj_comul' (A B : Comon_ C) :
    (A ⊗ B).comul =
      (A.comul ⊗ B.comul) ≫ (tensor_μ Cᵒᵖ (op A.X, op B.X) (op A.X, op B.X)).unop
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem ofFn_blocksFun : ofFn c.blocksFun = c.blocks
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderSpecialization_empty : StableUnderSpecialization (∅ : Set X)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem GoodProducts.P0 : P I 0
-- Mathlib/Topology/GDelta.lean
theorem IsGδ.inter {s t : Set X} (hs : IsGδ s) (ht : IsGδ t) : IsGδ (s ∩ t)
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₁_eq_zero_of_epi₃ (h : Epi T.mor₃) : T.mor₁ = 0
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem Units.mk0_mul (x y : G₀) (hxy) :
    Units.mk0 (x * y) hxy =
      Units.mk0 x (mul_ne_zero_iff.mp hxy).1 * Units.mk0 y (mul_ne_zero_iff.mp hxy).2
-- Mathlib/Algebra/Ring/Pi.lean
/-- Non-unital ring homomorphism between the function spaces `I → α` and `I → β`, induced by a
non-unital ring homomorphism `f` between `α` and `β`. -/
@[simps]
protected def NonUnitalRingHom.compLeft {α β : Type*} [NonUnitalNonAssocSemiring α]
    [NonUnitalNonAssocSemiring β] (f : α →ₙ+* β) (I : Type*) : (I → α) →ₙ+* I → β
-- Mathlib/Algebra/Polynomial/Laurent.lean
/-- Suppose that `Q` is a statement about Laurent polynomials such that
* `Q` is true on *ordinary* polynomials;
* `Q (f * T)` implies `Q f`;
it follow that `Q` is true on all Laurent polynomials. -/
theorem reduce_to_polynomial_of_mul_T (f : R[T;T⁻¹]) {Q : R[T;T⁻¹] → Prop}
    (Qf : ∀ f : R[X], Q (toLaurent f)) (QT : ∀ f, Q (f * T 1) → Q f) : Q f
-- Mathlib/CategoryTheory/HomCongr.lean
theorem homCongr_refl {X Y : C} (f : X ⟶ Y) : (Iso.refl X).homCongr (Iso.refl Y) f = f
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem le_add_left (a b : Ordinal) : a ≤ b + a
-- Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean
theorem IsLowerSet.memberSubfamily_subset_nonMemberSubfamily (h : IsLowerSet (𝒜 : Set (Finset α))) :
    𝒜.memberSubfamily a ⊆ 𝒜.nonMemberSubfamily a
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- The integral of the derivative of a product of two maps.
For improper integrals, see `MeasureTheory.integral_deriv_mul_eq_sub`,
`MeasureTheory.integral_Ioi_deriv_mul_eq_sub`, and `MeasureTheory.integral_Iic_deriv_mul_eq_sub`. -/
theorem integral_deriv_mul_eq_sub_of_hasDeriv_right {u v u' v' : ℝ → A}
    (hu : ContinuousOn u [[a, b]])
    (hv : ContinuousOn v [[a, b]])
    (huu' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt u (u' x) (Ioi x) x)
    (hvv' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt v (v' x) (Ioi x) x)
    (hu' : IntervalIntegrable u' volume a b)
    (hv' : IntervalIntegrable v' volume a b) :
    ∫ x in a..b, u' x * v x + u x * v' x = u b * v b - u a * v a
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem refl_toEmbedding : (refl L M).toEmbedding = Embedding.refl L M
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem MeasurableEmbedding.essSup_map_measure (hf : MeasurableEmbedding f) :
    essSup g (Measure.map f μ) = essSup (g ∘ f) μ
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Inner.lean
@[measurability]
theorem AEMeasurable.const_inner {m : MeasurableSpace α} [MeasurableSpace E]
    [OpensMeasurableSpace E] [SecondCountableTopology E]
    {μ : MeasureTheory.Measure α} {f : α → E} {c : E} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => ⟪c, f x⟫) μ
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem ofFunction_eq_sSup : OuterMeasure.ofFunction m m_empty = sSup { μ | ∀ s, μ s ≤ m s }
-- Mathlib/Topology/LocallyFinite.lean
protected theorem closure (hf : LocallyFinite f) : LocallyFinite fun i => closure (f i)
-- Mathlib/Algebra/Module/Defs.lean
@[deprecated (since := "2022-12-31")]
theorem two_smul' : (2 : R) • x = (2 : ℕ) • x
-- Mathlib/ModelTheory/Syntax.lean
@[simp]
theorem relabel_comp_relabel (f : α → β) (g : β → γ) :
    (Term.relabel g ∘ Term.relabel f : L.Term α → L.Term γ) = Term.relabel (g ∘ f)
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive]
nonrec theorem IsUnit.unop {M} [Monoid M] {m : Mᵐᵒᵖ} (h : IsUnit m) : IsUnit (unop m)
-- Mathlib/Analysis/Normed/Module/Complemented.lean
@[simp]
theorem coe_continuous_linearProjOfClosedCompl' (h : IsCompl p q) (hp : IsClosed (p : Set E))
    (hq : IsClosed (q : Set E)) :
    ⇑(p.linearProjOfClosedCompl q h hp hq) = p.linearProjOfIsCompl q h
-- Mathlib/Algebra/Lie/Free.lean
@[simp]
theorem lift_unique (f : X → L) (g : FreeLieAlgebra R X →ₗ⁅R⁆ L) : g ∘ of R = f ↔ g = lift R f
-- Mathlib/CategoryTheory/Closed/FunctorCategory.lean
/-- Auxiliary definition for `CategoryTheory.Functor.closed`.
The unit for the adjunction `(tensorLeft F) ⊣ (ihom F)`. -/
@[simps]
def closedUnit (F : D ⥤ C) : 𝟭 (D ⥤ C) ⟶ tensorLeft F ⋙ closedIhom F
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
lemma not_adj_iff_part_eq : ¬G.Adj s t ↔ h.finpartition.part s = h.finpartition.part t
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem comap_const (f : R →+* S) (U : Opens (PrimeSpectrum.Top R))
    (V : Opens (PrimeSpectrum.Top S)) (hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1) (a b : R)
    (hb : ∀ x : PrimeSpectrum R, x ∈ U → b ∈ x.asIdeal.primeCompl) :
    comap f U V hUV (const R a b U hb) =
      const S (f a) (f b) V fun p hpV => hb (PrimeSpectrum.comap f p) (hUV hpV)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem mk_Iio_ord_out_α {c : Cardinal} (i : c.ord.out.α) : #(Iio i) < c
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_const_of_tendsto {y : E''} (h : Tendsto f'' l (𝓝 y)) {c : F''} (hc : c ≠ 0) :
    f'' =O[l] fun _x => c
-- Mathlib/Data/Finset/Lattice.lean
theorem inf'_sup_distrib_right (f : ι → α) (a : α) : s.inf' hs f ⊔ a = s.inf' hs fun i => f i ⊔ a
-- Mathlib/Topology/Instances/ENNReal.lean
theorem le_of_forall_lt_one_mul_le {x y : ℝ≥0∞} (h : ∀ a < 1, a * x ≤ y) : x ≤ y
-- Mathlib/Topology/Separation.lean
/-- If two continuous functions are equal on a dense set, then they are equal. -/
theorem Continuous.ext_on [T2Space X] {s : Set Y} (hs : Dense s) {f g : Y → X} (hf : Continuous f)
    (hg : Continuous g) (h : EqOn f g s) : f = g
-- Mathlib/RingTheory/Kaehler/Polynomial.lean
lemma KaehlerDifferential.polynomial_D_apply (P : R[X]) :
    D R R[X] P = derivative P • D R R[X] X
-- Mathlib/Data/Set/Prod.lean
theorem exists_prod_set {p : α × β → Prop} : (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y)
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
@[simp] lemma right_mem_uIcc : b ∈ [[a, b]]
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[ext]
theorem ext (h : ∀ x, x ∈ p ↔ x ∈ q) : p = q
-- Mathlib/Data/Int/Bitwise.lean
theorem bodd_add_div2 : ∀ n, cond (bodd n) 1 0 + 2 * div2 n = n
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem single_eq_zero {a : G} {b : k} : single a b = 0 ↔ b = 0
-- Mathlib/Control/Fix.lean
protected theorem fix_def {x : α} (h' : ∃ i, (Fix.approx f i x).Dom) :
    Part.fix f x = Fix.approx f (Nat.succ (Nat.find h')) x
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Ioc_ofDual (a b : αᵒᵈ) : Ioc (ofDual a) (ofDual b) = (Ico b a).map ofDual.toEmbedding
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_inf_distrib_right (f : ι → α) (a : α) :
    s.sup' hs f ⊓ a = s.sup' hs fun i => f i ⊓ a
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp]
theorem whiskerLeft_id (F : C ⥤ D) {G : D ⥤ E} :
    whiskerLeft F (NatTrans.id G) = NatTrans.id (F.comp G)
-- Mathlib/Order/Filter/NAry.lean
theorem map₂_pure : map₂ m (pure a) (pure b) = pure (m a b)
-- Mathlib/Order/RelSeries.lean
@[simp] lemma head_append (p q : RelSeries r) (connect : r p.last q.head) :
    (p.append q connect).head = p.head
-- Mathlib/Algebra/Order/Monovary.lean
lemma Antivary.div_right₀ (hg₁ : 0 ≤ g₁) (hg₂ : StrongLT 0 g₂) (h₁ : Antivary f g₁)
    (h₂ : Monovary f g₂) : Antivary f (g₁ / g₂)
-- Mathlib/Data/ENNReal/Inv.lean
theorem mul_lt_of_lt_div' (h : a < b / c) : c * a < b
-- Mathlib/Order/Heyting/Basic.lean
theorem Disjoint.disjoint_sdiff_left (h : Disjoint a b) : Disjoint (a \ c) b
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem opCoproductIsoProduct_inv_comp_ι [HasCoproduct Z] (b : α) :
    (opCoproductIsoProduct Z).inv ≫ (Sigma.ι Z b).op = Pi.π (op <| Z ·) b
-- Mathlib/Order/RelSeries.lean
@[simp] lemma length_withLength [InfiniteDimensionalOrder α] (n : ℕ) :
    (LTSeries.withLength α n).length = n
-- Mathlib/Logic/Function/Basic.lean
protected theorem Bijective.surjective {f : α → β} (hf : Bijective f) : Surjective f
-- Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
theorem hasDerivAt_of_tendstoUniformlyOnFilter [NeBot l]
    (hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x))
    (hf : ∀ᶠ n : ι × 𝕜 in l ×ˢ 𝓝 x, HasDerivAt (f n.1) (f' n.1 n.2) n.2)
    (hfg : ∀ᶠ y in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))) : HasDerivAt g (g' x) x
-- Mathlib/Data/ZMod/Basic.lean
theorem RingHom.ext_zmod {n : ℕ} {R : Type*} [Semiring R] (f g : ZMod n →+* R) : f = g
-- Mathlib/LinearAlgebra/Orientation.lean
theorem orientation_map (e : Basis ι R M) (f : M ≃ₗ[R] N) :
    (e.map f).orientation = Orientation.map ι f e.orientation
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- A short complex `S` has left homology when there exists a `S.LeftHomologyData` -/
class HasLeftHomology : Prop where
  condition : Nonempty S.LeftHomologyData
-- Mathlib/Topology/MetricSpace/Completion.lean
theorem LipschitzWith.completion_map [PseudoMetricSpace β] {f : α → β} {K : ℝ≥0}
    (h : LipschitzWith K f) : LipschitzWith K (Completion.map f)
-- Mathlib/CategoryTheory/Limits/ExactFunctor.lean
@[simp]
theorem ExactFunctor.forget_map {F G : C ⥤ₑ D} (α : F ⟶ G) : (ExactFunctor.forget C D).map α = α
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem isoMk_hom_right {f g : Under X} (hr : f.right ≅ g.right) (hw : f.hom ≫ hr.hom = g.hom) :
    (isoMk hr hw).hom.right = hr.hom
-- Mathlib/Analysis/Convex/Body.lean
/-- A convex body that is symmetric contains `0`. -/
theorem zero_mem_of_symmetric (K : ConvexBody V) (h_symm : ∀ x ∈ K, - x ∈ K) : 0 ∈ K
-- Mathlib/GroupTheory/Nilpotent.lean
@[simp]
theorem upperCentralSeries_nilpotencyClass : upperCentralSeries G (Group.nilpotencyClass G) = ⊤
-- Mathlib/NumberTheory/LSeries/Convolution.lean
/-- The L-series of the (convolution) product of two `ℂ`-valued arithmetic functions `f` and `g`
equals the product of their L-series, assuming both L-series converge. -/
lemma LSeriesHasSum_mul {f g : ArithmeticFunction ℂ} {s a b : ℂ} (hf : LSeriesHasSum ↗f s a)
    (hg : LSeriesHasSum ↗g s b) :
    LSeriesHasSum ↗(f * g) s (a * b)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The Hausdorff distance satisfies the triangle inequality. -/
theorem hausdorffEdist_triangle : hausdorffEdist s u ≤ hausdorffEdist s t + hausdorffEdist t u
-- Mathlib/Order/Basic.lean
lemma mk_lt_mk_of_lt_of_le (h₁ : a₁ < a₂) (h₂ : b₁ ≤ b₂) : (a₁, b₁) < (a₂, b₂)
-- Mathlib/Analysis/Analytic/Basic.lean
/-- For `r` strictly smaller than the radius of `p`, then `‖pₙ‖ rⁿ` tends to zero exponentially:
for some `0 < a < 1`, `‖p n‖ rⁿ = o(aⁿ)`. -/
theorem isLittleO_of_lt_radius (h : ↑r < p.radius) :
    ∃ a ∈ Ioo (0 : ℝ) 1, (fun n => ‖p n‖ * (r : ℝ) ^ n) =o[atTop] (a ^ ·)
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
theorem catalan_succ' (n : ℕ) :
    catalan (n + 1) = ∑ ij ∈ antidiagonal n, catalan ij.1 * catalan ij.2
-- Mathlib/Geometry/Manifold/ContMDiffMFDeriv.lean
/-- If a function is `C^n` with `1 ≤ n` on a domain with unique derivatives, then its bundled
derivative is continuous. In this auxiliary lemma, we prove this fact when the source and target
space are model spaces in models with corners. The general fact is proved in
`ContMDiffOn.continuousOn_tangentMapWithin`-/
theorem ContMDiffOn.continuousOn_tangentMapWithin_aux {f : H → H'} {s : Set H}
    (hf : ContMDiffOn I I' n f s) (hn : 1 ≤ n) (hs : UniqueMDiffOn I s) :
    ContinuousOn (tangentMapWithin I I' f s) (π E (TangentSpace I) ⁻¹' s)
-- Mathlib/LinearAlgebra/Span.lean
theorem span_insert (x) (s : Set M) : span R (insert x s) = (R ∙ x) ⊔ span R s
-- Mathlib/Data/Set/Enumerate.lean
theorem enumerate_eq_none :
    ∀ {s n₁ n₂}, enumerate sel s n₁ = none → n₁ ≤ n₂ → enumerate sel s n₂ = none
-- Mathlib/Data/Complex/Abs.lean
lemma abs_eq_sqrt_sq_add_sq (z : ℂ) : abs z = (z.re ^ 2 + z.im ^ 2).sqrt
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem coe_sub {R : Type u} {A : Type v} [CommRing R] [Ring A] [Algebra R A]
    {S : Subalgebra R A} (x y : S) : (↑(x - y) : A) = ↑x - ↑y
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
@[simp]
lemma measure_compl_sigmaFiniteSet (μ : Measure α) [SigmaFinite μ] : μ μ.sigmaFiniteSetᶜ = 0
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
/-- `SatisfiesM` distributes over `>>=`, weakest precondition version. -/
protected theorem bind_pre [Monad m] [LawfulMonad m] {f : α → m β}
    (hx : SatisfiesM (fun a => SatisfiesM q (f a)) x) :
    SatisfiesM q (x >>= f)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- The **lower Lebesgue integral** of a function `f` with respect to a measure `μ`. -/
irreducible_def lintegral {_ : MeasurableSpace α} (μ : Measure α) (f : α → ℝ≥0∞) : ℝ≥0∞
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp]
theorem schwartzSeminormFamily_apply_zero :
    schwartzSeminormFamily 𝕜 E F 0 = SchwartzMap.seminorm 𝕜 0 0
-- Mathlib/Logic/Basic.lean
@[simp] theorem exists_unique_eq' {a' : α} : ∃! a, a' = a
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
theorem eval_surjective (n : ℕ) : Function.Surjective (eval I M n)
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- Construct a left lift along `g : c ⟶ a` from a left lift along `𝟙 c ≫ g`. -/
@[simps!]
def ofIdComp (t : LeftLift f (𝟙 c ≫ g)) : LeftLift f g
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem enumFrom_singleton (x : α) (n : ℕ) : enumFrom n [x] = [(n, x)]
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_nonempty_index (s : Set α) (t : s.Nonempty → Set β) :
    ⋃ h, t h = ⋃ x ∈ s, t ⟨x, ‹_›⟩
-- Mathlib/Data/Complex/Exponential.lean
private theorem sinh_add_aux {a b c d : ℂ} :
    (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d)
-- Mathlib/RingTheory/Etale/Basic.lean
/-- Being étale is transported via algebra isomorphisms. -/
theorem of_equiv [Etale R A] (e : A ≃ₐ[R] B) : Etale R B
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem append_right_cons {n m} {α : Type*} (xs : Fin n → α) (y : α) (ys : Fin m → α) :
    Fin.append xs (Fin.cons y ys) =
      Fin.append (Fin.snoc xs y) ys ∘ Fin.cast (Nat.succ_add_eq_add_succ ..).symm
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- Let `X` be a topological space, `𝔖` a family of compact subsets of `X`, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the topologies
of uniform convergence on `𝔖` and pointwise convergence on `⋃₀ 𝔖` induce the same topology on  `ι`.

In particular, pointwise convergence and compact convergence coincide on an equicontinuous
subset of `X → α`.

This is a consequence of `EquicontinuousOn.comap_uniformOnFun_eq` stated in terms of `Inducing`
for convenuence. -/
lemma EquicontinuousOn.inducing_uniformOnFun_iff_pi' [TopologicalSpace ι]
    {𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
    (F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
    Inducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
    Inducing ((⋃₀ 𝔖).restrict ∘ F)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_add_not_infinite {x y : ℝ*} :
    InfinitePos x → ¬Infinite y → InfinitePos (x + y)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_add_one (a : α) : round (a + 1) = round a + 1
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_range {f : ι → α} {g : α → Set β} : ⋂ x ∈ range f, g x = ⋂ y, g (f y)
-- Mathlib/RingTheory/Finiteness.lean
theorem iff_addGroup_fg {G : Type*} [AddCommGroup G] : Module.Finite ℤ G ↔ AddGroup.FG G
-- Mathlib/Data/PFun.lean
theorem preimage_subset_core (f : α →. β) (s : Set β) : f.preimage s ⊆ f.core s
-- Mathlib/Algebra/Lie/Classical.lean
theorem pso_inv {i : R} (hi : i * i = -1) : Pso p q R i * Pso p q R (-i) = 1
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
@[simp]
theorem leftComm_tmul (m : M) (p : P) (q : Q) :
    leftComm R A M P Q (m ⊗ₜ (p ⊗ₜ q)) = p ⊗ₜ (m ⊗ₜ q)
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
/-- If `f : P ⟶ R` and `g : Q ⟶ R` are morphisms and `p : P` and `q : Q` are pseudoelements such
    that `f p = g q`, then there is some `s : pullback f g` such that `fst s = p` and `snd s = q`.

    Remark: Borceux claims that `s` is unique, but this is false. See
    `Counterexamples/Pseudoelement.lean` for details. -/
theorem pseudo_pullback {P Q R : C} {f : P ⟶ R} {g : Q ⟶ R} {p : P} {q : Q} :
    f p = g q →
      ∃ s, pullback.fst f g s = p ∧ pullback.snd f g s = q
-- Mathlib/CategoryTheory/Localization/Predicate.lean
@[simp]
lemma compLeft_iso (W) (F : D ⥤ E) : Localization.Lifting.iso L W (L ⋙ F) F = Iso.refl _
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_quot_le {α : Type u} {r : α → α → Prop} : #(Quot r) ≤ #α
-- Mathlib/Topology/FiberBundle/Basic.lean
/-- Given a type `E` equipped with a fiber bundle structure, this is a `Prop` typeclass
for trivializations of `E`, expressing that a trivialization is in the designated atlas for the
bundle.  This is needed because lemmas about the linearity of trivializations or the continuity (as
functions to `F →L[R] F`, where `F` is the model fiber) of the transition functions are only
expected to hold for trivializations in the designated atlas. -/
@[mk_iff]
class MemTrivializationAtlas [FiberBundle F E] (e : Trivialization F (π F E)) : Prop where
  out : e ∈ trivializationAtlas F E
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_Ici {a : ℝ} : volume (Ici a) = ∞
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Reflection in the `Submodule.map` of a subspace. -/
theorem reflection_map_apply {E E' : Type*} [NormedAddCommGroup E] [NormedAddCommGroup E']
    [InnerProductSpace 𝕜 E] [InnerProductSpace 𝕜 E'] (f : E ≃ₗᵢ[𝕜] E') (K : Submodule 𝕜 E)
    [HasOrthogonalProjection K] (x : E') :
    reflection (K.map (f.toLinearEquiv : E →ₗ[𝕜] E')) x = f (reflection K (f.symm x))
-- Mathlib/RingTheory/Norm/Basic.lean
@[simp]
theorem norm_zero [Nontrivial S] [Module.Free R S] [Module.Finite R S] : norm R (0 : S) = 0
-- Mathlib/LinearAlgebra/StdBasis.lean
@[simp]
theorem basisFun_apply [DecidableEq η] (i) : basisFun R η i = stdBasis R (fun _ : η => R) i 1
-- Mathlib/CategoryTheory/Preadditive/Generator.lean
theorem isCoseparator_iff_faithful_preadditiveYoneda (G : C) :
    IsCoseparator G ↔ (preadditiveYoneda.obj G).Faithful
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
theorem preservesEpimorphsisms_of_adjunction {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G) :
    PreservesEpimorphisms F
-- Mathlib/Algebra/Associated/Basic.lean
theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul (hp : Prime p) {a b : α} {k l : ℕ} :
    p ^ k ∣ a → p ^ l ∣ b → p ^ (k + l + 1) ∣ a * b → p ^ (k + 1) ∣ a ∨ p ^ (l + 1) ∣ b
-- Mathlib/MeasureTheory/Measure/AddContent.lean
lemma addContent_biUnion_le {ι : Type*} (hC : IsSetRing C) {s : ι → Set α}
    {S : Finset ι} (hs : ∀ n ∈ S, s n ∈ C) :
    m (⋃ i ∈ S, s i) ≤ ∑ i ∈ S, m (s i)
-- Mathlib/RingTheory/ZMod.lean
/-- Two ring homomorphisms into `ZMod n` with equal kernels are equal. -/
theorem ZMod.ringHom_eq_of_ker_eq {n : ℕ} {R : Type*} [CommRing R] (f g : R →+* ZMod n)
    (h : RingHom.ker f = RingHom.ker g) : f = g
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Given a collection of isomorphisms between corresponding summands of a pair of biproducts
indexed by the same type, we obtain an isomorphism between the biproducts. -/
@[simps]
def biproduct.mapIso {f g : J → C} [HasBiproduct f] [HasBiproduct g] (p : ∀ b, f b ≅ g b) :
    ⨁ f ≅ ⨁ g
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
/-- The functional equation for the Jacobi theta function: `jacobiTheta₂ z τ` is an explict factor
times `jacobiTheta₂ (z / τ) (-1 / τ)`. This is the key lemma behind the proof of the functional
equation for L-series of even Dirichlet characters. -/
theorem jacobiTheta₂_functional_equation (z τ : ℂ) : jacobiTheta₂ z τ =
    1 / (-I * τ) ^ (1 / 2 : ℂ) * cexp (-π * I * z ^ 2 / τ) * jacobiTheta₂ (z / τ) (-1 / τ)
-- Mathlib/RingTheory/AlgebraTower.lean
theorem Basis.isScalarTower_finsupp {ι} (b : Basis ι S A) : IsScalarTower R S (ι →₀ S)
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
theorem app_left_eq_ι (a) : K.π.app (WalkingMulticospan.left a) = K.ι a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem toOuterMeasure_le : μ₁.toOuterMeasure ≤ μ₂.toOuterMeasure ↔ μ₁ ≤ μ₂
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem _root_.IsSMulRegular.polynomial {S : Type*} [Monoid S] [DistribMulAction S R] {a : S}
    (ha : IsSMulRegular R a) : IsSMulRegular R[X] a
-- Mathlib/Algebra/Symmetrized.lean
@[to_additive (attr := simp)]
theorem sym_one [One α] : sym (1 : α) = 1
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma hasHomology_of_isIso_leftRightHomologyComparison'
    (h₁ : S.LeftHomologyData) (h₂ : S.RightHomologyData)
    [IsIso (leftRightHomologyComparison' h₁ h₂)] :
    S.HasHomology
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
/--
Consider the contravariant functors between compact Hausdorff spaces and commutative unital
C⋆algebras `F : Cpct → CommCStarAlg := X ↦ C(X, ℂ)` and
`G : CommCStarAlg → Cpct := A → characterSpace ℂ A` whose actions on morphisms are given by
`WeakDual.CharacterSpace.compContinuousMap` and `ContinuousMap.compStarAlgHom'`, respectively.

Then `η : id → G ∘ F := WeakDual.CharacterSpace.homeoEval` is a natural isomorphism implementing
(half of) the duality between these categories. That is, for compact Hausdorff spaces `X` and `Y`,
`f : C(X, Y)` the following diagram commutes:

```
X  --- η X ---> characterSpace ℂ C(X, ℂ)

|                     |

f                  (G ∘ F) f

|                     |
V                     V

Y  --- η Y ---> characterSpace ℂ C(Y, ℂ)
```
-/
lemma WeakDual.CharacterSpace.homeoEval_naturality {X Y 𝕜 : Type*} [RCLike 𝕜] [TopologicalSpace X]
    [CompactSpace X] [T2Space X] [TopologicalSpace Y] [CompactSpace Y] [T2Space Y] (f : C(X, Y)) :
    (homeoEval Y 𝕜 : C(_, _)).comp f =
      (f.compStarAlgHom' 𝕜 𝕜 |> compContinuousMap).comp (homeoEval X 𝕜 : C(_, _))
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem ofLinear_apply {h₁ h₂} (x : M) : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂) x = f x