ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_mul_coe_angle {x y : ℂ} (hx : x ≠ 0) (hy : y ≠ 0) :
    (arg (x * y) : Real.Angle) = arg x + arg y
-- Mathlib/RingTheory/Trace/Defs.lean
/-- If `x` is in the base field `K`, then the trace is `[L : K] * x`. -/
theorem trace_algebraMap_of_basis (x : R) : trace R S (algebraMap R S x) = Fintype.card ι • x
-- Mathlib/Order/Partition/Finpartition.lean
theorem atomise_empty (hs : s.Nonempty) : (atomise s ∅).parts = {s}
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem symm_dual_comp (g : βᵒᵈ →o γᵒᵈ) (f : αᵒᵈ →o βᵒᵈ) :
    OrderHom.dual.symm (g.comp f) = (OrderHom.dual.symm g).comp (OrderHom.dual.symm f)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_left_comm : ∀ a b c, a ♯ (b ♯ c) = b ♯ (a ♯ c)
-- Mathlib/Data/Set/Lattice.lean
lemma iSup_sUnion (S : Set (Set α)) (f : α → β) :
    (⨆ x ∈ ⋃₀ S, f x) = ⨆ (s ∈ S) (x ∈ s), f x
-- Mathlib/Algebra/Order/Field/Power.lean
protected theorem Even.zpow_nonneg (hn : Even n) (a : α) : 0 ≤ a ^ n
-- Mathlib/Data/Nat/Factorization/Basic.lean
theorem ord_compl_le (n p : ℕ) : ord_compl[p] n ≤ n
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean
lemma norm_eq_max_natAbs (x : Fin 2 → ℤ) : ‖x‖ = max (x 0).natAbs (x 1).natAbs
-- Mathlib/Analysis/Convex/Body.lean
protected theorem isClosed [T2Space V] (K : ConvexBody V) : IsClosed (K : Set V)
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
theorem Intersecting.not_bot_mem (hs : s.Intersecting) : ⊥ ∉ s
-- Mathlib/Logic/Equiv/PartialEquiv.lean
/-- The product of a family of partial equivalences, as a partial equivalence on the pi type. -/
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i)
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem hasDerivAtFilter_const : HasDerivAtFilter (fun _ => c) 0 x L
-- Mathlib/SetTheory/ZFC/Basic.lean
@[symm]
protected theorem Resp.Equiv.symm {n} {a b : Resp n} : Resp.Equiv a b → Resp.Equiv b a
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma truncatedSup_infs_of_not_mem (ha : a ∉ lowerClosure s ⊓ lowerClosure t) :
    truncatedSup (s ⊼ t) a = ⊤
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurableSet_mem (a : α) : MeasurableSet {s : Set α | a ∈ s}
-- Mathlib/FieldTheory/PerfectClosure.lean
private theorem mul_aux_right (x y1 y2 : ℕ × K) (H : R K p y1 y2) :
    mk K p (x.1 + y1.1, (frobenius K p)^[y1.1] x.2 * (frobenius K p)^[x.1] y1.2) =
      mk K p (x.1 + y2.1, (frobenius K p)^[y2.1] x.2 * (frobenius K p)^[x.1] y2.2)
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma setIntegral_toReal_rnDeriv [SigmaFinite μ] [SigmaFinite ν] (hμν : μ ≪ ν) (s : Set α) :
    ∫ x in s, (μ.rnDeriv ν x).toReal ∂ν = (μ s).toReal
-- Mathlib/CategoryTheory/EqToHom.lean
/-- Proving equality between functors. This isn't an extensionality lemma,
  because usually you don't really want to do this. -/
