ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem dist_eq_iff_eq_sinh :
    dist z w = r ↔ dist (z : ℂ) w / (2 * √(z.im * w.im)) = sinh (r / 2)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
protected theorem Sublist.filterMap (f : α → Option β) (s : l₁ <+ l₂) :
    filterMap f l₁ <+ filterMap f l₂
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem preimage_symm (f : P₁ ≃ᵃ[k] P₂) (s : Set P₁) : f.symm ⁻¹' s = f '' s
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem smul_finset_univ [Fintype β] : a • (univ : Finset β) = univ
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem coeHom_injective : Function.Injective (coeHom E F)
-- Mathlib/Topology/Order/LawsonTopology.lean
/-- A lower set is Lawson closed if and only if it is closed under sups of directed sets -/
lemma lawsonClosed_iff_dirSupClosed_of_isLowerSet (s : Set α) (h : IsLowerSet s) :
    IsClosed[L] s ↔ DirSupClosed s
-- Mathlib/Data/ZMod/Basic.lean
@[push_cast, simp]
theorem intCast_mod (a : ℤ) (b : ℕ) : ((a % b : ℤ) : ZMod b) = (a : ZMod b)
-- Mathlib/CategoryTheory/Iso.lean
theorem eq_comp_inv (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X} : g = f ≫ α.inv ↔ g ≫ α.hom = f
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualAnnihilator_inj {W W' : Subspace K V} :
    W.dualAnnihilator = W'.dualAnnihilator ↔ W = W'
-- Mathlib/Algebra/Homology/Localization.lean
lemma HomologicalComplex.homologyFunctor_inverts_quasiIso (i : ι) :
    (quasiIso C c).IsInvertedBy (homologyFunctor C c i)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp, norm_cast]
theorem natCoe_mul [Semiring R] {f g : ArithmeticFunction ℕ} :
    (↑(f * g) : ArithmeticFunction R) = f * g
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem ule_eq_carry (x y : BitVec w) : x.ule y = carry w y (~~~x) true
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_union_of_not_mem_inter (h : a ∉ s ∩ t) (f : α → M) :
    mulIndicator (s ∪ t) f a = mulIndicator s f a * mulIndicator t f a
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- `b < sSup s` when there is an element `a` in `s` with `b < a`, when `s` is bounded above.
This is essentially an iff, except that the assumptions for the two implications are
slightly different (one needs boundedness above for one direction, nonemptiness and linear
order for the other one), so we formulate separately the two implications, contrary to
the `CompleteLattice` case. -/
theorem lt_csSup_of_lt (hs : BddAbove s) (ha : a ∈ s) (h : b < a) : b < sSup s
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem surjective_of_epi [Epi f] : Function.Surjective f
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem le_succ_of_isLimit {o} (h : IsLimit o) {a} : o ≤ succ a ↔ o ≤ a
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem Eventually.exists_measurable_mem_of_smallSets {f : Filter α} [IsMeasurablyGenerated f]
    {p : Set α → Prop} (h : ∀ᶠ s in f.smallSets, p s) : ∃ s ∈ f, MeasurableSet s ∧ p s
-- Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean
theorem convs'_stable_of_terminated (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.convs' m = g.convs' n
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
theorem norm_def : ‖f‖ = max ‖f 0‖ ‖f.contLinear‖
-- Mathlib/GroupTheory/Coset.lean
theorem rightRel_r_eq_rightCosetEquivalence :
    @Setoid.r _ (QuotientGroup.rightRel s) = RightCosetEquivalence s
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem RingHom.comp_id_commRingCat
    {G : CommRingCat.{u}} {H : Type u} [CommRing H] (f : G →+* H) : f.comp (𝟙 G) = f
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma mulIndicator_le_one (h : ∀ a ∈ s, f a ≤ 1) (a : α) : mulIndicator s f a ≤ 1
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem monic_normalize [DecidableEq R] (hp0 : p ≠ 0) : Monic (normalize p)
-- Mathlib/Computability/Primrec.lean
theorem listFilterMap {f : α → List β} {g : α → β → Option σ}
    (hf : Primrec f) (hg : Primrec₂ g) : Primrec fun a => (f a).filterMap (g a)
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem Monotone.monovary (hf : Monotone f) (hg : Monotone g) : Monovary f g
-- Mathlib/Computability/TuringMachine.lean
theorem tr_supports {S : Finset Λ} (ss : Supports M S) : Supports (tr enc dec M) (trSupp M S)
-- Mathlib/RingTheory/IntegralClosure/Algebra/Basic.lean
theorem RingHom.IsIntegralElem.mul {x y : S} (hx : f.IsIntegralElem x) (hy : f.IsIntegralElem y) :
    f.IsIntegralElem (x * y)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_or_eq_of_le {n m : Nat} (h : n ≤ m) : n < m ∨ n = m
