ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean
theorem FiniteDimensional.rank_linearMap_self :
    Module.rank S (M →ₗ[R] S) = lift.{u'} (Module.rank R M)
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
theorem one_of_one_le (h : 1 ≤ x) : smoothTransition x = 1
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem sbtw_mul_sub_add_iff [NoZeroDivisors R] {x y r : R} :
    Sbtw R x (r * (y - x) + x) y ↔ x ≠ y ∧ r ∈ Set.Ioo (0 : R) 1
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
lemma scaleRoots_dvd_iff (p q : R[X]) {r : R} (hr : IsUnit r) :
    p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q
-- Mathlib/Data/Set/Lattice.lean
theorem image2_iInter₂_subset_left (s : ∀ i, κ i → Set α) (t : Set β) :
    image2 f (⋂ (i) (j), s i j) t ⊆ ⋂ (i) (j), image2 f (s i j) t
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_toMul : UniformContinuous (toMul : Additive α → α)
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin_contains_field_as_subfield (F : Subfield E) : (F : Set E) ⊆ adjoin F S
-- Mathlib/Data/Finsupp/Indicator.lean
theorem indicator_injective : Injective fun f : ∀ i ∈ s, α => indicator s f
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem union_vsub : s₁ ∪ s₂ -ᵥ t = s₁ -ᵥ t ∪ (s₂ -ᵥ t)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem tendsto_atTop [Nonempty β] [SemilatticeSup β] {u : β → α} {a : α} :
    Tendsto u atTop (𝓝 a) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε
-- Mathlib/Algebra/Star/Basic.lean
@[simp, norm_cast]
theorem star_intCast [Ring R] [StarRing R] (z : ℤ) : star (z : R) = z
-- Mathlib/LinearAlgebra/TensorProduct/Subalgebra.lean
theorem mulMap'_surjective : Function.Surjective (mulMap' A B)
-- Mathlib/Analysis/Convex/Normed.lean
/-- Convex hull of `s` is bounded if and only if `s` is bounded. -/
@[simp]
theorem isBounded_convexHull {s : Set E} :
    Bornology.IsBounded (convexHull ℝ s) ↔ Bornology.IsBounded s
-- Mathlib/SetTheory/Game/Basic.lean
@[simp]
theorem quot_one_mul (x : PGame) : (⟦1 * x⟧ : Game) = ⟦x⟧
-- Mathlib/Order/Basic.lean
theorem LinearOrder.ext {A B : LinearOrder α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) : A = B
-- Mathlib/Order/Lattice.lean
theorem sup_idem (a : α) : a ⊔ a = a
-- Mathlib/Algebra/Associated/Basic.lean
@[simp] theorem mk_zero [Zero α] [Monoid α] : Associates.mk (0 : α) = 0
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem comap_snd_neBot_iff {f : Filter β} :
    (f.comap (Prod.snd : α × β → β)).NeBot ↔ Nonempty α ∧ f.NeBot