theorem ext {F G : C ⥤ D} (h_obj : ∀ X, F.obj X = G.obj X)
    (h_map : ∀ X Y f,
      F.map f = eqToHom (h_obj X) ≫ G.map f ≫ eqToHom (h_obj Y).symm := by aesop_cat) :
    F = G
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem range_enumOrd (hS : Unbounded (· < ·) S) : range (enumOrd S) = S
-- .lake/packages/lean4/src/lean/Init/Data/AC.lean
theorem Context.toList_nonEmpty (e : Expr) : e.toList ≠ []
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem Measure.QuasiMeasurePreserving.ae_eq_comp {ν : Measure β} {f : α → β} {g g' : β → δ}
    (hf : QuasiMeasurePreserving f μ ν) (h : g =ᵐ[ν] g') : g ∘ f =ᵐ[μ] g' ∘ f
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
@[simp]
lemma map₂_val {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X Y : C} (f : X ⟶ Y)
    {s : yoneda.obj X ⟶ A} {t : yoneda.obj Y ⟶ A} (hst : yoneda.map f ≫ t = s)
    (u : OverArrows η t) : (u.map₂ f hst).val = F.map f.op u.val
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem apply_symm_apply (e : A₁ ≃ₐ[R] A₂) : ∀ x, e (e.symm x) = x
-- Mathlib/Topology/Maps/Basic.lean
theorem inducing_id : Inducing (@id X)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem eval_gcd_eq_zero [DecidableEq R] {f g : R[X]} {α : R}
    (hf : f.eval α = 0) (hg : g.eval α = 0) : (EuclideanDomain.gcd f g).eval α = 0
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem inl_apply [Module R₁ M₂] (x : M₁) : inl R₁ M₁ M₂ x = (x, 0)
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
/-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem coe_restrictScalars {E : IntermediateField L' L} :
    (restrictScalars K E : Set L) = (E : Set L)
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
theorem braiding_leftUnitor_aux₂ (X : C) :
    ((β_ X (𝟙_ C)).hom ▷ 𝟙_ C) ≫ ((λ_ X).hom ▷ 𝟙_ C) = (ρ_ X).hom ▷ 𝟙_ C
-- Mathlib/LinearAlgebra/Reflection.lean
lemma invOn_reflection_of_mapsTo {Φ : Set M} (h : f x = 2) :
    InvOn (reflection h) (reflection h) Φ Φ
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
theorem isIso_π_of_isTerminal {j : J} (I : IsTerminal j) (F : J ⥤ C) [HasLimit F]
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsIso (limit.π F j)
-- Mathlib/CategoryTheory/Category/Bipointed.lean
/-- The identity morphism of `X : Bipointed`. -/
@[simps]
nonrec def id (X : Bipointed) : Bipointed.Hom X X
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem range_restrictDom (s : Set α) [DecidablePred (· ∈ s)] :
    LinearMap.range (restrictDom M R s) = ⊤
-- Mathlib/Topology/Order/LeftRight.lean
lemma frequently_gt_nhds (a : α) [NeBot (𝓝[>] a)] : ∃ᶠ x in 𝓝 a, a < x
-- Mathlib/Topology/Sets/Opens.lean
@[simp] theorem carrier_eq_coe (U : Opens α) : U.1 = ↑U
-- Mathlib/LinearAlgebra/Reflection.lean
lemma preReflection_preReflection (g : Dual R M) (h : f x = 2) :
    preReflection (preReflection x f y) (preReflection f (Dual.eval R M x) g) =
    (preReflection x f) ∘ₗ (preReflection y g) ∘ₗ (preReflection x f)
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasFDerivWithinAt.inner (hf : HasFDerivWithinAt f f' s x)
    (hg : HasFDerivWithinAt g g' s x) :
    HasFDerivWithinAt (fun t => ⟪f t, g t⟫) ((fderivInnerCLM 𝕜 (f x, g x)).comp <| f'.prod g') s
      x
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem restrictScalars_apply (fₗ : M →ₗ[S] M₂) (x) : restrictScalars R fₗ x = fₗ x
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem wbtw_vadd_const_iff {x y z : V} (p : P) :
    Wbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Wbtw R x y z
-- Mathlib/Order/Hom/Basic.lean
/-- Order isomorphism between the space of monotone maps to `β × γ` and the product of the spaces
of monotone maps to `β` and `γ`. -/
@[simps]
def prodIso : (α →o β × γ) ≃o (α →o β) × (α →o γ)
-- Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
theorem objSupIsoProdEqLocus_inv_snd {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
    F.1.map (homOfLE le_sup_right).op ((F.objSupIsoProdEqLocus U V).inv x) = x.1.2
-- Mathlib/Probability/Kernel/MeasureCompProd.lean
@[simp]
lemma snd_dirac_unit_compProd_const (μ : Measure β) [IsFiniteMeasure μ] :
    snd (Measure.dirac () ⊗ₘ Kernel.const Unit μ) = μ
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_pos [PosSMulStrictMono α β] (ha : 0 < a) (hb : 0 < b) : 0 < a • b
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Only assumes right strict covariance. -/
@[to_additive "Only assumes right strict covariance"]
theorem Right.mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c d : α}
    (h₁ : a < b) (h₂ : c < d) :
    a * c < b * d
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_inv (x : H) : ↑(x⁻¹ : H) = (x⁻¹ : G)
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem deriv_sqrt_aux {x : ℝ} (hx : x ≠ 0) :
    HasStrictDerivAt (√·) (1 / (2 * √x)) x ∧ ∀ n, ContDiffAt ℝ n (√·) x
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
@[local simp]
theorem transitionMap_map_pow {m n a : ℕ} (hmn : m ≤ n) (x : R ⧸ (I ^ n • ⊤ : Ideal R)) :
    transitionMap I R hmn (x ^ a) = transitionMap I R hmn x ^ a
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_option (f : Option β → α) : ⨅ o, f o = f none ⊓ ⨅ b, f (Option.some b)
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
@[simp]
theorem coe_smul (r : ℝ≥0) : (r : ℝ) • j = r • j
-- Mathlib/Data/Multiset/Basic.lean
theorem le_add_right (s t : Multiset α) : s ≤ s + t
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
@[simp]
theorem coe_openToLocalization (U : Opens (PrimeSpectrum.Top R)) (x : PrimeSpectrum.Top R)
    (hx : x ∈ U) :
    (openToLocalization R U x hx :
        (structureSheaf R).1.obj (op U) → Localization.AtPrime x.asIdeal) =
      fun s => (s.1 ⟨x, hx⟩ : _)
-- Mathlib/Order/Interval/Set/OrderIso.lean
@[simp]
theorem preimage_Iic (e : α ≃o β) (b : β) : e ⁻¹' Iic b = Iic (e.symm b)
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem Fork.IsLimit.existsUnique {s : Fork f g} (hs : IsLimit s) {W : C} (k : W ⟶ X)
    (h : k ≫ f = k ≫ g) : ∃! l : W ⟶ s.pt, l ≫ Fork.ι s = k
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_right_comm (m n k : Nat) : m - n - k = m - k - n
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp] lemma isNClique_empty : G.IsNClique n ∅ ↔ n = 0
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem add_def (x y x' y' : ℤ) : (⟨x, y⟩ + ⟨x', y'⟩ : ℤ√d) = ⟨x + x', y + y'⟩
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesAt.eq_formalMultilinearSeries_of_eventually
    {p q : FormalMultilinearSeries 𝕜 𝕜 E} {f g : 𝕜 → E} {x : 𝕜} (hp : HasFPowerSeriesAt f p x)
    (hq : HasFPowerSeriesAt g q x) (heq : ∀ᶠ z in 𝓝 x, f z = g z) : p = q
-- Mathlib/Data/DFinsupp/Basic.lean
/-- Like `Finsupp.single_eq_single_iff`, but with a `HEq` due to dependent types -/
theorem single_eq_single_iff (i j : ι) (xi : β i) (xj : β j) :
    DFinsupp.single i xi = DFinsupp.single j xj ↔ i = j ∧ HEq xi xj ∨ xi = 0 ∧ xj = 0
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem isLeftDescent_iff {w : W} {i : B} :
    cs.IsLeftDescent w i ↔ ℓ (s i * w) + 1 = ℓ w
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.le_toIdeal_homogeneousHull : I ≤ (Ideal.homogeneousHull 𝒜 I).toIdeal
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem eq_of_infinite_eval_eq (p q : R[X]) (h : Set.Infinite { x | eval x p = eval x q }) :
    p = q
-- Mathlib/Order/Fin/Basic.lean
/-- `Fin.rev n` as an order-reversing isomorphism. -/
@[simps! apply toEquiv]
def revOrderIso : (Fin n)ᵒᵈ ≃o Fin n
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem BEqCmp.cmp_iff_eq [BEq α] [LawfulBEq α] [BEqCmp (α := α) cmp] : cmp x y = .eq ↔ x = y
-- Mathlib/ModelTheory/Skolem.lean
theorem exists_small_elementarySubstructure : ∃ S : L.ElementarySubstructure M, Small.{max u v} S
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem IsNormal.apply_lt_nfp {f} (H : IsNormal f) {a b} : f b < nfp f a ↔ b < nfp f a
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem support_smul_subset_vadd_support [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
    {y : HahnModule Γ' R V} :
    ((of R).symm (x • y)).support ⊆ x.support +ᵥ ((of R).symm y).support
-- Mathlib/Topology/Algebra/InfiniteSum/GroupCompletion.lean
/-- A function `f` is summable in a uniform additive group `α` if and only if the net of its partial
sums is Cauchy and its sum in `Completion α` lies in the range of `toCompl : α →+ Completion α`.
(The condition that the net of partial sums is Cauchy can be checked using
`cauchySeq_finset_iff_sum_vanishing` or `cauchySeq_finset_iff_tsum_vanishing`.) -/
theorem summable_iff_cauchySeq_finset_and_tsum_mem (f : β → α) :
    Summable f ↔ CauchySeq (fun s : Finset β ↦ ∑ b in s, f b) ∧
      ∑' i, toCompl (f i) ∈ Set.range toCompl
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
lemma map_smul_eq {Y : Cᵒᵖ} (f : X ⟶ Y) (r₀ : R₀.obj Y) (hr₀ : α.app Y r₀ = R.val.map f r)
    (m₀ : M₀.obj Y) (hm₀ : φ.app Y m₀ = A.val.map f m) :
    A.val.map f (smul α φ r m) = φ.app Y (r₀ • m₀)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem cons_isTrail_iff {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).IsTrail ↔ p.IsTrail ∧ s(u, v) ∉ p.edges
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
@[simp, mfld_simps]
theorem prodChartedSpace_chartAt :
    chartAt (ModelProd H H') x = (chartAt H x.fst).prod (chartAt H' x.snd)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_dvd_iff_zpow_eq_one : (orderOf x : ℤ) ∣ i ↔ x ^ i = 1
-- Mathlib/GroupTheory/Perm/Support.lean
@[simp]
theorem disjoint_refl_iff : Disjoint f f ↔ f = 1
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem trim_measurableSet_eq (hm : m ≤ m0) (hs : @MeasurableSet α m s) : μ.trim hm s = μ s
-- Mathlib/Topology/Category/TopCat/OpenNhds.lean
@[simp]
theorem map_id_obj_unop (x : X) (U : (OpenNhds x)ᵒᵖ) : (map (𝟙 X) x).obj (unop U) = unop U
-- Mathlib/Algebra/Module/LocalizedModule.lean
lemma LocalizedModule.mem_ker_mkLinearMap_iff {S : Submonoid R} {m} :
    m ∈ LinearMap.ker (LocalizedModule.mkLinearMap S M) ↔ ∃ r ∈ S, r • m = 0
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem toList_ne_singleton (y : α) : toList p x ≠ [y]
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem span_pair_add_mul_right {R : Type u} [CommRing R] {x y : R} (z : R) :
    (span {x, y + x * z} : Ideal R) = span {x, y}
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma Y_sub_Y_mul_Y_sub_negY {P Q : Fin 3 → R} (hP : W'.Equation P) (hQ : W'.Equation Q)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) :
    (P y * Q z ^ 3 - Q y * P z ^ 3) * (P y * Q z ^ 3 - W'.negY Q * P z ^ 3) = 0
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem sUnion_apply {x : Class} {y : ZFSet} : (⋃₀ x) y ↔ ∃ z : ZFSet, x z ∧ y ∈ z
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma cast_ne_zero : (n : α) ≠ 0 ↔ n ≠ 0
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioc_mem_nhdsWithin_Iio (H : b ∈ Ioc a c) : Ioc a c ∈ 𝓝[<] b
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem subtypeₗᵢ_toLinearMap : p.subtypeₗᵢ.toLinearMap = p.subtype
-- Mathlib/LinearAlgebra/Prod.lean
theorem fst_map_snd : (Submodule.fst R M M₂).map (LinearMap.snd R M M₂) = ⊥
-- Mathlib/Logic/Function/Defs.lean
theorem Surjective.comp {g : β → φ} {f : α → β} (hg : Surjective g) (hf : Surjective f) :
    Surjective (g ∘ f)
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem iterate_derivative_X_pow_eq_natCast_mul (n k : ℕ) :
    derivative^[k] (X ^ n : R[X]) = ↑(Nat.descFactorial n k : R[X]) * X ^ (n - k)
-- Mathlib/Data/List/Enum.lean
theorem mk_add_mem_enumFrom_iff_get? {n i : ℕ} {x : α} {l : List α} :
    (n + i, x) ∈ enumFrom n l ↔ l.get? i = x
-- Mathlib/Topology/Instances/ENNReal.lean
theorem cauchySeq_of_edist_le_of_tsum_ne_top {f : ℕ → α} (d : ℕ → ℝ≥0∞)
    (hf : ∀ n, edist (f n) (f n.succ) ≤ d n) (hd : tsum d ≠ ∞) : CauchySeq f
-- Mathlib/Algebra/CharP/MixedCharZero.lean
/--
A ring of characteristic zero is of "mixed characteristic `(0, p)`" if there exists an ideal
such that the quotient `R ⧸ I` has characteristic `p`.

**Remark:** For `p = 0`, `MixedChar R 0` is a meaningless definition (i.e. satisfied by any ring)
as `R ⧸ ⊥ ≅ R` has by definition always characteristic zero.
One could require `(I ≠ ⊥)` in the definition, but then `MixedChar R 0` would mean something
like `ℤ`-algebra of extension degree `≥ 1` and would be completely independent from
whether something is a `ℚ`-algebra or not (e.g. `ℚ[X]` would satisfy it but `ℚ` wouldn't).
-/
class MixedCharZero (p : ℕ) : Prop where
  [toCharZero : CharZero R]
  charP_quotient : ∃ I : Ideal R, I ≠ ⊤ ∧ CharP (R ⧸ I) p
-- Mathlib/Algebra/Associated/Basic.lean
theorem Prime.pow_dvd_of_dvd_mul_left [CancelCommMonoidWithZero α] {p a b : α} (hp : Prime p)
    (n : ℕ) (h : ¬p ∣ a) (h' : p ^ n ∣ a * b) : p ^ n ∣ b
-- Mathlib/Topology/Filter.lean
theorem isOpen_setOf_mem {s : Set α} : IsOpen { l : Filter α | s ∈ l }
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
theorem opNNNorm_comp_le [RingHomIsometric σ₁₃] (f : E →SL[σ₁₂] F) : ‖h.comp f‖₊ ≤ ‖h‖₊ * ‖f‖₊
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem ContMDiffAt.inv₀ (hf : ContMDiffAt I' I n f a) (ha : f a ≠ 0) :
    ContMDiffAt I' I n (fun x ↦ (f x)⁻¹) a
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma Localization.essSurj_mapArrow :
    L.mapArrow.EssSurj
-- Mathlib/Data/PNat/Defs.lean
@[simp]
theorem succPNat_coe (n : ℕ) : (succPNat n : ℕ) = succ n
-- Mathlib/Data/Set/Function.lean
theorem congr_left (h₁ : LeftInvOn f₁' f s) {t : Set β} (h₁' : MapsTo f s t)
    (heq : EqOn f₁' f₂' t) : LeftInvOn f₂' f s
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem absorbent_iff_eventually_nhdsWithin_zero :
    Absorbent 𝕜 s ↔ ∀ x : E, ∀ᶠ c : 𝕜 in 𝓝[≠] 0, c • x ∈ s
-- Mathlib/Probability/Independence/Basic.lean
theorem indepSet_iff_indepSets_singleton (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (μ : Measure Ω := by volume_tac)
    [IsProbabilityMeasure μ] : IndepSet s t μ ↔ IndepSets {s} {t} μ
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_and_iff_or_not (p q : Prop) [d₁ : Decidable p] [d₂ : Decidable q] : ¬ (p ∧ q) ↔ ¬ p ∨ ¬ q
-- Mathlib/GroupTheory/Finiteness.lean
/-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid. -/
@[to_additive "An additive subgroup is finitely generated if
and only if it is finitely generated as an additive submonoid."]
theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.FG
-- Mathlib/CategoryTheory/FullSubcategory.lean
@[simp]
theorem FullSubcategory.map_inclusion (h : ∀ ⦃X⦄, Z X → Z' X) :
    FullSubcategory.map h ⋙ fullSubcategoryInclusion Z' = fullSubcategoryInclusion Z
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem trans_apply (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) (x : L₁) : (e₁.trans e₂) x = e₂ (e₁ x)
-- Mathlib/Algebra/Homology/QuasiIso.lean
lemma quasiIso_map_iff_of_preservesHomology [F.ReflectsIsomorphisms] :
    QuasiIso ((F.mapHomologicalComplex c).map φ) ↔ QuasiIso φ
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem Nonempty.of_vsub_right : (s -ᵥ t : Set α).Nonempty → t.Nonempty
-- Mathlib/Data/Matrix/Kronecker.lean
theorem add_kroneckerTMul (A₁ A₂ : Matrix l m α) (B : Matrix n p α) :
    (A₁ + A₂) ⊗ₖₜ[R] B = A₁ ⊗ₖₜ B + A₂ ⊗ₖₜ B
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.mono_g_iff (hS : S.Exact) : Mono S.g ↔ S.f = 0
-- Mathlib/CategoryTheory/NatIso.lean
@[simp]
theorem cancel_natIso_hom_left {X : C} {Z : D} (g g' : G.obj X ⟶ Z) :
    α.hom.app X ≫ g = α.hom.app X ≫ g' ↔ g = g'
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem card_divisors_mul {m n : ℕ} (hmn : m.Coprime n) :
    (m * n).divisors.card = m.divisors.card * n.divisors.card
-- Mathlib/RingTheory/Flat/Basic.lean
/--
If `M` is a flat module, then `f ⊗ 𝟙 M` is injective for all injective linear maps `f`.
-/
theorem rTensor_preserves_injective_linearMap {N' : Type*} [AddCommGroup N'] [Module R N']
    [h : Flat R M] (L : N →ₗ[R] N') (hL : Function.Injective L) :
    Function.Injective (L.rTensor M)
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_compl_inf_distrib (a b : α) : (a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toOrdinal_toNatOrdinal (a : NatOrdinal) :
    Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_min_sub_left (a b c : Nat) : min (a - b) (a - c) = a - max b c
-- Mathlib/Topology/Bases.lean
@[simp]
theorem isSeparable_union {s t : Set α} : IsSeparable (s ∪ t) ↔ IsSeparable s ∧ IsSeparable t
-- Mathlib/Data/List/Nodup.lean
theorem disjoint_of_nodup_append {l₁ l₂ : List α} (d : Nodup (l₁ ++ l₂)) : Disjoint l₁ l₂
-- Mathlib/Topology/Sober.lean
theorem disjoint_iff (h : IsGenericPoint x S) (hU : IsOpen U) : Disjoint S U ↔ x ∉ U
-- Mathlib/Topology/Compactness/Compact.lean
theorem IsCompact.compl_mem_coclosedCompact_of_isClosed (hs : IsCompact s) (hs' : IsClosed s) :
    sᶜ ∈ Filter.coclosedCompact X
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addY_of_X_eq' {P Q : Fin 3 → R} (hP : W'.Equation P) (hQ : W'.Equation Q)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) :
    W'.addY P Q * (P z * Q z) ^ 3 = (-(P y * Q z ^ 3 - Q y * P z ^ 3)) ^ 3
-- Mathlib/Order/Filter/Basic.lean
protected theorem EventuallyEq.rfl {l : Filter α} {f : α → β} : f =ᶠ[l] f
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem polar_toQuadraticMap (x y : M) : polar (toQuadraticMap B) x y = B x y + B y x
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
    f ^ n = 1 ↔ ∀ x, f x ≠ x → (f ^ n) x = x
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
/-- The function `exp (b * x) / x ^ s` tends to `+∞` at `+∞`, for any real `s` and `b > 0`. -/
theorem tendsto_exp_mul_div_rpow_atTop (s : ℝ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun x : ℝ => exp (b * x) / x ^ s) atTop atTop
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
lemma exact_cotangentComplex_toKaehler : Function.Exact P.cotangentComplex P.toKaehler
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem eventuallyEq_one_of_dist_lt (hs : x ∈ (chartAt H c).source)
    (hd : dist (extChartAt I c x) (extChartAt I c c) < f.rIn) : f =ᶠ[𝓝 x] 1
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem one_trans : (1 : E ≃ₗᵢ[R] E).trans e = e
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem ContinuousLinearEquiv.uniqueDiffOn_image (e : E ≃L[𝕜] F) (h : UniqueDiffOn 𝕜 s) :
    UniqueDiffOn 𝕜 (e '' s)
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem cramer_zero [Nontrivial n] : cramer (0 : Matrix n n α) = 0
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem prime_X_sub_C (r : R) : Prime (X - C r)
-- Mathlib/Analysis/NormedSpace/ENorm.lean
@[simp]
theorem map_smul (c : 𝕜) (x : V) : e (c • x) = ‖c‖₊ * e x
-- Mathlib/Order/Bounds/Basic.lean
theorem bddBelow_Ioc : BddBelow (Ioc a b)
-- Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean
theorem toFun_unique' (g : L ≃+* L) (c : ZMod (Fintype.card (rootsOfUnity n L)))
    (hc : ∀ t ∈ rootsOfUnity n L, g t = t ^ c.val) : c = χ₀ n g
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem iff_comap_eq :
    MeasurableEmbedding f ↔
      Injective f ∧ MeasurableSpace.comap f ‹_› = ‹_› ∧ MeasurableSet (range f)
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivQuotSupₐ_symm_toRingEquiv :
    ((quotQuotEquivQuotSupₐ R I J).symm : _ ≃+* _ ⧸ J.map (Quotient.mkₐ R I)) =
      (quotQuotEquivQuotSup I J).symm
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem not_LindelofSpace_iff : ¬LindelofSpace X ↔ NonLindelofSpace X
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
    (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
/-- The `0`-cocycle associated to a morphism in `CochainComplex C ℤ`. -/
@[simps!]
def ofHom (φ : F ⟶ G) : Cocycle F G 0
-- Mathlib/Data/List/Perm.lean
theorem bind_append_perm (l : List α) (f g : α → List β) :
    l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGreatest.upperBounds_eq (h : IsGreatest s a) : upperBounds s = Ici a
-- Mathlib/Data/Nat/Choose/Sum.lean
theorem choose_middle_le_pow (n : ℕ) : choose (2 * n + 1) n ≤ 4 ^ n
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem coeff_order_ne_zero {x : HahnSeries Γ R} (hx : x ≠ 0) : x.coeff x.order ≠ 0
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_update_of_ne_one [DecidableEq α] (f : α → M) (x : α) {y : M} (hy : y ≠ 1) :
    mulSupport (update f x y) = insert x (mulSupport f)
-- Mathlib/RingTheory/Localization/Basic.lean
theorem IsLocalization.algebraMap_mk' (x : R) (y : M) :
    algebraMap Rₘ Sₘ (IsLocalization.mk' Rₘ x y) =
      IsLocalization.mk' Sₘ (algebraMap R S x)
        ⟨algebraMap R S y, Algebra.mem_algebraMapSubmonoid_of_mem y⟩
-- Mathlib/LinearAlgebra/Dual.lean
theorem LinearMap.dualMap_apply' (f : M₁ →ₗ[R] M₂) (g : Dual R M₂) : f.dualMap g = g.comp f