ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
@[to_additive]
theorem locallyCompactSpace_of_hasBasis (V : ℕ → Set Y)
    (hV : ∀ {n x}, x ∈ V n → x * x ∈ V n → x ∈ V (n + 1))
    (hVo : Filter.HasBasis (nhds 1) (fun _ ↦ True) V) :
    LocallyCompactSpace (ContinuousMonoidHom X Y)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem head?_cons : @head? α (a::l) = some a
-- Mathlib/Order/Atoms.lean
theorem isSimpleOrder_iff [BoundedOrder α] [BoundedOrder β] (f : α ≃o β) :
    IsSimpleOrder α ↔ IsSimpleOrder β
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csInf_image2_eq_csInf_csInf (h₁ : ∀ b, GaloisConnection (l₁ b) (swap u b))
    (h₂ : ∀ a, GaloisConnection (l₂ a) (u a)) :
    s.Nonempty → BddBelow s → t.Nonempty → BddBelow t → sInf (image2 u s t) = u (sInf s) (sInf t)
-- Mathlib/Topology/CompactOpen.lean
lemma isClosed_setOf_mapsTo {t : Set Y} (ht : IsClosed t) (s : Set X) :
    IsClosed {f : C(X, Y) | MapsTo f s t}
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem freeGroupCongr_trans {α β γ} (e : α ≃ β) (f : β ≃ γ) :
    (freeGroupCongr e).trans (freeGroupCongr f) = freeGroupCongr (e.trans f)
-- Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean
nonrec theorem BoundedAtFilter.add [SeminormedAddCommGroup β] {l : Filter α} {f g : α → β}
    (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f + g)
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
@[simp]
theorem det_transvection_of_ne (h : i ≠ j) (c : R) : det (transvection i j c) = 1
-- Mathlib/Data/Nat/PartENat.lean
theorem not_dom_iff_eq_top {x : PartENat} : ¬x.Dom ↔ x = ⊤
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem lift_comp_inl (f : M →* P) (g : N →* P) : (lift f g).comp inl = f
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma orbit_submonoid_subset (S : Submonoid M) (a : α) : orbit S a ⊆ orbit M a
-- Mathlib/Algebra/Homology/ShortComplex/Ab.lean
@[simp]
lemma abLeftHomologyData_f' : S.abLeftHomologyData.f' = S.abToCycles
-- Mathlib/Algebra/Field/Basic.lean
@[simp] lemma ofLex_ratCast [RatCast α] (n : ℚ) : (ofLex n : α) = n
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_of_monotone_of_subseq [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι}
    (h : Monotone u) {l : Filter ι'} [NeBot l] (H : Tendsto (u ∘ φ) l atBot) :
    Tendsto u atBot atBot
-- Mathlib/Analysis/Convex/Topology.lean
/-- `stdSimplex ℝ ι` is bounded. -/
theorem bounded_stdSimplex : IsBounded (stdSimplex ℝ ι)
-- Mathlib/Algebra/Homology/QuasiIso.lean
lemma quasiIso_iff_comp_left (φ : K ⟶ L) (φ' : L ⟶ M) [∀ i, K.HasHomology i]
    [∀ i, L.HasHomology i] [∀ i, M.HasHomology i]
    [hφ : QuasiIso φ] :
    QuasiIso (φ ≫ φ') ↔ QuasiIso φ'
-- Mathlib/Algebra/Ring/InjSurj.lean
/-- Pullback a `RightDistribClass` instance along an injective function. -/
theorem rightDistribClass [Mul α] [Add α] [RightDistribClass α] (add : ∀ x y, f (x + y) = f x + f y)
    (mul : ∀ x y, f (x * y) = f x * f y) : RightDistribClass β
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem zero_of_target_iso_zero' {X Y : C} (f : X ⟶ Y) (i : IsIsomorphic Y 0) : f = 0
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
@[simp] theorem iSup_genEigenspace_eq_genEigenspace_finrank
    [FiniteDimensional K V] (f : End K V) (μ : K) :
    ⨆ k, f.genEigenspace μ k = f.genEigenspace μ (finrank K V)
-- Mathlib/FieldTheory/Galois.lean
theorem of_fixedField_eq_bot [FiniteDimensional F E]
    (h : IntermediateField.fixedField (⊤ : Subgroup (E ≃ₐ[F] E)) = ⊥) : IsGalois F E
-- Mathlib/Algebra/Order/Floor.lean
/-- There exists at most one `FloorRing` structure on a given linear ordered ring. -/
theorem subsingleton_floorRing {α} [LinearOrderedRing α] : Subsingleton (FloorRing α)
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
/-- If, for all `x` in a set `s`, one has frequently `q < ρ a / μ a`, then `q * μ s ≤ ρ s`, as
proved in `measure_le_of_frequently_le`. Since `ρ a / μ a` tends almost everywhere to
`v.limRatioMeas hρ x`, the same property holds for sets `s` on which `q < v.limRatioMeas hρ`. -/
theorem mul_measure_le_of_subset_lt_limRatioMeas {q : ℝ≥0} {s : Set α}
    (h : s ⊆ {x | (q : ℝ≥0∞) < v.limRatioMeas hρ x}) : (q : ℝ≥0∞) * μ s ≤ ρ s
-- Mathlib/Topology/Separation.lean
/-- A locally compact Hausdorff totally disconnected space has a basis with clopen elements. -/
theorem loc_compact_Haus_tot_disc_of_zero_dim [TotallyDisconnectedSpace H] :
    IsTopologicalBasis { s : Set H | IsClopen s }
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem iso_inv_image_comp_eq_iff_eq_map {C : G.ConnectedComponent} :
    G.connectedComponentMk (φ.symm v') = C ↔ G'.connectedComponentMk v' = C.map φ
-- Mathlib/Algebra/Order/Floor.lean
theorem round_eq (x : α) : round x = ⌊x + 1 / 2⌋
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem algHomOfLinearMapTensorProduct_apply (f h_mul h_one x) :
    (algHomOfLinearMapTensorProduct f h_mul h_one : A ⊗[R] B →ₐ[S] C) x = f x
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem coeFn_ofInjective [L.IsAlgebraic] {f : M →[L] N} (hf : Function.Injective f) :
    (ofInjective hf : M → N) = f
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive]
theorem update_inv [∀ i, Inv (f i)] [DecidableEq I] (f₁ : ∀ i, f i) (i : I) (x₁ : f i) :
    update f₁⁻¹ i x₁⁻¹ = (update f₁ i x₁)⁻¹
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
/-- A subgroupoid is wide if its carrier set is all of `C`-/
structure IsWide : Prop where
  wide : ∀ c, 𝟙 c ∈ S.arrows c c
-- Mathlib/MeasureTheory/Function/Jacobian.lean
theorem addHaar_image_le_lintegral_abs_det_fderiv_aux2 (hs : MeasurableSet s) (h's : μ s ≠ ∞)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) :
    μ (f '' s) ≤ ∫⁻ x in s, ENNReal.ofReal |(f' x).det| ∂μ
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem beth_strictMono : StrictMono beth
-- Mathlib/Algebra/Group/Semiconj/Defs.lean
/-- Equality behind `SemiconjBy a x y`; useful for rewriting. -/
@[to_additive "Equality behind `AddSemiconjBy a x y`; useful for rewriting."]
protected theorem eq [Mul S] {a x y : S} (h : SemiconjBy a x y) : a * x = y * a
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- Taking sub-families preserves uniform equicontinuity. -/
theorem UniformEquicontinuous.comp {F : ι → β → α} (h : UniformEquicontinuous F) (u : κ → ι) :
    UniformEquicontinuous (F ∘ u)
-- Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean
/-- For `κ' := map κ (Prod.map (id : β → β) e) (measurable_id.prod_map he.measurable)`, the
hypothesis `hη` is `fst κ' ⊗ₖ η = κ'`. With that hypothesis,
`fst κ ⊗ₖ borelMarkovFromReal κ η = κ`.-/
lemma compProd_fst_borelMarkovFromReal (κ : Kernel α (β × Ω)) [IsSFiniteKernel κ]
    (η : Kernel (α × β) ℝ) [IsSFiniteKernel η]
    (hη : (fst (map κ (Prod.map (id : β → β) (embeddingReal Ω))
        (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable))) ⊗ₖ η
      = map κ (Prod.map (id : β → β) (embeddingReal Ω))
        (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable)) :
    fst κ ⊗ₖ borelMarkovFromReal Ω η = κ
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_le_pred_iff_of_not_isMin (ha : ¬IsMin a) (hb : ¬IsMin b) :
    pred a ≤ pred b ↔ a ≤ b
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_symm_half (m : ℕ) : choose (2 * m + 1) (m + 1) = choose (2 * m + 1) m
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem stronglyMeasurable_derivWithin_Ici :
    StronglyMeasurable (fun x ↦ derivWithin f (Ici x) x)
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem restrictDom_comp_subtype (s : Set α) [DecidablePred (· ∈ s)] :
    (restrictDom M R s).comp (Submodule.subtype _) = LinearMap.id
-- Mathlib/Data/Nat/Squarefree.lean
theorem squarefree_iff_minSqFac {n : ℕ} : Squarefree n ↔ n.minSqFac = none
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem unique_diff_preimage {s : Set H} (hs : IsOpen s) :
    UniqueDiffOn 𝕜 (I.symm ⁻¹' s ∩ range I)
-- Mathlib/Data/Finset/Basic.lean
theorem erase_ssubset_insert (s : Finset α) (a : α) : s.erase a ⊂ insert a s
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Subperm.countP_le (p : α → Bool) {l₁ l₂ : List α} : l₁ <+~ l₂ → countP p l₁ ≤ countP p l₂
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem Filter.Tendsto.vsub {l : Filter α} {f g : α → P} {x y : P} (hf : Tendsto f l (𝓝 x))
    (hg : Tendsto g l (𝓝 y)) : Tendsto (f -ᵥ g) l (𝓝 (x -ᵥ y))
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem dirac_prod_dirac {x : α} {y : β} : (dirac x).prod (dirac y) = dirac (x, y)
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : UniformContinuous g)
    (h : ∀ a : α, f a = g (ι a)) : pkg.extend f = g
-- Mathlib/Combinatorics/Derangements/Finite.lean
theorem card_derangements_eq_numDerangements (α : Type*) [Fintype α] [DecidableEq α] :
    card (derangements α) = numDerangements (card α)
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem support_monomial' (n) (a : R) : (monomial n a).support ⊆ singleton n
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_mono : Monotone (ceil : α → ℤ)
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- If `φ` satisfies `‖φ‖ ≤ C`, then the same is true for the lifted morphism. -/
theorem norm_lift_le (φ : NormedAddGroupHom V₁ V) (h : f.comp φ = g.comp φ) (C : ℝ) (hφ : ‖φ‖ ≤ C) :
    ‖lift φ h‖ ≤ C
-- Mathlib/CategoryTheory/Sums/Basic.lean
/-- `inr_` is the functor `X ↦ inr X`. -/
@[simps]
def inr_ : D ⥤ C ⊕ D
-- Mathlib/CategoryTheory/Bicategory/Coherence.lean
theorem normalizeAux_nil_comp {a b c : B} (f : Hom a b) (g : Hom b c) :
    normalizeAux nil (f.comp g) = (normalizeAux nil f).comp (normalizeAux nil g)
-- Mathlib/Algebra/Order/Monoid/TypeTags.lean
@[simp]
theorem toAdd_lt {a b : Multiplicative α} : toAdd a < toAdd b ↔ a < b
-- Mathlib/Data/Nat/Bits.lean
theorem bodd_eq_bits_head (n : ℕ) : n.bodd = n.bits.headI
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem prod_add (ν' : Measure β) [SFinite ν'] : μ.prod (ν + ν') = μ.prod ν + μ.prod ν'
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem min_assoc : ∀ (a b c : Nat), min (min a b) c = min a (min b c)
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive (attr := simp) MeasureTheory.mem_addFundamentalInterior]
theorem mem_fundamentalInterior :
    x ∈ fundamentalInterior G s ↔ x ∈ s ∧ ∀ g : G, g ≠ 1 → x ∉ g • s
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive]
theorem snd_pow : (s ^ n).snd = s.snd ^ n
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_mem (s : Set α) (w : ∀ᵉ (x ∈ s) (y ∈ s), x ⊔ y ∈ s) {ι : Type*}
    (t : Finset ι) (H : t.Nonempty) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.sup' H p ∈ s
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem eq_true (h : p) : p = True
-- Mathlib/CategoryTheory/Preadditive/EndoFunctor.lean
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F)
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
lemma map_surjective {X Y : C} :
    Function.Surjective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y))
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp, norm_cast]
theorem coe_sub (z1 z2 : ℤ_[p]) : ((z1 - z2 : ℤ_[p]) : ℚ_[p]) = z1 - z2
-- Mathlib/NumberTheory/NumberField/Norm.lean
theorem Algebra.coe_trace_int : (Algebra.trace ℤ _ x : ℚ) = Algebra.trace ℚ K (x : K)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_lt_of_le_one_of_lt [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α} (ha : a ≤ 1)
    (hb : b < c) :
    a * b < c
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_map : (s.map f : Set L) = f '' s
-- Mathlib/Algebra/Ring/Idempotents.lean
theorem of_isIdempotent [Std.IdempotentOp (α := M) (· * ·)] (a : M) : IsIdempotentElem a
-- Mathlib/Data/Set/Lattice.lean
theorem image_iInter₂ {f : α → β} (hf : Bijective f) (s : ∀ i, κ i → Set α) :
    (f '' ⋂ (i) (j), s i j) = ⋂ (i) (j), f '' s i j