-- Mathlib/Topology/Separation.lean
protected theorem Finset.isClosed [T1Space X] (s : Finset X) : IsClosed (s : Set X)
-- Mathlib/RingTheory/Unramified/Basic.lean
theorem lift_unique' [FormallyUnramified R A] {C : Type u} [CommRing C]
    [Algebra R C] (f : B →ₐ[R] C) (hf : IsNilpotent <| RingHom.ker (f : B →+* C))
    (g₁ g₂ : A →ₐ[R] B) (h : f.comp g₁ = f.comp g₂) : g₁ = g₂
-- Mathlib/CategoryTheory/Localization/Predicate.lean
lemma of_isEquivalence (L : C ⥤ D) (W : MorphismProperty C)
    (hW : W ≤ MorphismProperty.isomorphisms C) [IsEquivalence L] :
    L.IsLocalization W
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_right_surjective (a : α) : Surjective (a ∆ ·)
-- Mathlib/Order/Sublattice.lean
lemma comap_iInf (f : LatticeHom α β) (s : ι → Sublattice β) :
    (iInf s).comap f = ⨅ i, (s i).comap f
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
@[simp]
lemma mk_id_comp [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W X X]
    (α : SmallHom.{w} W X Y) :
    (mk W (𝟙 X)).comp α = α
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
@[simp]
theorem hasDerivWithinAt_diff_singleton :
    HasDerivWithinAt f f' (s \ {x}) x ↔ HasDerivWithinAt f f' s x
-- Mathlib/RingTheory/ChainOfDivisors.lean
theorem Associates.isAtom_iff {p : Associates M} (h₁ : p ≠ 0) : IsAtom p ↔ Irreducible p
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem one_rel (y : S) : r S 1 (y, y)
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem sub_imI : (a - b).imI = a.imI - b.imI
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem eraseP_append_right :
    ∀ {l₁ : List α} l₂, (∀ b ∈ l₁, ¬p b) → eraseP p (l₁++l₂) = l₁ ++ l₂.eraseP p
-- Mathlib/RepresentationTheory/Invariants.lean
theorem invariants_eq_top [ρ.IsTrivial] :
    invariants ρ = ⊤
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem val_zero : ∀ {n}, (0 : ZMod n).val = 0
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem eq_false_of_ne_true : {b : Bool} → Not (Eq b true) → Eq b false
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive (attr := fun_prop) Continuous.nnnorm]
theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊
-- Mathlib/Topology/UnitInterval.lean
/-- Any open cover `c` of a closed interval `[a, b]` in ℝ can be refined to
  a finite partition into subintervals. -/
lemma exists_monotone_Icc_subset_open_cover_Icc {ι} {a b : ℝ} (h : a ≤ b) {c : ι → Set (Icc a b)}
    (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : univ ⊆ ⋃ i, c i) : ∃ t : ℕ → Icc a b, t 0 = a ∧
      Monotone t ∧ (∃ m, ∀ n ≥ m, t n = b) ∧ ∀ n, ∃ i, Icc (t n) (t (n + 1)) ⊆ c i