-- Mathlib/Topology/Order/Hom/Basic.lean
theorem copy_eq (f : α →Co β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoLocallyUniformlyOn.congr_right {g : α → β} (hf : TendstoLocallyUniformlyOn F f p s)
    (hg : s.EqOn f g) : TendstoLocallyUniformlyOn F g p s
-- Mathlib/Data/Nat/Choose/Multinomial.lean
theorem succ_mul_binomial [DecidableEq α] (h : a ≠ b) :
    (f a + f b).succ * multinomial {a, b} f =
      (f a).succ * multinomial {a, b} (Function.update f a (f a).succ)
-- Mathlib/Control/Functor.lean
protected theorem ext {α} {x y : Comp F G α} : x.run = y.run → x = y
-- Mathlib/RingTheory/TensorProduct/Basic.lean
nonrec theorem _root_.Commute.tmul {a₁ a₂ : A} {b₁ b₂ : B}
    (ha : Commute a₁ a₂) (hb : Commute b₁ b₂) :
    Commute (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_monomial (a : R) (n : ℕ) : leadingCoeff (monomial n a) = a
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem lift_unique (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = 0) (g : ExteriorAlgebra R M →ₐ[R] A) :
    g.toLinearMap.comp (ι R) = f ↔ g = lift R ⟨f, cond⟩
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma pow_le_pow_of_le_one [ZeroLEOneClass α] [PosMulMono α] [MulPosMono α]
    (ha₀ : 0 ≤ a) (ha₁ : a ≤ 1) : ∀ {m n : ℕ}, m ≤ n → a ^ n ≤ a ^ m
-- Mathlib/GroupTheory/Perm/Support.lean
theorem Disjoint.inv_left (h : Disjoint f g) : Disjoint f⁻¹ g
-- Mathlib/Order/Heyting/Basic.lean
@[simp, nolint simpNF]
theorem hnot_eq : ￢a = unit
-- Mathlib/Order/Interval/Finset/Basic.lean
lemma transGen_wcovBy_of_le [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x ≤ y) :
    TransGen (· ⩿ ·) x y
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
/--
A class describing the property of reflecting effective epimorphic families.
-/
class ReflectsEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects effective epimorphic families if families that are mapped to effective
  epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
-- Mathlib/Algebra/Order/Module/Defs.lean
/-- Typeclass for strict monotonicity of scalar multiplication by positive elements on the left,
namely `b₁ < b₂ → a • b₁ < a • b₂` if `0 < a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulStrictMono : Prop where
  /-- Do not use this. Use `smul_lt_smul_of_pos_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 < a) ⦃b₁ b₂ : β⦄ (hb : b₁ < b₂) : a • b₁ < a • b₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem toReal_coe_eq_self_iff_mem_Ioc {θ : ℝ} : (θ : Angle).toReal = θ ↔ θ ∈ Set.Ioc (-π) π
-- Mathlib/Algebra/MonoidAlgebra/Grading.lean
theorem grade_eq_lsingle_range (m : M) :
    grade R m = LinearMap.range (Finsupp.lsingle m : R →ₗ[R] M →₀ R)
-- Mathlib/Data/Fintype/Card.lean
theorem subtype_card {p : α → Prop} (s : Finset α) (H : ∀ x : α, x ∈ s ↔ p x) :
    @card { x // p x } (Fintype.subtype s H) = s.card
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem natAdd_zero {n : Nat} : natAdd 0 = cast (Nat.zero_add n).symm
-- Mathlib/Analysis/RCLike/Basic.lean
theorem real_smul_eq_coe_smul [AddCommGroup E] [Module K E] [Module ℝ E] [IsScalarTower ℝ K E]
    (r : ℝ) (x : E) : r • x = (r : K) • x
-- Mathlib/CategoryTheory/Idempotents/FunctorCategories.lean
@[reassoc (attr := simp)]
theorem app_p_comp : P.p.app X ≫ f.f.app X = f.f.app X
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem IsStrongLimit.two_power_lt {x c} (h : IsStrongLimit c) : x < c → (2^x) < c
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
/-- A path whose support contains every vertex is hamiltonian. -/
lemma IsPath.isHamiltonian_of_mem (hp : p.IsPath) (hp' : ∀ w, w ∈ p.support) :
    p.IsHamiltonian
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
/-- Morphisms in `SimplicialObject.Split C` are morphisms of simplicial objects that
are compatible with the splittings. -/
structure Hom (S₁ S₂ : Split C) where
  /-- the morphism between the underlying simplicial objects -/
  F : S₁.X ⟶ S₂.X
  /-- the morphism between the "nondegenerate" `n`-simplices for all `n : ℕ` -/
  f : ∀ n : ℕ, S₁.s.N n ⟶ S₂.s.N n
  comm : ∀ n : ℕ, S₁.s.ι n ≫ F.app (op [n]) = f n ≫ S₂.s.ι n := by aesop_cat
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_sub_eq_left_of_degree_lt (h : degree q < degree p) : degree (p - q) = degree p
-- Mathlib/NumberTheory/NumberField/Basic.lean
@[simp] lemma mk_zero : (⟨0, zero_mem _⟩ : 𝓞 K) = 0
-- Mathlib/GroupTheory/Perm/Closure.lean
theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
    closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤
-- Mathlib/LinearAlgebra/Prod.lean
@[simp] theorem snd_comp_inl : snd R M M₂ ∘ₗ inl R M M₂ = 0
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem or_true (p : Prop) : (p ∨ True) = True
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp, norm_cast]
theorem coe_mul : ((φ * ψ : MvPolynomial σ R) : MvPowerSeries σ R) = φ * ψ
-- Mathlib/GroupTheory/Perm/Support.lean
theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card
-- Mathlib/GroupTheory/Abelianization.lean
@[simp]
theorem abelianizationCongr_of (x : G) :
    e.abelianizationCongr (Abelianization.of x) = Abelianization.of (e x)
-- Mathlib/Data/List/Destutter.lean
@[simp]
theorem destutter'_eq_self_iff (a) : l.destutter' R a = a :: l ↔ l.Chain R a
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_symm_of_eq_add {n a b : ℕ} (h : n = a + b) : Nat.choose n a = Nat.choose n b
-- Mathlib/RingTheory/PowerSeries/Basic.lean
/-- First coefficient of the `n`-th power of a power series. -/
lemma coeff_one_pow (n : ℕ) (φ : R⟦X⟧) :
    coeff R 1 (φ ^ n) = n * coeff R 1 φ * (constantCoeff R φ) ^ (n - 1)
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem dom_natCast (x : ℕ) : (x : PartENat).Dom
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[aesop safe 20 apply (rule_sets := [Measurable])]
protected theorem dist {_ : MeasurableSpace α} {β : Type*} [PseudoMetricSpace β] {f g : α → β}
    (hf : StronglyMeasurable f) (hg : StronglyMeasurable g) :
    StronglyMeasurable fun x => dist (f x) (g x)
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem integrableOn_Icc_iff_integrableOn_Ioo' (ha : μ {a} ≠ ∞) (hb : μ {b} ≠ ∞) :
    IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioo a b) μ
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem prev (α : Type*) [AddRightCancelSemigroup α] [One α] (i : α) :
    (ComplexShape.down α).prev i = i + 1
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1_nonneg {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f : α →₁[μ] G'}
    (hf : 0 ≤ f) : 0 ≤ setToL1 hT f
-- Mathlib/RingTheory/Polynomial/Wronskian.lean
theorem wronskian_add_left (a b c : R[X]) : wronskian (a + b) c = wronskian a c + wronskian b c
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_sphere' : y ∈ sphere x ε ↔ dist x y = ε
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
theorem biprod.lift_eq {T : C} {f : T ⟶ X} {g : T ⟶ Y} :
    biprod.lift f g = f ≫ biprod.inl + g ≫ biprod.inr
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem succ_coe_top : succ ↑(⊤ : α) = (⊤ : WithTop α)
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem diam_preimage (s : Set β) : Metric.diam (h ⁻¹' s) = Metric.diam s
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma add_pow_le (ha : 0 ≤ a) (hb : 0 ≤ b) : ∀ n, (a + b) ^ n ≤ 2 ^ (n - 1) * (a ^ n + b ^ n)
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive]
theorem Prod.commute_iff {x y : M × N} :
    Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma IsConj.symm (hσ : IsConj φ σ) :
    IsConj φ σ.symm
-- Mathlib/Algebra/Module/Bimodule.lean
/-- Forgetting the `A` action, a `Submodule` over `A ⊗[R] B` is just a `Submodule` over `B`. -/
@[simps]
def toSubmodule' (p : Submodule (A ⊗[R] B) M) : Submodule B M
-- Mathlib/MeasureTheory/Function/LpSpace.lean
/-- A version of `Set.indicator_add` for `MeasureTheory.indicatorConstLp`.-/
theorem indicatorConstLp_add {c' : E} :
    indicatorConstLp p hs hμs c + indicatorConstLp p hs hμs c' =
    indicatorConstLp p hs hμs (c + c')
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_id : (id R₁ M₁ : M₁ →ₗ[R₁] M₁) = LinearMap.id
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
theorem le_pointwise_smul_iff₀ {a : M} (ha : a ≠ 0) {S T : Subring R} : S ≤ a • T ↔ a⁻¹ • S ≤ T
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
@[simp]
lemma basis_one : CoordinateRing.basis W 1 = mk W Y
-- Mathlib/RingTheory/Localization/Basic.lean
protected theorem eq {a₁ b₁} {a₂ b₂ : M} :
    mk' S a₁ a₂ = mk' S b₁ b₂ ↔ ∃ c : M, ↑c * (↑b₂ * a₁) = c * (a₂ * b₁)
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem coeff_ofNat_succ (a n : ℕ) [h : a.AtLeastTwo] :
    coeff (no_index (OfNat.ofNat a : R[X])) (n + 1) = 0
-- Mathlib/Algebra/Lie/Weights/Killing.lean
@[simp] lemma coe_neg : ((-α : Weight K H L) : H → K) = -α
-- Mathlib/CategoryTheory/Category/Pointed.lean
/-- The identity morphism of `X : Pointed`. -/
@[simps]
def id (X : Pointed) : Pointed.Hom X X
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_or {p q : Prop} (s : p ∨ q → Set α) :
    ⋃ h, s h = (⋃ i, s (Or.inl i)) ∪ ⋃ j, s (Or.inr j)
-- Mathlib/Data/Nat/Defs.lean
lemma sqrt_lt : sqrt m < n ↔ m < n * n
-- Mathlib/SetTheory/ZFC/Basic.lean
/-- Unlike the other set constructors, the `iota` definite descriptor
  is a set for any set input, but not constructively so, so there is no
  associated `Class → Set` function. -/
theorem iota_ex (A) : iota.{u} A ∈ univ.{u}
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem neg_iSup {ι : Sort*} (S : ι → Submodule R M) : (-⨆ i, S i) = ⨆ i, -S i
-- Mathlib/Logic/Function/OfArity.lean
@[simp]
theorem const_succ (α : Type u) {β : Type u} (b : β) (n : ℕ) :
    const α b n.succ = fun _ => const _ b n
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem eval₂Hom_congr' {f₁ f₂ : R →+* S} {g₁ g₂ : σ → S} {p₁ p₂ : MvPolynomial σ R} :
    f₁ = f₂ →
      (∀ i, i ∈ p₁.vars → i ∈ p₂.vars → g₁ i = g₂ i) →
        p₁ = p₂ → eval₂Hom f₁ g₁ p₁ = eval₂Hom f₂ g₂ p₂
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem ofFractionRing_mul (p q : FractionRing K[X]) :
    ofFractionRing (p * q) = ofFractionRing p * ofFractionRing q
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem sup_sInf_eq : a ⊔ sInf s = ⨅ b ∈ s, a ⊔ b
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem algebraMap_exp_comm_of_mem_ball [CompleteSpace 𝕂] (x : 𝕂)
    (hx : x ∈ EMetric.ball (0 : 𝕂) (expSeries 𝕂 𝕂).radius) :
    algebraMap 𝕂 𝔸 (exp 𝕂 x) = exp 𝕂 (algebraMap 𝕂 𝔸 x)
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem multiset_prod_comp (s : Multiset R[X]) (q : R[X]) :
    s.prod.comp q = (s.map fun p : R[X] => p.comp q).prod
-- Mathlib/Algebra/Algebra/Bilinear.lean
theorem _root_.Algebra.lmul_injective : Function.Injective (Algebra.lmul R A)
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- If a filter is converging, its liminf coincides with its limit. -/
theorem limsSup_eq_of_le_nhds : ∀ {f : Filter α} {a : α} [NeBot f], f ≤ 𝓝 a → f.limsSup = a
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma pow_right_injective (ha₀ : 0 < a) (ha₁ : a ≠ 1) : Injective (a ^ ·)
-- Mathlib/Order/WellFoundedSet.lean
theorem PartiallyWellOrderedOn.wellFoundedOn [IsPreorder α r] (h : s.PartiallyWellOrderedOn r) :
    s.WellFoundedOn fun a b => r a b ∧ ¬r b a
-- Mathlib/Topology/RestrictGenTopology.lean
protected theorem mono {T} (hS : RestrictGenTopology S) (hT : S ⊆ T) : RestrictGenTopology T
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem subtype_comp_codRestrict (f : F) (S : NonUnitalStarSubalgebra R B) (hf : ∀ x : A, f x ∈ S) :
    (NonUnitalStarSubalgebraClass.subtype S).comp (NonUnitalStarAlgHom.codRestrict f S hf) = f
-- Mathlib/CategoryTheory/Limits/FullSubcategory.lean
theorem ClosedUnderLimitsOfShape.limit (h : ClosedUnderLimitsOfShape J P) {F : J ⥤ C} [HasLimit F] :
    (∀ j, P (F.obj j)) → P (limit F)
-- Mathlib/Algebra/Lie/OfAssociative.lean
/-- Given an equivalence `e` of Lie algebras from `L` to `L'`, and an element `x : L`, the conjugate
of the endomorphism `ad(x)` of `L` by `e` is the endomorphism `ad(e x)` of `L'`. -/
@[simp]
lemma conj_ad_apply (e : L ≃ₗ⁅R⁆ L') (x : L) : LinearEquiv.conj e (ad R L x) = ad R L' (e x)
-- Mathlib/GroupTheory/CoprodI.lean
theorem empty_of_word_prod_eq_one {w : Word H} (h : lift f w.prod = 1) : w = Word.empty
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem attach_map_val (s : Multiset α) : s.attach.map Subtype.val = s
-- Mathlib/MeasureTheory/Measure/Complex.lean
/-- The real part of a complex measure is a signed measure. -/
@[simps! apply]
def re : ComplexMeasure α →ₗ[ℝ] SignedMeasure α
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem sup_support_list_prod_le (degb0 : degb 0 ≤ 0)
    (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b) :
    ∀ l : List R[A],
      l.prod.support.sup degb ≤ (l.map fun f : R[A] => f.support.sup degb).sum
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[fun_prop]
nonrec theorem ContinuousAt.inv₀ (hf : ContinuousAt f a) (ha : f a ≠ 0) :
    ContinuousAt (fun x => (f x)⁻¹) a
-- Mathlib/Data/Vector3.lean
@[simp]
theorem append_cons (a : α) (v : Vector3 α m) (w : Vector3 α n) : (a :: v) +-+ w = a :: v +-+ w
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diagonal_mul_diagonal [Fintype n] [DecidableEq n] (d₁ d₂ : n → α) :
    diagonal d₁ * diagonal d₂ = diagonal fun i => d₁ i * d₂ i
-- Mathlib/Algebra/Lie/Weights/Cartan.lean
theorem le_zeroRootSubalgebra : H ≤ zeroRootSubalgebra R L H
-- Mathlib/Data/List/Range.lean
/-- The members of `l.ranges` have no duplicate -/
theorem ranges_nodup {l s : List ℕ} (hs : s ∈ ranges l) : s.Nodup
-- Mathlib/Analysis/Calculus/Implicit.lean
/-- `HasStrictFDerivAt.implicitFunctionOfComplemented` sends `(z, y)` to a point in `f ⁻¹' z`. -/
theorem map_implicitFunctionOfComplemented_eq (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    ∀ᶠ p : F × ker f' in 𝓝 (f a, 0),
      f (hf.implicitFunctionOfComplemented f f' hf' hker p.1 p.2) = p.1
-- Mathlib/MeasureTheory/Integral/DivergenceTheorem.lean
/-- **Fundamental theorem of calculus, part 2**. This version assumes that `f` is continuous on the
interval and is differentiable off a countable set `s`.

See also `intervalIntegral.integral_eq_sub_of_hasDeriv_right` for a version that
only assumes right differentiability of `f`.
-/
theorem integral_eq_of_hasDerivWithinAt_off_countable (f f' : ℝ → E) {a b : ℝ} {s : Set ℝ}
    (hs : s.Countable) (Hc : ContinuousOn f [[a, b]])
    (Hd : ∀ x ∈ Ioo (min a b) (max a b) \ s, HasDerivAt f (f' x) x)
    (Hi : IntervalIntegrable f' volume a b) : ∫ x in a..b, f' x = f b - f a
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
theorem mulMap'_surjective : Function.Surjective (mulMap' M N)
-- Mathlib/Topology/Bornology/Basic.lean
@[simp]
theorem isBounded_compl_iff : IsBounded sᶜ ↔ IsCobounded s
-- Mathlib/RingTheory/FiniteType.lean
/-- The image of an element `m : M` in `MonoidAlgebra R M` belongs the submodule generated by
`S : Set M` if and only if `m ∈ S`. -/
theorem of_mem_span_of_iff [Nontrivial R] {m : M} {S : Set M} :
    of R M m ∈ span R (of R M '' S) ↔ m ∈ S
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem isPrimitive_primPart (p : R[X]) : p.primPart.IsPrimitive
-- Mathlib/Topology/Homeomorph.lean
@[ext]
theorem ext {h h' : X ≃ₜ Y} (H : ∀ x, h x = h' x) : h = h'
-- Mathlib/GroupTheory/Commutator.lean
@[simp]
theorem commutator_bot_right : ⁅H₁, ⊥⁆ = (⊥ : Subgroup G)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem refl_toPartialEquiv : (Equiv.refl α).toPartialEquiv = PartialEquiv.refl α
-- Mathlib/Data/Set/Card.lean
theorem Finite.cast_ncard_eq (hs : s.Finite) : s.ncard = s.encard
-- Mathlib/RingTheory/Idempotents.lean
/-- Idempotents lift along nil ideals. -/
theorem exists_isIdempotentElem_eq_of_ker_isNilpotent (h : ∀ x ∈ RingHom.ker f, IsNilpotent x)
    (e : S) (he : e ∈ f.range) (he' : IsIdempotentElem e) :
    ∃ e' : R, IsIdempotentElem e' ∧ f e' = e
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma negY_negY (x y : R) : W.negY x (W.negY x y) = y
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
/-- If `f` satisfies a boundedness property around `0`, one can deduce a bound on `f m₁ - f m₂`
using the multilinearity. Here, we give a usable but not very precise version. See
`norm_image_sub_le_of_bound'` for a more precise but less usable version. The bound is
`‖f m - f m'‖ ≤ C * card ι * ‖m - m'‖ * (max ‖m‖ ‖m'‖) ^ (card ι - 1)`. -/
theorem norm_image_sub_le_of_bound {C : ℝ} (hC : 0 ≤ C) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (m₁ m₂ : ∀ i, E i) :
    ‖f m₁ - f m₂‖ ≤ C * Fintype.card ι * max ‖m₁‖ ‖m₂‖ ^ (Fintype.card ι - 1) * ‖m₁ - m₂‖
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp, norm_cast]
theorem coe_sub (f g : CauSeq β abv) : ⇑(f - g) = (f : ℕ → β) - g
-- Mathlib/Order/CompleteLattice.lean
theorem Antitone.map_iSup_le [CompleteLattice β] {f : α → β} (hf : Antitone f) :
    f (iSup s) ≤ ⨅ i, f (s i)
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `u` is a sequence which is unbounded below,
then it `Frequently` reaches a value strictly smaller than all previous values.
-/
theorem frequently_low_scores [LinearOrder β] [NoMinOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atBot) : ∃ᶠ n in atTop, ∀ k < n, u n < u k
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[simp]
lemma FixedPoints.mem_submonoid (a : α) : a ∈ submonoid M α ↔ ∀ m : M, m • a = a
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem mem_Ioo : x ∈ Ioo a b ↔ a < x ∧ x < b
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The symbol `J(a | b)` is nonzero when `a` and `b` are coprime. -/
protected theorem ne_zero {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) ≠ 0
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem coe_comp (f : BotHom β γ) (g : BotHom α β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/Order/Defs.lean
theorem compare_iff (a b : α) {o : Ordering} : compare a b = o ↔ o.toRel a b
-- Mathlib/Order/RelIso/Basic.lean
protected theorem acc [RelHomClass F r s] (f : F) (a : α) : Acc s (f a) → Acc r a
-- Mathlib/GroupTheory/Sylow.lean
theorem Sylow.smul_le {P : Sylow p G} {H : Subgroup G} (hP : ↑P ≤ H) (h : H) : ↑(h • P) ≤ H
-- Mathlib/SetTheory/ZFC/Basic.lean
@[ext]
theorem ext {x y : ZFSet.{u}} : (∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y) → x = y
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A subspace is less than another if and only if it is less than or equal to the second subspace
and there is a point only in the second. -/
theorem lt_iff_le_and_exists (s1 s2 : AffineSubspace k P) :
    s1 < s2 ↔ s1 ≤ s2 ∧ ∃ p ∈ s2, p ∉ s1
-- Mathlib/Topology/Basic.lean
theorem ContinuousAt.preimage_mem_nhds {t : Set Y} (h : ContinuousAt f x)
    (ht : t ∈ 𝓝 (f x)) : f ⁻¹' t ∈ 𝓝 x
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
theorem map_id : @map X Y Y _ id = id
-- Mathlib/RingTheory/Perfection.lean
theorem equiv_apply {π : P →+* R} (m : PerfectionMap p π) (x : P) :
    m.equiv x = Perfection.lift p P R π x
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem succ_le_castSucc_iff {a b : Fin n} : succ a ≤ castSucc b ↔ a < b
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma image_coe_Icc (x y : ℝ) : Real.toEReal '' Icc x y = Icc ↑x ↑y
-- Mathlib/Algebra/Order/Ring/WithTop.lean
@[simp] lemma mul_top (h : a ≠ 0) : a * ⊤ = ⊤
-- Mathlib/Topology/Sets/Opens.lean
@[simp]
lemma mem_top (x : α) : x ∈ (⊤ : Opens α)
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
@[simp]
theorem xgcdAux_fst (x y : R) : ∀ s t s' t', (xgcdAux x s t y s' t').1 = gcd x y
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem contMDiff_subtype_val {n : ℕ∞} {U : Opens M} : ContMDiff I I n (Subtype.val : U → M)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
theorem ContinuousMultilinearMap.uncurry0_curry0 (f : G[×0]→L[𝕜] G') :
    ContinuousMultilinearMap.curry0 𝕜 G f.uncurry0 = f
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
/-- The homogeneous submodules form a graded ring.
This instance is used by `DirectSum.commSemiring` and `DirectSum.algebra`. -/
lemma HomogeneousSubmodule.gradedMonoid :
    SetLike.GradedMonoid (homogeneousSubmodule σ R)
-- Mathlib/Data/Holor.lean
theorem take_take : ∀ t : HolorIndex (ds₁ ++ ds₂ ++ ds₃), t.assocRight.take = t.take.take
-- Mathlib/Algebra/GroupWithZero/Hom.lean
protected lemma map_zero (f : α →*₀ β) : f 0 = 0
-- Mathlib/Order/GameAdd.lean
theorem Acc.sym2_gameAdd {a b} (ha : Acc rα a) (hb : Acc rα b) :
    Acc (Sym2.GameAdd rα) s(a, b)
-- Mathlib/Algebra/Group/Hom/Instances.lean
theorem AddMonoid.End.one_apply [AddCommMonoid M] (m : M) : (1 : AddMonoid.End M) m = m
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
theorem lift_uniq (H' : Set.range g.1.base ⊆ Set.range f.1.base) (l : Y ⟶ X) (hl : l ≫ f = g) :
    l = lift f g H'
-- Mathlib/Order/OmegaCompletePartialOrder.lean
@[simps! ωSup_coe]
instance omegaCompletePartialOrder : OmegaCompletePartialOrder (α →o β)
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- If the liminf and the limsup of a filter coincide, then this filter converges to
their common value, at least if the filter is eventually bounded above and below. -/
theorem le_nhds_of_limsSup_eq_limsInf {f : Filter α} {a : α} (hl : f.IsBounded (· ≤ ·))
    (hg : f.IsBounded (· ≥ ·)) (hs : f.limsSup = a) (hi : f.limsInf = a) : f ≤ 𝓝 a