-- Mathlib/Data/Finset/Image.lean
theorem map_injective (f : α ↪ β) : Injective (map f)
-- Mathlib/Data/List/Infix.lean
theorem tail_subset (l : List α) : tail l ⊆ l
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem aeval_esymm_eq_multiset_esymm [Algebra R S] (f : σ → S) (n : ℕ) :
    aeval f (esymm σ R n) = (univ.val.map f).esymm n
-- Mathlib/Analysis/Normed/Group/Completion.lean
@[simp]
theorem nnnorm_coe {E} [SeminormedAddCommGroup E] (x : E) : ‖(x : Completion E)‖₊ = ‖x‖₊
-- Mathlib/Order/BoundedOrder.lean
theorem fst_bot [Bot α] [Bot β] : (⊥ : α × β).fst = ⊥
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
/-- A right fraction from `X : C` to `Y : C` for `W : MorphismProperty C` consists of the
datum of an object `X' : C` and maps `s : X' ⟶ X` and `f : X' ⟶ Y` such that `W s`. -/
structure RightFraction (W : MorphismProperty C) (X Y : C) where
  /-- the auxiliary object of a right fraction -/
  {X' : C}
  /-- the denominator of a right fraction -/
  s : X' ⟶ X
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
  /-- the numerator of a right fraction -/
  f : X' ⟶ Y
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[deprecated ufm_of_decomposition_of_wfDvdMonoid (since := "2024-02-12")]
theorem ufm_of_gcd_of_wfDvdMonoid [CancelCommMonoidWithZero α] [WfDvdMonoid α]
    [DecompositionMonoid α] : UniqueFactorizationMonoid α
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiffWithinAt_comp_diffeomorph_iff {m} (h : M ≃ₘ^n⟮I, J⟯ N) {f : N → M'} {s x}
    (hm : m ≤ n) :
    ContMDiffWithinAt I I' m (f ∘ h) s x ↔ ContMDiffWithinAt J I' m f (h.symm ⁻¹' s) (h x)
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma mulIndicator_le_self (s : Set α) (f : α → M) : mulIndicator s f ≤ f
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem toAdd_mul [Add α] (x y : Multiplicative α) : toAdd (x * y) = toAdd x + toAdd y
-- Mathlib/Data/Real/Sqrt.lean
/-- The natural square root is at most the real square root -/
theorem nat_sqrt_le_real_sqrt {a : ℕ} : ↑(Nat.sqrt a) ≤ √(a : ℝ)
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.convolution_integrand_bound_left (hcf : HasCompactSupport f)
    (hf : Continuous f) {x t : G} {s : Set G} (hx : x ∈ s) :
    ‖L (f (x - t)) (g t)‖ ≤
      (-tsupport f + s).indicator (fun t => (‖L‖ * ⨆ i, ‖f i‖) * ‖g t‖) t
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Mono.lean
/-- `f` is an epi if the pushout cocone `(𝟙 X, 𝟙 X)` is a colimit for the pair `(f, f)`.
The converse is given in `PushoutCocone.isColimitMkIdId`.
-/
theorem epi_of_isColimitMkIdId (f : X ⟶ Y)
    (t : IsColimit (mk (𝟙 Y) (𝟙 Y) rfl : PushoutCocone f f)) : Epi f
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
lemma adicCompletion.mul_nonZeroDivisor_mem_adicCompletionIntegers (v : HeightOneSpectrum R)
    (a : v.adicCompletion K) : ∃ b ∈ R⁰, a * b ∈ v.adicCompletionIntegers K
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem principal_eq_iff_eq {s t : Set α} : 𝓟 s = 𝓟 t ↔ s = t
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem univ_mem_measurableCylinders (α : ι → Type*) [∀ i, MeasurableSpace (α i)] :
    Set.univ ∈ measurableCylinders α
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem hom_bind₁ (f : MvPolynomial τ R →+* S) (g : σ → MvPolynomial τ R) (φ : MvPolynomial σ R) :
    f (bind₁ g φ) = eval₂Hom (f.comp C) (fun i => f (g i)) φ
-- Mathlib/GroupTheory/Coprod/Basic.lean
/-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : PUnit ∗ M ≃* M
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_inter_Iic (a b c : α) : Ioc a b ∩ Iic c = Ioc a (b ⊓ c)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@[simp]
theorem contractRight_ι (x : M) : ι Q x⌊d = algebraMap R _ (d x)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
/-- See note [partially-applied ext lemmas]. -/
@[ext high]
theorem hom_ext {A : Type*} [Semiring A] [Algebra R A] {f g : CliffordAlgebra Q →ₐ[R] A} :
    f.toLinearMap.comp (ι Q) = g.toLinearMap.comp (ι Q) → f = g
-- Mathlib/Analysis/SumIntegralComparisons.lean
theorem MonotoneOn.sum_le_integral_Ico (hab : a ≤ b) (hf : MonotoneOn f (Set.Icc a b)) :
    ∑ x ∈ Finset.Ico a b, f x ≤ ∫ x in a..b, f x
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem isSome_iff : ∀ {I : WithBot (Box ι)}, I.isSome ↔ (I : Set (ι → ℝ)).Nonempty
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem pullbackArrows_comm [HasPullbacks C] {X Y : C} (f : Y ⟶ X) (R : Presieve X) :
    Sieve.generate (R.pullbackArrows f) = (Sieve.generate R).pullback f
-- Mathlib/CategoryTheory/Subobject/Basic.lean
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem underlyingIso_arrow {X Y : C} (f : X ⟶ Y) [Mono f] :
    (underlyingIso f).inv ≫ (Subobject.mk f).arrow = f
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem coe_pi {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)] (f : ∀ i, M [⋀^ι]→L[R] M' i) :
    ⇑(pi f) = fun m j => f j m
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoMod_mem_Ico (a b : α) : toIcoMod hp a b ∈ Set.Ico a (a + p)
-- Mathlib/Algebra/Algebra/Hom.lean
@[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₐ[R] A)
-- Mathlib/Data/Multiset/Fold.lean
theorem fold_cons_right (b a : α) (s : Multiset α) : (a ::ₘ s).fold op b = s.fold op b * a
-- Mathlib/Algebra/Polynomial/BigOperators.lean
theorem coeff_zero_prod : (∏ i ∈ s, f i).coeff 0 = ∏ i ∈ s, (f i).coeff 0
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem continuousOn_symm (e : Trivialization F (π F E)) :
    ContinuousOn (fun z : B × F => TotalSpace.mk' F z.1 (e.symm z.1 z.2)) (e.baseSet ×ˢ univ)
-- Mathlib/Control/Bitraversable/Basic.lean
/-- Bifunctor. This typeclass asserts that a lawless bitraversable bifunctor is lawful. -/
class LawfulBitraversable (t : Type u → Type u → Type u) [Bitraversable t] extends
  LawfulBifunctor t : Prop where
  -- Porting note: need to specify `m := Id` because `id` no longer has a `Monad` instance
  id_bitraverse : ∀ {α β} (x : t α β), bitraverse (m := Id) pure pure x = pure x
  comp_bitraverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      {α α' β β' γ γ'} (f : β → F γ) (f' : β' → F γ') (g : α → G β) (g' : α' → G β') (x : t α α'),
      bitraverse (Comp.mk ∘ map f ∘ g) (Comp.mk ∘ map f' ∘ g') x =
        Comp.mk (bitraverse f f' <$> bitraverse g g' x)
  bitraverse_eq_bimap_id :
    ∀ {α α' β β'} (f : α → β) (f' : α' → β') (x : t α α'),
      bitraverse (m := Id) (pure ∘ f) (pure ∘ f') x = pure (bimap f f' x)
  binaturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α α' β β'} (f : α → F β) (f' : α' → F β') (x : t α α'),
      η (bitraverse f f' x) = bitraverse (@η _ ∘ f) (@η _ ∘ f') x
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_univ (e : E ≃L[𝕜] F) : dimH (univ : Set E) = dimH (univ : Set F)
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem Module.Finite.not_linearIndependent_of_infinite {ι : Type*} [Infinite ι]
    (v : ι → M) : ¬LinearIndependent R v
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem isUnitTrinomial_iff' :
    p.IsUnitTrinomial ↔
      (p * p.mirror).coeff (((p * p.mirror).natDegree + (p * p.mirror).natTrailingDegree) / 2) =
        3
-- Mathlib/Data/Prod/Basic.lean
theorem swap_surjective : Function.Surjective (@swap α β)
-- Mathlib/RingTheory/Idempotents.lean
/-- A family of complete orthogonal idempotents induces an isomorphism `R ≃+* ∏ R ⧸ ⟨1 - eᵢ⟩` -/
lemma CompleteOrthogonalIdempotents.bijective_pi (he : CompleteOrthogonalIdempotents e) :
    Function.Bijective (Pi.ringHom fun i ↦ Ideal.Quotient.mk (Ideal.span {1 - e i}))
-- Mathlib/Data/Semiquot.lean
theorem nonempty (q : Semiquot α) : q.s.Nonempty
-- Mathlib/Data/Finset/Basic.lean
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem toFinset_nonempty_iff (l : List α) : l.toFinset.Nonempty ↔ l ≠ []
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Iic_mem_atBot [Preorder α] (a : α) : Iic a ∈ (atBot : Filter α)
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal_apply_eq (M : o → Matrix m n α) (i j k) :
    blockDiagonal M (i, k) (j, k) = M k i j
-- Mathlib/Data/Complex/Module.lean
lemma Complex.coe_selfAdjointEquiv (z : selfAdjoint ℂ) :
    (selfAdjointEquiv z : ℂ) = z
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- The natural transformation `S.X₁ ⟶ S.cycles` for all short complexes `S`. -/
@[simps]
noncomputable def toCyclesNatTrans :
    π₁ ⟶ cyclesFunctor C
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma imageSieve_mem {F G : Cᵒᵖ ⥤ A} (f : F ⟶ G) [IsLocallySurjective J f] {U : Cᵒᵖ}
    (s : G.obj U) : imageSieve f s ∈ J U.unop
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem Prime.eq_two_or_odd' {p : ℕ} (hp : Prime p) : p = 2 ∨ Odd p
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem limit.lift_post (c : Cone F) :
    G.map (limit.lift F c) ≫ limit.post F G = limit.lift (F ⋙ G) (G.mapCone c)
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem disjoint_toDual_iff [SemilatticeSup α] [OrderTop α] {a b : α} :
    Disjoint (toDual a) (toDual b) ↔ Codisjoint a b
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_inter (x y : ZFSet.{u}) : (x ∩ y).toSet = x.toSet ∩ y.toSet
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem rightHom_inl (n : N) : rightHom (inl n : N ⋊[φ] G) = 1
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_neg_of_nonpos_of_neg {a b : Int} (ha : a ≤ 0) (hb : b < 0) : a + b < 0
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_apply_left (a : α) : toIocDiv hp a a = -1
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
@[simp]
theorem curry_uncurry (f : X ⟶ A ⟹ Y) : curry (uncurry f) = f
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp] theorem toHopfAlgEquiv_trans (e : X ≅ Y) (f : Y ≅ Z) :
    toHopfAlgEquiv (e ≪≫ f) = e.toHopfAlgEquiv.trans f.toHopfAlgEquiv
-- Mathlib/Data/PFun.lean
theorem preimage_mono {s t : Set β} (h : s ⊆ t) : f.preimage s ⊆ f.preimage t
-- Mathlib/Topology/LocallyFinite.lean
/-- If `f : β → Set α` is a locally finite family of closed sets, then for any `x : α`, the
intersection of the complements to `f i`, `x ∉ f i`, is a neighbourhood of `x`. -/
theorem iInter_compl_mem_nhds (hf : LocallyFinite f) (hc : ∀ i, IsClosed (f i)) (x : X) :
    (⋂ (i) (_ : x ∉ f i), (f i)ᶜ) ∈ 𝓝 x
-- Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
theorem Matrix.Represents.add {A A' : Matrix ι ι R} {f f' : Module.End R M} (h : A.Represents b f)
    (h' : Matrix.Represents b A' f') : (A + A').Represents b (f + f')
-- Mathlib/Data/Sign.lean
theorem Right.sign_neg [CovariantClass α α (Function.swap (· + ·)) (· < ·)] (a : α) :
    sign (-a) = -sign a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma monotone_rpow_of_base_ge_one {b : ℝ} (hb : 1 ≤ b) :
    Monotone (b ^ · : ℝ → ℝ)
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
theorem map_zsmul {X Y : C} {f : X ⟶ Y} {r : ℤ} : F.map (r • f) = r • F.map f
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
lemma Shatters.card_le_vcDim (hs : 𝒜.Shatters s) : s.card ≤ 𝒜.vcDim
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveLeft = xL
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem closedBall_eq_empty : closedBall x ε = ∅ ↔ ε < 0
-- Mathlib/Data/Finset/Card.lean
/-- Reorder a finset.

The difference with `Finset.card_nbij` is that the bijection is specified with an inverse, rather
than as a surjective injection.

The difference with `Finset.card_bij'` is that the bijection and its inverse are non-dependent
functions, rather than being allowed to use membership of the domains.

The difference with `Finset.card_equiv` is that bijectivity is only required to hold on the domains,
rather than on the entire types. -/
lemma card_nbij' (i : α → β) (j : β → α) (hi : ∀ a ∈ s, i a ∈ t) (hj : ∀ a ∈ t, j a ∈ s)
    (left_inv : ∀ a ∈ s, j (i a) = a) (right_inv : ∀ a ∈ t, i (j a) = a) : s.card = t.card
-- Mathlib/Order/Filter/Extr.lean
theorem IsMinFilter.add (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => f x + g x) l a