-- Mathlib/GroupTheory/Coset.lean
@[to_additive (attr := simp)]
lemma fiberEquivKer_apply (f : α →* H) (a : α) (g : f ⁻¹' {f a}) : f.fiberEquivKer a g = a⁻¹ * g
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
/-- The characterization of this multiplication on partially homogenous elements. -/
theorem tmul_coe_mul_coe_tmul {j₁ i₂ : ι} (a₁ : A) (b₁ : ℬ j₁) (a₂ : 𝒜 i₂) (b₂ : B) :
    (a₁ ᵍ⊗ₜ[R] (b₁ : B) * (a₂ : A) ᵍ⊗ₜ[R] b₂ : 𝒜 ᵍ⊗[R] ℬ) =
      (-1 : ℤˣ)^(j₁ * i₂) • ((a₁ * a₂ : A) ᵍ⊗ₜ (b₁ * b₂ : B))
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem Specializes.const_smul {x y : α} (h : x ⤳ y) (c : M) : (c • x) ⤳ (c • y)
-- Mathlib/Geometry/RingedSpace/SheafedSpace.lean
/-- Constructor for isomorphisms in the category `SheafedSpace C`. -/
@[simps]
def isoMk {X Y : SheafedSpace C} (e : X.toPresheafedSpace ≅ Y.toPresheafedSpace) : X ≅ Y
-- Mathlib/Analysis/Convolution.lean
/-- The symmetric definition of convolution where the bilinear operator is multiplication. -/
theorem convolution_mul_swap [NormedSpace ℝ 𝕜] {f : G → 𝕜} {g : G → 𝕜} :
    (f ⋆[mul 𝕜 𝕜, μ] g) x = ∫ t, f (x - t) * g t ∂μ
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem _root_.MeasureTheory.Integrable.condDistrib_ae (hX : AEMeasurable X μ)
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    ∀ᵐ a ∂μ, Integrable (fun ω => f (X a, ω)) (condDistrib Y X μ (X a))
-- Mathlib/Data/FunLike/Basic.lean
theorem coe_injective : Function.Injective (fun f : F ↦ (f : ∀ a : α, β a))
-- Mathlib/Data/List/Lattice.lean
@[simp]
theorem bagInter_nil (l : List α) : l.bagInter [] = []
-- Mathlib/Data/ENNReal/Real.lean
theorem toNNReal_sInf (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ∞) :
    (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem support_embDomain_subset {f : Γ ↪o Γ'} {x : HahnSeries Γ R} :
    support (embDomain f x) ⊆ f '' x.support
-- Mathlib/Algebra/Homology/Augment.lean
/-- The truncation of an `ℕ`-indexed cochain complex,
deleting the object at `0` and shifting everything else down.
-/
@[simps]
def truncate [HasZeroMorphisms V] : CochainComplex V ℕ ⥤ CochainComplex V ℕ
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- Turn a colimit for `F.unop : J ⥤ C` into a limit for `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def isLimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F.unop} (hc : IsColimit c) :
    IsLimit (coneOfCoconeUnop c)
-- Mathlib/ModelTheory/LanguageMap.lean
/-- The map between two sum-languages induced by maps on the two factors. -/
@[simps]
def sumMap : L.sum L₁ →ᴸ L'.sum L₂
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
/-- `SatisfiesM` distributes over `<*>`, strongest postcondition version. -/
protected theorem seq_post [Applicative m] [LawfulApplicative m] {x : m α}
    (hf : SatisfiesM p₁ f) (hx : SatisfiesM p₂ x) :
    SatisfiesM (fun c => ∃ f a, p₁ f ∧ p₂ a ∧ c = f a) (f <*> x)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem sum_apply {α : Type*} (f : α → ContinuousMultilinearMap R M₁ M₂) (m : ∀ i, M₁ i)
    {s : Finset α} : (∑ a ∈ s, f a) m = ∑ a ∈ s, f a m
-- Mathlib/Dynamics/PeriodicPts.lean
theorem iUnion_pNat_ptsOfPeriod : ⋃ n : ℕ+, ptsOfPeriod f n = periodicPts f
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
@[simp]
theorem apply_ne_one_iff [MulZeroOneClass α] [Nontrivial α] (h : IsAdjMatrix A) (i j : V) :
    ¬A i j = 1 ↔ A i j = 0
-- Mathlib/Algebra/Polynomial/EraseLead.lean
@[simp]
theorem eraseLead_X_pow (n : ℕ) : eraseLead (X ^ n : R[X]) = 0
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
theorem mul_def (e e' : X ≃ᵈ X) : e * e' = e'.trans e
-- Mathlib/Topology/ContinuousOn.lean
/-- If a function `f a b` is such that `y ↦ f a b` is continuous for all `a`, and `a` lives in a
discrete space, then `f` is continuous, and vice versa. -/
theorem continuous_prod_of_discrete_left [DiscreteTopology α] {f : α × β → γ} :
    Continuous f ↔ ∀ a, Continuous (f ⟨a, ·⟩)
-- Mathlib/Dynamics/FixedPoints/Basic.lean
theorem mem_fixedPoints_iff {α : Type*} {f : α → α} {x : α} : x ∈ fixedPoints f ↔ f x = x
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem card_roots' (p : R[X]) : Multiset.card p.roots ≤ natDegree p
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_natCast_le (n : ℕ) : degree (n : R[X]) ≤ 0
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_le_self : a - b ≤ a
-- Mathlib/Topology/UniformSpace/Compact.lean
/-- A family of functions `α → β → γ` tends uniformly to its value at `x` if `α` is locally compact,
`β` is compact and `f` is continuous on `U × (univ : Set β)` for some neighborhood `U` of `x`. -/
theorem ContinuousOn.tendstoUniformly [LocallyCompactSpace α] [CompactSpace β] [UniformSpace γ]
    {f : α → β → γ} {x : α} {U : Set α} (hxU : U ∈ 𝓝 x) (h : ContinuousOn (↿f) (U ×ˢ univ)) :
    TendstoUniformly f (f x) (𝓝 x)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem map_id : N.map LieModuleHom.id = N
-- Mathlib/Order/SupIndep.lean
theorem supIndep_map {s : Finset ι'} {g : ι' ↪ ι} : (s.map g).SupIndep f ↔ s.SupIndep (f ∘ g)
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[simp]
theorem leftUnitor_hom (X : C) : (λ_ X).hom = coprod.desc (initial.to X) (𝟙 _)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_def (a b : Ordinal) :
    a ⨳ b = sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma cons_add (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    vecCons x v + w = vecCons (x + vecHead w) (v + vecTail w)
-- Mathlib/Algebra/Group/UniqueProds.lean
@[to_additive]
theorem to_mulOpposite (h : UniqueMul A B a0 b0) :
    UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0)
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem isTheta_const_mul_right {c : 𝕜} {g : α → 𝕜} (hc : c ≠ 0) :
    (f =Θ[l] fun x ↦ c * g x) ↔ f =Θ[l] g
-- Mathlib/Data/Sym/Basic.lean
theorem mem_append_iff {s' : Sym α m} : a ∈ s.append s' ↔ a ∈ s ∨ a ∈ s'
-- Mathlib/Data/Set/Lattice.lean
theorem seq_singleton {s : Set (α → β)} {a : α} : Set.seq s {a} = (fun f : α → β => f a) '' s
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma density_ae_eq_limitProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    (fun x ↦ density κ ν a x s)
      =ᵐ[ν a] (countableFiltration γ).limitProcess
        (fun n x ↦ densityProcess κ ν n a x s) (ν a)
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[ext]
theorem ext {x y : AdicCauchySequence I M} (h : ∀ n, x n = y n) : x = y
-- Mathlib/Analysis/Calculus/LHopital.lean
/-- **L'Hôpital's rule** for approaching -∞, `deriv` version -/
theorem lhopital_zero_atBot (hdf : ∀ᶠ x : ℝ in atBot, DifferentiableAt ℝ f x)
    (hg' : ∀ᶠ x : ℝ in atBot, deriv g x ≠ 0) (hfbot : Tendsto f atBot (𝓝 0))
    (hgbot : Tendsto g atBot (𝓝 0)) (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) atBot l) :
    Tendsto (fun x => f x / g x) atBot l
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
/-- In a `p ^ (k + 1)`-th cyclotomic extension of `ℚ `, we have that `ζ` is not congruent to an
  integer modulo `p` if `p ^ (k  + 1) ≠ 2`. -/
theorem not_exists_int_prime_dvd_sub_of_prime_pow_ne_two
    [hcycl : IsCyclotomicExtension {p ^ (k + 1)} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))) (htwo : p ^ (k + 1) ≠ 2) :
    ¬(∃ n : ℤ, (p : 𝓞 K) ∣ (hζ.toInteger - n : 𝓞 K))
-- Mathlib/RingTheory/Ideal/Norm.lean
@[simp]
theorem absNorm_span_singleton (r : S) :
    absNorm (span ({r} : Set S)) = (Algebra.norm ℤ r).natAbs
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem nil_sublist : ∀ l : List α, [] <+ l
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[continuity]
theorem Continuous.div (hf : Continuous f) (hg : Continuous g) (h₀ : ∀ x, g x ≠ 0) :
    Continuous (f / g)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq (f : α →₁[μ] E) : integral f = integralCLM (E := E) f
-- Mathlib/Order/Ideal.lean
theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : Set P).Nonempty
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem not_isPrime_iff {I : Ideal α} :
    ¬I.IsPrime ↔ I = ⊤ ∨ ∃ (x : α) (_hx : x ∉ I) (y : α) (_hy : y ∉ I), x * y ∈ I
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- `spanningCoe` is equivalent to `coe` for a subgraph that `IsSpanning`. -/
@[simps]
def spanningCoeEquivCoeOfSpanning (G' : Subgraph G) (h : G'.IsSpanning) :
    G'.spanningCoe ≃g G'.coe
-- Mathlib/Data/List/Destutter.lean
@[simp]
theorem destutter'_cons_pos (h : R b a) : (a :: l).destutter' R b = b :: l.destutter' R a
-- Mathlib/Algebra/CharP/Two.lean
@[simp]
theorem neg_eq (x : R) : -x = x
-- Mathlib/Data/Setoid/Basic.lean
@[refl]
theorem refl' (r : Setoid α) (x) : r.Rel x x
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem dvd_of_emod_eq_zero {a b : Int} (H : b % a = 0) : a ∣ b
-- Mathlib/Topology/Connected/PathConnected.lean
@[refl]
theorem Joined.refl (x : X) : Joined x x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- The **spectral mapping theorem** for polynomials in a Banach algebra over `ℂ`. -/
theorem map_polynomial_aeval (p : ℂ[X]) :
    spectrum ℂ (aeval a p) = (fun k => eval k p) '' spectrum ℂ a
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem flip_inj {f g : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} (H : flip f = flip g) : f = g
-- Mathlib/Order/Filter/Lift.lean
theorem map_lift'_eq {m : β → γ} (hh : Monotone h) : map m (f.lift' h) = f.lift' (image m ∘ h)
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- Restricting a chart to its source `s ⊆ M` yields a chart in the maximal atlas of `s`. -/
theorem StructureGroupoid.restriction_mem_maximalAtlas_subtype
    {e : PartialHomeomorph M H} (he : e ∈ atlas H M)
    (hs : Nonempty e.source) [HasGroupoid M G] [ClosedUnderRestriction G] :
    let s := { carrier := e.source, is_open' := e.open_source : Opens M }
    let t := { carrier := e.target, is_open' := e.open_target : Opens H }
    ∀ c' ∈ atlas H t, e.toHomeomorphSourceTarget.toPartialHomeomorph ≫ₕ c' ∈ G.maximalAtlas s
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem coe_set_neg (S : Submodule R M) : ↑(-S) = -(S : Set M)
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
/-- If a function is countably sub-multiplicative then it is sub-multiplicative on countable
types -/
@[to_additive "If a function is countably sub-additive then it is sub-additive on countable types"]
theorem rel_iSup_tprod [CompleteLattice α] (m : α → M) (m0 : m ⊥ = 1) (R : M → M → Prop)
    (m_iSup : ∀ s : ℕ → α, R (m (⨆ i, s i)) (∏' i, m (s i))) (s : β → α) :
    R (m (⨆ b : β, s b)) (∏' b : β, m (s b))
-- Mathlib/Order/OrdContinuous.lean
theorem map_csSup (hf : LeftOrdContinuous f) {s : Set α} (sne : s.Nonempty) (sbdd : BddAbove s) :
    f (sSup s) = sSup (f '' s)
-- Mathlib/CategoryTheory/Localization/DerivabilityStructure/Basic.lean
lemma guitartExact_of_isRightDerivabilityStructure' [h : Φ.IsRightDerivabilityStructure]
    (e : Φ.functor ⋙ L₂ ≅ L₁ ⋙ F) : TwoSquare.GuitartExact e.hom
-- Mathlib/Algebra/Lie/TraceForm.lean
/-- Given a representation `M` of a Lie algebra `L`, the action of any `x : L` is skew-adjoint wrt
the trace form. -/
lemma traceForm_apply_lie_apply' (x y z : L) :
    traceForm R L M ⁅x, y⁆ z = - traceForm R L M y ⁅x, z⁆
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem suffix_cons (a : α) : ∀ l, l <:+ a :: l
-- Mathlib/NumberTheory/Padics/RingHoms.lean
/-- `z - (toZMod z : ℤ_[p])` is contained in the maximal ideal of `ℤ_[p]`, for every `z : ℤ_[p]`.

The coercion from `ZMod p` to `ℤ_[p]` is `ZMod.cast`,
which coerces `ZMod p` into arbitrary rings.
This is unfortunate, but a consequence of the fact that we allow `ZMod p`
to coerce to rings of arbitrary characteristic, instead of only rings of characteristic `p`.
This coercion is only a ring homomorphism if it coerces into a ring whose characteristic divides
`p`. While this is not the case here we can still make use of the coercion.
-/
theorem toZMod_spec : x - (ZMod.cast (toZMod x) : ℤ_[p]) ∈ maximalIdeal ℤ_[p]
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem getElem_setD_eq (a : Array α) {i : Nat} (v : α) (h : _) :
  (setD a i v)[i]'h = v
-- Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean
theorem isUnital_rightAdd : EckmannHilton.IsUnital (· +ᵣ ·) 0
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem tendsto_inv_nhdsWithin_Ioi {a : H} : Tendsto Inv.inv (𝓝[>] a) (𝓝[<] a⁻¹)
-- Mathlib/Topology/Instances/AddCircle.lean
lemma toAddCircle_natCast (j : ℕ) :
    toAddCircle (j : ZMod N) = ↑(j / N : ℝ)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem div_gcd_pos_of_pos_right (a : Nat) (h : 0 < b) : 0 < b / a.gcd b
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem x_sub_y_dvd_pow_lem (y2 y1 y0 yn1 yn0 xn1 xn0 ay a2 : ℤ) :
    (a2 * yn1 - yn0) * ay + y2 - (a2 * xn1 - xn0) =
      y2 - a2 * y1 + y0 + a2 * (yn1 * ay + y1 - xn1) - (yn0 * ay + y0 - xn0)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem proj_prop_eq_self (hh : ∀ i x, x ∈ C → x i ≠ false → J i) : π C J = C
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem fst_comp_toProd : (MonoidHom.fst M N).comp toProd = fst
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem norm_eq_sum (hp : 0 < p.toReal) (f : PiLp p β) :
    ‖f‖ = (∑ i, ‖f i‖ ^ p.toReal) ^ (1 / p.toReal)
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem adjoin_empty (F E : Type*) [Field F] [Field E] [Algebra F E] : adjoin F (∅ : Set E) = ⊥
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive (attr := simp)]
lemma prod_indicator_index_eq_prod_attach [Zero M] [CommMonoid N]
    {s : Finset α} (f : ∀ a ∈ s, M) {h : α → M → N} (h_zero : ∀ a ∈ s, h a 0 = 1) :
    (indicator s f).prod h = ∏ x ∈ s.attach, h ↑x (f x x.2)
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma algebraMap_apply (x) : algebraMap P.Ring S x = aeval (R := R) P.val x
-- Mathlib/Data/Nat/Factorization/PrimePow.lean
theorem isPrimePow_of_minFac_pow_factorization_eq {n : ℕ}
    (h : n.minFac ^ n.factorization n.minFac = n) (hn : n ≠ 1) : IsPrimePow n
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrRight_symm (e : ∀ i, α i ≃ₗᵢ[𝕜] β i) :
    (LinearIsometryEquiv.piLpCongrRight p e).symm =
      LinearIsometryEquiv.piLpCongrRight p (fun i => (e i).symm)
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)] theorem range_swap : MonoidHom.range (swap G H) = ⊤
-- Mathlib/Analysis/Normed/Group/Basic.lean
theorem le_norm_self (r : ℝ) : r ≤ ‖r‖
-- Mathlib/Logic/Denumerable.lean
theorem lt_succ_iff_le {x y : s} : x < succ y ↔ x ≤ y
-- Mathlib/LinearAlgebra/Dimension/RankNullity.lean
/-- Given a nonzero vector in a finite-dimensional space of dimension `> 1`, one may find another
vector linearly independent of the first one. -/
theorem exists_linearIndependent_pair_of_one_lt_finrank [NoZeroSMulDivisors R M]
    (h : 1 < finrank R M) {x : M} (hx : x ≠ 0) :
    ∃ y, LinearIndependent R ![x, y]
-- Mathlib/Data/Finset/Sups.lean
lemma sups_subset_self : s ⊻ s ⊆ s ↔ SupClosed (s : Set α)
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem coeToSubmodule_inj {I J : FractionalIdeal S P} : (I : Submodule R P) = J ↔ I = J
-- Mathlib/Order/Interval/Set/Infinite.lean
theorem Ico.infinite : Infinite (Ico a b)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem re_inner_le_norm (x y : E) : re ⟪x, y⟫ ≤ ‖x‖ * ‖y‖
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem isOrtho_def {Q : QuadraticMap R M N} {x y : M} : Q.IsOrtho x y ↔ Q (x + y) = Q x + Q y
-- Mathlib/Data/Set/Function.lean
theorem SurjOn.mapsTo_invFunOn [Nonempty α] (h : SurjOn f s t) : MapsTo (invFunOn f s) t s
-- Mathlib/Algebra/Field/Basic.lean
theorem sub_div (a b c : K) : (a - b) / c = a / c - b / c
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_map : b ∈ map f s ↔ f.symm b ∈ s
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
/-- A version of `WithTop.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithTop.map` for `ZeroHom`s"]
protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithTop M) (WithTop N)
-- Mathlib/Topology/Defs/Induced.lean
/-- A function between topological spaces is an embedding if it is injective,
  and for all `s : Set X`, `s` is open iff it is the preimage of an open set. -/
@[mk_iff]
structure Embedding [TopologicalSpace X] [TopologicalSpace Y] (f : X → Y) extends
  Inducing f : Prop where
  /-- A topological embedding is injective. -/
  inj : Function.Injective f
-- Mathlib/RingTheory/DedekindDomain/Dvr.lean
/-- In a Dedekind domain, the localization at every nonzero prime ideal is a DVR. -/
theorem IsLocalization.AtPrime.discreteValuationRing_of_dedekind_domain [IsDedekindDomain A]
    {P : Ideal A} (hP : P ≠ ⊥) [pP : P.IsPrime] (Aₘ : Type*) [CommRing Aₘ] [IsDomain Aₘ]
    [Algebra A Aₘ] [IsLocalization.AtPrime Aₘ P] : DiscreteValuationRing Aₘ