ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp, reassoc]
theorem pullbackRestrictIsoRestrict_inv_fst {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
    (pullbackRestrictIsoRestrict f U).inv ≫ pullback.fst f _ = (f ⁻¹ᵁ U).ι
-- Mathlib/Init/Data/Nat/Lemmas.lean
theorem eq_zero_of_mul_eq_zero : ∀ {n m : ℕ}, n * m = 0 → n = 0 ∨ m = 0
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- A submodule contained in a finite-dimensional submodule is
finite-dimensional. -/
theorem finiteDimensional_of_le {S₁ S₂ : Submodule K V} [FiniteDimensional K S₂] (h : S₁ ≤ S₂) :
    FiniteDimensional K S₁
-- Mathlib/MeasureTheory/Measure/Restrict.lean
/-- A version of the **Borel-Cantelli lemma**: if `sᵢ` is a sequence of sets such that
`∑ μ sᵢ` exists, then for almost all `x`, `x` does not belong to almost all `sᵢ`. -/
theorem ae_eventually_not_mem {s : ℕ → Set α} (hs : (∑' i, μ (s i)) ≠ ∞) :
    ∀ᵐ x ∂μ, ∀ᶠ n in atTop, x ∉ s n
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_prod (since := "2024-06-26")]
protected theorem map_prod {ι : Type*} (f : ι → A) (s : Finset ι) :
    φ (∏ x ∈ s, f x) = ∏ x ∈ s, φ (f x)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem valid_next {p : Pos} (h : p.Valid s) (h₂ : p < s.endPos) : (next s p).Valid s
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem zero_mem : (0 : A) ∈ S
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
/-- All the `Q q` coincide with `0` in degree 0. -/
@[simp]
theorem Q_f_0_eq (q : ℕ) : ((Q q).f 0 : X _[0] ⟶ X _[0]) = 0
-- Mathlib/Data/Finsupp/Defs.lean
theorem eq_single_iff {f : α →₀ M} {a b} : f = single a b ↔ f.support ⊆ {a} ∧ f a = b
-- Mathlib/CategoryTheory/Monad/Equalizer.lean
/-- The fork map in the equalizer diagram we will construct. -/
@[simps]
def CofreeEqualizer.ι : X ⟶ (Comonad.cofree T).obj X.A
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem isUnit_one_sub_smul_of_lt_inv_radius {a : A} {z : 𝕜} (h : ↑‖z‖₊ < (spectralRadius 𝕜 a)⁻¹) :
    IsUnit (1 - z • a)
-- Mathlib/Algebra/Module/Submodule/LinearMap.lean
theorem restrict_eq_codRestrict_domRestrict {f : M →ₗ[R] M₁} {p : Submodule R M}
    {q : Submodule R M₁} (hf : ∀ x ∈ p, f x ∈ q) :
    f.restrict hf = (f.domRestrict p).codRestrict q fun x => hf x.1 x.2
-- Mathlib/Topology/Separation.lean
theorem isClosed_diagonal [T2Space X] : IsClosed (diagonal X)
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem degrees_add_of_disjoint [DecidableEq σ] {p q : MvPolynomial σ R}
    (h : Multiset.Disjoint p.degrees q.degrees) : (p + q).degrees = p.degrees ∪ q.degrees
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem lt_of_lt_of_le : ∀ {x y z : Bool}, x < y → y ≤ z → x < z
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem eventuallyEq_one : f =ᶠ[𝓝 c] 1
-- Mathlib/Algebra/Order/Floor.lean
theorem le_ceil (a : α) : a ≤ ⌈a⌉₊
-- Mathlib/CategoryTheory/Dialectica/Monoidal.lean
/-- The unit for the tensor `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorUnit : Dial C
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem fib_two_mul (n : ℕ) : fib (2 * n) = fib n * (2 * fib (n + 1) - fib n)
-- Mathlib/Topology/Homotopy/Contractible.lean
protected theorem Homeomorph.contractibleSpace_iff (e : X ≃ₜ Y) :
    ContractibleSpace X ↔ ContractibleSpace Y
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
@[simp]
theorem ofConjAct_inv (x : ConjAct G) : ofConjAct x⁻¹ = (ofConjAct x)⁻¹
-- Mathlib/CategoryTheory/Sigma/Basic.lean
/--
If `q₁` and `q₂` when restricted to each subcategory `C i` agree, then `q₁` and `q₂` are isomorphic.
-/
@[simps]
def natIso {q₁ q₂ : (Σi, C i) ⥤ D} (h : ∀ i, incl i ⋙ q₁ ≅ incl i ⋙ q₂) : q₁ ≅ q₂
-- Mathlib/Algebra/Polynomial/Lifts.lean
/-- If `p` lifts and `(r : R)` then `r * p` lifts. -/
theorem base_mul_mem_lifts {p : S[X]} (r : R) (hp : p ∈ lifts f) : C (f r) * p ∈ lifts f
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem nnnorm_map [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) (x : E) : ‖f x‖₊ = ‖x‖₊
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_add_one {x : ℝ} (hx : x ≠ 0) (y : ℝ) : x ^ (y + 1) = x ^ y * x
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem Monic.comp_X_add_C (hp : p.Monic) (r : R) : (p.comp (X + C r)).Monic
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[reassoc (attr := simp)]
theorem invApp_app (U : Opens X) :
    H.invApp U ≫ f.c.app (op (opensFunctor f |>.obj U)) =
      X.presheaf.map (eqToHom (by simp [Opens.map, Set.preimage_image_eq _ H.base_open.inj]))
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
@[simp, norm_cast]
theorem coe_mul (x y : Ico (0 : α) 1) : ↑(x * y) = (x * y : α)
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
theorem ordConnectedSection_subset : ordConnectedSection s ⊆ s
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
/-- An auxiliary lemma used twice in the proof of `WithLp.prodPseudoMetricAux` below. Not intended
for use outside this file. -/
theorem prod_sup_edist_ne_top_aux [PseudoMetricSpace α] [PseudoMetricSpace β]
    (f g : WithLp ∞ (α × β)) :
    edist f.fst g.fst ⊔ edist f.snd g.snd ≠ ⊤
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem final_of_final_comp [hF : Final F] [hFG : Final (F ⋙ G)] : Final G
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[ext]
theorem image.ext [HasImage f] {W : C} {g h : image f ⟶ W} [HasLimit (parallelPair g h)]
    (w : factorThruImage f ≫ g = factorThruImage f ≫ h) : g = h
-- Mathlib/RingTheory/WittVector/Truncated.lean
theorem truncateFun_nsmul (m : ℕ) (x : 𝕎 R) : truncateFun n (m • x) = m • truncateFun n x
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.neg_nsmul [AddGroup α] (h : Periodic f c) (n : ℕ) : Periodic f (-(n • c))
-- Mathlib/Algebra/Algebra/Basic.lean
theorem NoZeroSMulDivisors.trans (R A M : Type*) [CommRing R] [Ring A] [IsDomain A] [Algebra R A]
    [AddCommGroup M] [Module R M] [Module A M] [IsScalarTower R A M] [NoZeroSMulDivisors R A]
    [NoZeroSMulDivisors A M] : NoZeroSMulDivisors R M
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma isWeaklyRegular_map_algebraMap_iff [CommRing R] [CommRing S]
    [Algebra R S] [AddCommGroup M] [Module R M] [Module S M]
    [IsScalarTower R S M] (rs : List R) :
    IsWeaklyRegular M (rs.map (algebraMap R S)) ↔ IsWeaklyRegular M rs
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[mfld_simps]
theorem refl_restr_source (s : Set α) : ((PartialEquiv.refl α).restr s).source = s
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive sum_univ_one]
theorem prod_univ_one [CommMonoid β] (f : Fin 1 → β) : ∏ i, f i = f 0
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma inv_pow_sub₀ (ha : a ≠ 0) (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem comp_eq_mk (g : β → γ) (hg : Continuous g) (f : α →ₘ[μ] β) :
    comp g hg f = mk (g ∘ f) (hg.comp_aestronglyMeasurable f.aestronglyMeasurable)
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
@[to_additive]
theorem smul_of_tower_def (r : M) (x : s) :
    r • x = ⟨r • x, smul_one_smul N r x.1 ▸ smul_mem _ x.2⟩
-- Mathlib/Topology/Sets/Compacts.lean
@[simp, norm_cast] lemma coe_himp (s t : CompactOpens α) : ↑(s ⇨ t) = (s ⇨ t : Set α)
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem measurable_fderiv_apply_const_with_param [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f.uncurry) (y : E) :
    Measurable (fun (p : α × E) ↦ fderiv 𝕜 (f p.1) p.2 y)
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem map_roots_le [IsDomain A] [IsDomain B] {p : A[X]} {f : A →+* B} (h : p.map f ≠ 0) :
    p.roots.map f ≤ (p.map f).roots
-- Mathlib/Algebra/Module/Torsion.lean
theorem torsionBySet_isTorsionBySet : IsTorsionBySet R (torsionBySet R M s) s
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma comm (h : HomologyMapData φ h₁ h₂) :
    h.left.φH ≫ h₂.iso.hom = h₁.iso.hom ≫ h.right.φH
-- Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
theorem ofBaseChange_comp_toBaseChange (Q : QuadraticForm R V) :
    (ofBaseChange A Q).comp (toBaseChange A Q) = AlgHom.id _ _
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem inv_def (μ : Measure G) : μ.inv = Measure.map inv μ
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem ae_eq_set {s t : Set α} : s =ᵐ[μ] t ↔ μ (s \ t) = 0 ∧ μ (t \ s) = 0
-- Mathlib/Order/LiminfLimsup.lean
theorem limsup_congr {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : ∀ᶠ a in f, u a = v a) : limsup u f = limsup v f
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_le_mabs_of_le_one (ha : a ≤ 1) (hab : b ≤ a) : |a|ₘ ≤ |b|ₘ
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem bot_orthogonal_eq_top : (⊥ : Submodule 𝕜 E)ᗮ = ⊤
-- Mathlib/Data/Fin/Basic.lean
lemma succAbove_castPred_of_lt (p i : Fin (n + 1)) (h : i < p)
    (hi := Fin.ne_of_lt $ Nat.lt_of_lt_of_le h p.le_last) : succAbove p (i.castPred hi) = i
-- Mathlib/Computability/TuringMachine.lean
theorem stmts_trans {M : Λ → Stmt₂} {S : Finset Λ} {q₁ q₂ : Stmt₂} (h₁ : q₁ ∈ stmts₁ q₂) :
    some q₂ ∈ stmts M S → some q₁ ∈ stmts M S
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
/-- The parts of a Turán-maximal graph form an equipartition. -/
theorem isEquipartition : h.finpartition.IsEquipartition
-- Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
lemma term_welldef {n : ℕ} (hn : 0 < n) {s : ℝ} (hs : 0 < s) :
    IntervalIntegrable (fun x : ℝ ↦ (x - n) / x ^ (s + 1)) volume n (n + 1)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem linearIndependent_iff_sum :
    LinearIndependent ℤ (eval C) ↔ LinearIndependent ℤ (SumEval C ho)
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
theorem neg_bind (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α) : -x >>= f = -(x >>= f)
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- Given a weakly regular measure, any measurable set of finite mass can be approximated from
inside by closed sets. -/
theorem _root_.MeasurableSet.measure_eq_iSup_isClosed_of_ne_top [WeaklyRegular μ] ⦃A : Set α⦄
    (hA : MeasurableSet A) (h'A : μ A ≠ ∞) : μ A = ⨆ (K) (_ : K ⊆ A) (_ : IsClosed K), μ K
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem bound_pos : 0 < bound ε l
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean
theorem mapBiproduct_hom :
    haveI : HasBiproduct fun j => F.obj (f j) := hasBiproduct_of_preserves F f
    (mapBiproduct F f).hom = biproduct.lift fun j => F.map (biproduct.π f j)
-- Mathlib/Data/Complex/Exponential.lean
@[simp, norm_cast]
theorem ofReal_sinh (x : ℝ) : (Real.sinh x : ℂ) = sinh x
-- .lake/packages/batteries/Batteries/Data/HashMap/Basic.lean
/--
The well-formedness invariant for the bucket array says that every element hashes to its index
(assuming the hash is lawful - otherwise there are no promises about where elements are located).
-/
structure WF [BEq α] [Hashable α] (buckets : Buckets α β) : Prop where
  /-- The elements of a bucket are all distinct according to the `BEq` relation. -/
  distinct [LawfulHashable α] [PartialEquivBEq α] : ∀ bucket ∈ buckets.1.data,
    bucket.toList.Pairwise fun a b => ¬(a.1 == b.1)
  /-- Every element in a bucket should hash to its location. -/
  hash_self (i : Nat) (h : i < buckets.1.size) :
    buckets.1[i].All fun k _ => ((hash k).toUSize % buckets.1.size).toNat = i
-- Mathlib/Analysis/CstarAlgebra/Spectrum.lean
theorem IsStarNormal.spectralRadius_eq_nnnorm (a : A) [IsStarNormal a] :
    spectralRadius ℂ a = ‖a‖₊
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast]
theorem ofReal_im (r : ℝ) : (r : ℂ).im = 0
-- Mathlib/Data/Nat/Cast/Commute.lean
theorem commute_cast (x : α) (n : ℕ) : Commute x n
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma exterior_subset_iff_mem_nhdsSet : exterior s ⊆ t ↔ t ∈ 𝓝ˢ s
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem mkRat_eq_iff (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    mkRat n₁ d₁ = mkRat n₂ d₂ ↔ n₁ * d₂ = n₂ * d₁
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_eq_neg_pi_div_two_iff {z : ℂ} : arg z = -(π / 2) ↔ z.re = 0 ∧ z.im < 0
-- Mathlib/Data/Fin/Tuple/Basic.lean
lemma append_rev {m n} {α : Type*} (xs : Fin m → α) (ys : Fin n → α) (i : Fin (m + n)) :
    append xs ys (rev i) = append (ys ∘ rev) (xs ∘ rev) (cast (Nat.add_comm ..) i)
-- Mathlib/GroupTheory/GroupAction/Pointwise.lean
theorem Group.preimage_smul_set
    {R : Type*} [Group R] (M₁ M₂ : Type*)
    [MulAction R M₁] [MulAction R M₂]
    {F : Type*} [FunLike F M₁ M₂] [MulActionHomClass F R M₁ M₂] (h : F)
    (c : R) (t : Set M₂) :
    h ⁻¹' (c • t) = c • h ⁻¹' t
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem prod_map_fst : (prod p q).map (fst R M M₂) = p
-- Mathlib/Data/Nat/ModEq.lean
@[symm]
protected theorem symm : a ≡ b [MOD n] → b ≡ a [MOD n]
-- Mathlib/Order/CompleteBooleanAlgebra.lean
/-- Structure containing the minimal axioms required to check that an order is a completely
distributive. Do NOT use, except for implementing `CompletelyDistribLattice` via
`CompletelyDistribLattice.ofMinimalAxioms`.

This structure omits the `himp`, `compl`, `sdiff`, `hnot` fields, which can be recovered using
`CompletelyDistribLattice.ofMinimalAxioms`. -/
structure CompletelyDistribLattice.MinimalAxioms (α : Type u) extends CompleteLattice α where
  protected iInf_iSup_eq {ι : Type u} {κ : ι → Type u} (f : ∀ a, κ a → α) :
    (⨅ a, ⨆ b, f a b) = ⨆ g : ∀ a, κ a, ⨅ a, f a (g a)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
/-- finite = integral + finite type -/
theorem Algebra.finite_iff_isIntegral_and_finiteType :
    Module.Finite R A ↔ Algebra.IsIntegral R A ∧ Algebra.FiniteType R A
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.mul_right_iff : IsRelPrime x (y * z) ↔ IsRelPrime x y ∧ IsRelPrime x z
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem eventually_all {ι : Sort*} [Finite ι] {l} {p : ι → α → Prop} :
    (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma IsRatCondKernelCDFAux.isRatCondKernelCDF (hf : IsRatCondKernelCDFAux f κ ν) [IsFiniteKernel κ]
    [IsFiniteKernel ν] :
    IsRatCondKernelCDF f κ ν
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem frequently_principal {a : Set α} {p : α → Prop} : (∃ᶠ x in 𝓟 a, p x) ↔ ∃ x ∈ a, p x
-- Mathlib/Topology/Order/Basic.lean
/-- Consider a disjoint family of intervals `(x, y)` with `x < y` in a second-countable space.
Then the family is countable.
This is not a straightforward consequence of second-countability as some of these intervals might be
empty (but in fact this can happen only for countably many of them). -/
theorem Set.PairwiseDisjoint.countable_of_Ioo [OrderTopology α] [SecondCountableTopology α]
    {y : α → α} {s : Set α} (h : PairwiseDisjoint s fun x => Ioo x (y x))
    (h' : ∀ x ∈ s, x < y x) : s.Countable
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem comap_inf (S T : Subsemigroup N) (f : M →ₙ* N) : (S ⊓ T).comap f = S.comap f ⊓ T.comap f
-- Mathlib/Algebra/Ring/Prod.lean
theorem prod_comp_prodMap (f : T →+* R) (g : T →+* S) (f' : R →+* R') (g' : S →+* S') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infiniteNeg_add_not_infinite {x y : ℝ*} :
    InfiniteNeg x → ¬Infinite y → InfiniteNeg (x + y)
-- Mathlib/Control/Basic.lean
@[simp]
theorem pure_id'_seq (x : F α) : (pure fun x => x) <*> x = x
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then the preimage of `perfectClosure F K`
under the map `i` is equal to `perfectClosure F E`. -/
theorem perfectClosure.comap_eq_of_algHom (i : E →ₐ[F] K) :
    (perfectClosure F K).comap i = perfectClosure F E
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
theorem mem_support_iff (x : X) (a : FreeAbelianGroup X) : x ∈ a.support ↔ coeff x a ≠ 0
-- Mathlib/Data/DFinsupp/Order.lean
theorem subset_support_tsub : f.support \ g.support ⊆ (f - g).support
-- Mathlib/Order/GameAdd.lean
/-- Induction on the well-founded `Prod.GameAdd` relation.
  Note that it's strictly more general to induct on the lexicographic order instead. -/
theorem GameAdd.induction {C : α → β → Prop} :
    WellFounded rα →
      WellFounded rβ →
        (∀ a₁ b₁, (∀ a₂ b₂, GameAdd rα rβ (a₂, b₂) (a₁, b₁) → C a₂ b₂) → C a₁ b₁) → ∀ a b, C a b
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
theorem mem_eigenspace_iff {f : End R M} {μ : R} {x : M} : x ∈ eigenspace f μ ↔ f x = μ • x
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousOn.preimage_isClosed_of_isClosed {f : α → β} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hs : IsClosed s) (ht : IsClosed t) : IsClosed (s ∩ f ⁻¹' t)
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
theorem mod_add_div' (m k : R) : m % k + m / k * k = m
-- Mathlib/Data/List/Zip.lean
theorem zipWith_zipWith_right (f : α → δ → ε) (g : β → γ → δ) :
    ∀ (la : List α) (lb : List β) (lc : List γ),
      zipWith f la (zipWith g lb lc) = zipWith3 (fun a b c => f a (g b c)) la lb lc
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem eraseP_map (f : β → α) : ∀ (l : List β), (map f l).eraseP p = map f (l.eraseP (p ∘ f))
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma equation_neg_iff (x y : R) : W.Equation x (W.negY x y) ↔ W.Equation x y
-- Mathlib/Data/Matroid/Map.lean
lemma eq_of_restrictSubtype_eq {N : Matroid α} (hM : M.E = E) (hN : N.E = E)
    (h : M.restrictSubtype E = N.restrictSubtype E) : M = N
-- Mathlib/Algebra/MonoidAlgebra/Support.lean
@[simp]
lemma support_one [One G] [NeZero (1 : k)] : (1 : MonoidAlgebra k G).support = 1
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem sum_add {S : Type*} [AddCommMonoid S] (p : R[X]) (f g : ℕ → R → S) :
    (p.sum fun n x => f n x + g n x) = p.sum f + p.sum g
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
/-- Pull an opposite subgroup back to a subgroup along `MulOpposite.op`-/
@[to_additive (attr := simps)
"Pull an opposite additive subgroup back to an additive subgroup along `AddOpposite.op`"]
protected def unop (H : Subgroup Gᵐᵒᵖ) : Subgroup G
-- Mathlib/Order/Minimal.lean
theorem Set.mem_maximals_iff_forall_insert {P : Set α → Prop} (hP : ∀ ⦃s t⦄, P t → s ⊆ t → P s) :
    s ∈ maximals (· ⊆ ·) {t | P t} ↔ P s ∧ ∀ x ∉ s, ¬ P (insert x s)
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
theorem hasCore_def {f : E →ₗ.[R] F} {S : Submodule R E} (h : f.HasCore S) :
    (f.domRestrict S).closure = f
-- Mathlib/Algebra/Group/Subgroup/Finite.lean
@[to_additive]
theorem noncommProd_mem (K : Subgroup G) {ι : Type*} {t : Finset ι} {f : ι → G} (comm) :
    (∀ c ∈ t, f c ∈ K) → t.noncommProd f comm ∈ K
-- Mathlib/Data/Nat/BitIndices.lean
@[simp] theorem bitIndices_sorted {n : ℕ} : n.bitIndices.Sorted (· < ·)
-- Mathlib/MeasureTheory/Constructions/Projective.lean
lemma measure_univ_eq (hμ : IsProjectiveLimit μ P) (I : Finset ι) :
    μ univ = P I univ
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma pairwiseDisjoint_union_diffFinset₀ (hC : IsSetSemiring C) (hs : s ∈ C)
    (hI : ↑I ⊆ C) (h_dis : PairwiseDisjoint (I : Set (Set α)) id) :
    PairwiseDisjoint (I ∪ hC.diffFinset₀ hs hI : Set (Set α)) id
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuousAt_biSup {p : ι → Prop} {f : ∀ i, p i → α → δ}
    (h : ∀ i hi, LowerSemicontinuousAt (f i hi) x) :
    LowerSemicontinuousAt (fun x' => ⨆ (i) (hi), f i hi x') x
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem add_im (z w : ℂ) : (z + w).im = z.im + w.im
-- Mathlib/Order/WithBot.lean
@[simp]
protected theorem not_lt_bot (a : WithBot α) : ¬a < ⊥
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem coe_zero : ((0 : A →⋆ₙₐ[R] B) : A → B) = 0
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
@[ext]
lemma hom_ext {X Y : SimplicialObject C} (f g : X ⟶ Y)
    (h : ∀ (n : SimplexCategoryᵒᵖ), f.app n = g.app n) : f = g
-- Mathlib/Logic/Equiv/PartialEquiv.lean
/-- Associate a `PartialEquiv` to an `Equiv`. -/
@[simps! (config := mfld_cfg)]
def _root_.Equiv.toPartialEquiv (e : α ≃ β) : PartialEquiv α β
-- Mathlib/Order/Filter/AtTopBot.lean
theorem atBot_countable_basis [Nonempty α] [SemilatticeInf α] [Countable α] :
    HasCountableBasis (atBot : Filter α) (fun _ => True) Iic
-- Mathlib/SetTheory/Cardinal/CountableCover.lean
/-- If a space is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of the space is also bounded by `a`. -/
lemma mk_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #α ≤ a
-- Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean
/-- Given a cartesian morphism `φ : a ⟶ b` lying over `f : R ⟶ S` in `𝒳`, and another morphism
`φ' : a' ⟶ b` which also lifts `f`. Then any morphism `ψ : a' ⟶ a` lifting `𝟙 R` such that
`g ≫ ψ = φ'` must equal the map induced from the universal property of `φ`. -/
lemma map_uniq (ψ : a' ⟶ a) [IsHomLift p (𝟙 R) ψ] (hψ : ψ ≫ φ = φ') :
    ψ = IsCartesian.map p f φ φ'
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem HasMFDerivAt.continuousAt (h : HasMFDerivAt I I' f x f') : ContinuousAt f x
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
protected theorem map_sub : D (a - b) = D a - D b
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem singletonMulHom_apply (a : α) : singletonMulHom a = {a}
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
lemma IsHamiltonianCycle.count_support_self (hp : p.IsHamiltonianCycle) :
    p.support.count a = 2
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem one_le_blocks {i : ℕ} (h : i ∈ c.blocks) : 1 ≤ i
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem map_adjoin (φ : A →ₐ[R] B) (s : Set A) : (adjoin R s).map φ = adjoin R (φ '' s)
-- Mathlib/Topology/Constructions.lean
theorem openEmbedding_inl : OpenEmbedding (@inl X Y)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem card_typein_out_lt (c : Cardinal) (x : c.ord.out.α) :
    card (@typein _ (· < ·) (isWellOrder_out_lt _) x) < c
-- Mathlib/Data/Option/Basic.lean
@[simp]
lemma bnot_comp_isNone : (! ·) ∘ @Option.isNone α = Option.isSome
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F)
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem toNatLinearEquiv_trans (e₂ : M₂ ≃+ M₃) :
    e.toNatLinearEquiv.trans e₂.toNatLinearEquiv = (e.trans e₂).toNatLinearEquiv
-- Mathlib/Data/Finset/Lattice.lean
theorem isGLB_mem [LinearOrder α] {i : α} (s : Finset α) (his : IsGLB (s : Set α) i)
    (hs : s.Nonempty) : i ∈ s
-- Mathlib/Order/LiminfLimsup.lean
theorem le_limsup_of_frequently_le' {α β} [CompleteLattice β] {f : Filter α} {u : α → β} {x : β}
    (h : ∃ᶠ a in f, x ≤ u a) : x ≤ limsup u f
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma neg_of_smul_neg_right' [PosSMulMono α β] (h : a • b < 0) (hb : 0 ≤ b) : a < 0
-- Mathlib/Tactic/LinearCombination.lean
theorem c_mul_pf [Mul α] (p : b = c) (a : α) : a * b = a * c
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
theorem coeff_hermite_of_lt {n k : ℕ} (hnk : n < k) : coeff (hermite n) k = 0
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
@[simp]
theorem mul_apply (n : ℕ) (f g : AdicCauchySequence I R) : (f * g) n = f n * g n
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem roots_ne_zero_of_splits' {f : K[X]} (hs : Splits i f) (hf0 : natDegree (f.map i) ≠ 0) :
    (f.map i).roots ≠ 0
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_succ : a ♯ succ b = succ (a ♯ b)
-- Mathlib/Order/Bounds/Basic.lean
theorem mem_lowerBounds_image_self (Hf : MonotoneOn f t) :
    a ∈ lowerBounds t → a ∈ t → f a ∈ lowerBounds (f '' t)
-- Mathlib/Topology/Semicontinuous.lean
theorem UpperSemicontinuousAt.comp_continuousAt {f : α → β} {g : ι → α} {x : ι}
    (hf : UpperSemicontinuousAt f (g x)) (hg : ContinuousAt g x) :
    UpperSemicontinuousAt (fun x ↦ f (g x)) x
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive]
theorem setLIntegral_eq_tsum' (h : IsFundamentalDomain G s μ) (f : α → ℝ≥0∞) (t : Set α) :
    ∫⁻ x in t, f x ∂μ = ∑' g : G, ∫⁻ x in g • t ∩ s, f (g⁻¹ • x) ∂μ
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem isLittleO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =o[l] fun x => exp (f x)) ↔ Tendsto f l atTop