ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem coeFn_injective : Function.Injective ((↑) : ENorm 𝕜 V → V → ℝ≥0∞)
-- Mathlib/Algebra/Order/Monovary.lean
lemma AntivaryOn.div_right₀ (hg₁ : ∀ i ∈ s, 0 ≤ g₁ i) (hg₂ : ∀ i ∈ s, 0 < g₂ i)
    (h₁ : AntivaryOn f g₁ s) (h₂ : MonovaryOn f g₂ s) : AntivaryOn f (g₁ / g₂) s
-- Mathlib/RingTheory/WittVector/Verschiebung.lean
theorem verschiebungFun_coeff_zero (x : 𝕎 R) : (verschiebungFun x).coeff 0 = 0
-- Mathlib/LinearAlgebra/Span.lean
@[simp] lemma _root_.LinearMap.surjective_domRestrict_iff
    {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M} (hf : Surjective f) :
    Surjective (f.domRestrict S) ↔ S ⊔ LinearMap.ker f = ⊤
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
lemma pushoutCocone_inl_eq_inr_iff_of_iso {c c' : PushoutCocone f g} (e : c ≅ c')
    (x₁ : X₁) (x₂ : X₂) :
    c.inl x₁ = c.inr x₂ ↔ c'.inl x₁ = c'.inr x₂
-- Mathlib/Data/Finset/Basic.lean
@[aesop unsafe apply (rule_sets := [finsetNonempty])]
theorem Nonempty.inr {s t : Finset α} (h : t.Nonempty) : (s ∪ t).Nonempty
-- Mathlib/Data/Seq/Seq.lean
theorem map_pair {f : α → β} {a s} : map f (a, s) = (f a, Seq.map f s)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioc_mem_nhdsWithin_Iic (H : b ∈ Ioc a c) : Ioc a c ∈ 𝓝[≤] b
-- Mathlib/Data/Set/Basic.lean
theorem inter_nonempty_iff_exists_left : (s ∩ t).Nonempty ↔ ∃ x ∈ s, x ∈ t
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_iff_segment_subset : Convex 𝕜 s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → [x -[𝕜] y] ⊆ s
-- Mathlib/Data/Matroid/Closure.lean
@[simp] lemma closure_univ (M : Matroid α) : M.closure univ = M.E
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem add_apply (f g : NormedAddGroupHom V₁ V₂) (v : V₁) :
    (f + g) v = f v + g v
-- Mathlib/Algebra/AddTorsor.lean
/-- If subtracting two points from the same point produces equal
results, those points are equal. -/
theorem vsub_right_cancel {p₁ p₂ p : P} (h : p -ᵥ p₁ = p -ᵥ p₂) : p₁ = p₂
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem K'.elim_update_main {a b c d a'} : update (K'.elim a b c d) main a' = K'.elim a' b c d
-- Mathlib/Data/Finset/Card.lean
theorem card_le_four : card {a, b, c, d} ≤ 4
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxFilter.isExtr : IsMaxFilter f l a → IsExtrFilter f l a
-- Mathlib/NumberTheory/Divisors.lean
@[simp]
lemma nonempty_properDivisors : n.properDivisors.Nonempty ↔ 1 < n
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma hurwitzEvenFEPair_zero_symm :
    (hurwitzEvenFEPair 0).symm = hurwitzEvenFEPair 0
-- Mathlib/Order/ModularLattice.lean
/-- A generalization of the theorem that if `N` is a submodule of `M` and
  `N` and `M / N` are both Artinian, then `M` is Artinian. -/
theorem wellFounded_lt_exact_sequence {β γ : Type*} [PartialOrder β] [Preorder γ]
    (h₁ : WellFounded ((· < ·) : β → β → Prop)) (h₂ : WellFounded ((· < ·) : γ → γ → Prop)) (K : α)
    (f₁ : β → α) (f₂ : α → β) (g₁ : γ → α) (g₂ : α → γ) (gci : GaloisCoinsertion f₁ f₂)
    (gi : GaloisInsertion g₂ g₁) (hf : ∀ a, f₁ (f₂ a) = a ⊓ K) (hg : ∀ a, g₁ (g₂ a) = a ⊔ K) :
    WellFounded ((· < ·) : α → α → Prop)
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[simp]
theorem bot_sub : ⊥ - t = ⊥
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
protected theorem contDiffAt {x n} : ContDiffAt ℝ n smoothTransition x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem sum_pow_char {ι : Type*} (s : Finset ι) (f : ι → R) :
    (∑ i ∈ s, f i) ^ p = ∑ i ∈ s, f i ^ p
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
theorem equivalence₂CounitIso_eq :
    (equivalence₂ eB hF).counitIso = equivalence₂CounitIso eB hF
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem c_mem_support : c ∈ support f
-- Mathlib/Algebra/Category/Ring/Adjunctions.lean
@[simp]
theorem free_obj_coe {α : Type u} : (free.obj α : Type u) = MvPolynomial α ℤ
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem smul_def (xs : IntList) (i : Int) : i * xs = xs.map fun x => i * x
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
@[simp]
theorem thickening_cthickening (hε : 0 < ε) (hδ : 0 ≤ δ) (s : Set E) :
    thickening ε (cthickening δ s) = thickening (ε + δ) s
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem aemeasurable_biSup {ι} {μ : Measure δ} (s : Set ι) {f : ι → δ → α} (hs : s.Countable)
    (hf : ∀ i ∈ s, AEMeasurable (f i) μ) : AEMeasurable (fun b => ⨆ i ∈ s, f i b) μ
-- Mathlib/Order/Chain.lean
theorem chainClosure_empty : ChainClosure r ∅
-- Mathlib/Order/Hom/Basic.lean
protected theorem strictMono : StrictMono f
-- Mathlib/Order/Bounds/Basic.lean
/-- If `a` is the greatest element of `s` and `b` is the greatest element of `t`,
then `max a b` is the greatest element of `s ∪ t`. -/
theorem IsGreatest.union [LinearOrder γ] {a b : γ} {s t : Set γ} (ha : IsGreatest s a)
    (hb : IsGreatest t b) : IsGreatest (s ∪ t) (max a b)
-- Mathlib/FieldTheory/Minpoly/Field.lean
/-- A minimal polynomial is prime. -/
theorem prime (hx : IsIntegral A x) : Prime (minpoly A x)
-- Mathlib/Data/Fin/Tuple/BubbleSortInduction.lean
/-- *Bubble sort induction*: Prove that the sorted version of `f` has some property `P`
if `f` satisfies `P` and `P` is preserved when swapping two antitone values. -/
theorem bubble_sort_induction {n : ℕ} {α : Type*} [LinearOrder α] {f : Fin n → α}
    {P : (Fin n → α) → Prop} (hf : P f)
    (h : ∀ (g : Fin n → α) (i j : Fin n), i < j → g j < g i → P g → P (g ∘ Equiv.swap i j)) :
    P (f ∘ sort f)
-- Mathlib/GroupTheory/GroupAction/Quotient.lean
theorem ConjClasses.card_carrier {G : Type*} [Group G] [Fintype G] (g : G)
    [Fintype (ConjClasses.mk g).carrier] [Fintype <| MulAction.stabilizer (ConjAct G) g] :
    Fintype.card (ConjClasses.mk g).carrier =
      Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem map_congr {f g : α → β} (h : f =ᵐ[μ] g) : Measure.map f μ = Measure.map g μ
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_add_nat' (hx : 0 ≤ x) (h : y + n ≠ 0) : x ^ (y + n) = x ^ y * x ^ n
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- An isometry from an emetric space is an embedding -/
protected theorem embedding (hf : Isometry f) : Embedding f
-- Mathlib/Data/DFinsupp/Order.lean
@[simp, norm_cast] lemma coe_le_coe : ⇑f ≤ g ↔ f ≤ g
-- Mathlib/Data/Set/Card.lean
theorem ncard_congr {t : Set β} (f : ∀ a ∈ s, β) (h₁ : ∀ a ha, f a ha ∈ t)
    (h₂ : ∀ a b ha hb, f a ha = f b hb → a = b) (h₃ : ∀ b ∈ t, ∃ a ha, f a ha = b) :
    s.ncard = t.ncard
-- Mathlib/Algebra/Homology/HomologySequence.lean
@[reassoc (attr := simp)]
lemma opcyclesToCycles_iCycles : K.opcyclesToCycles i j ≫ K.iCycles j = K.fromOpcycles i j
-- Mathlib/Order/Sublattice.lean
lemma subtype_injective (L : Sublattice α) : Injective <| subtype L
-- Mathlib/Order/Bounds/Basic.lean
theorem isLUB_prod {s : Set (α × β)} (p : α × β) :
    IsLUB s p ↔ IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem inter_mem_iff {s t : Set α} : s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp]
theorem symm_piecewise (e e' : PartialHomeomorph X Y) {s : Set X} {t : Set Y}
    [∀ x, Decidable (x ∈ s)] [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t)
    (Hs : e.source ∩ frontier s = e'.source ∩ frontier s)
    (Heq : EqOn e e' (e.source ∩ frontier s)) :
    (e.piecewise e' s t H H' Hs Heq).symm =
      e.symm.piecewise e'.symm t s H.symm H'.symm
        (H.frontier.inter_eq_of_inter_eq_of_eqOn H'.frontier Hs Heq)
        (H.frontier.symm_eqOn_of_inter_eq_of_eqOn Hs Heq)
-- Mathlib/Order/Disjoint.lean
protected theorem Antitone {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') (hx : x ≤ x') : y' ≤ y
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_neg (x : ℝ≥0) (y : ℝ) : x ^ (-y) = (x ^ y)⁻¹
-- Mathlib/Order/Hom/Basic.lean
/-- Function application `fun f => f a` (for fixed `a`) is a monotone function from the
monotone function space `α →o β` to `β`. See also `Pi.evalOrderHom`.  -/
@[simps! (config := .asFn)]
def apply (x : α) : (α →o β) →o β
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_coe {F : Type*} [FunLike F α β] [RingHomClass F α β] (f : F) :
    ((f : α →+* β) : α → β) = f
-- Mathlib/Data/Set/Finite.lean
@[simp]
theorem finite_singleton (a : α) : ({a} : Set α).Finite
-- Mathlib/Topology/Algebra/Ring/Basic.lean
/-- If `R` is a ring which is a topological semiring, then it is automatically a topological
ring. This exists so that one can place a topological ring structure on `R` without explicitly
proving `continuous_neg`. -/
theorem TopologicalSemiring.toTopologicalRing [TopologicalSpace α] [NonAssocRing α]
    (_ : TopologicalSemiring α) : TopologicalRing α
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[local simp] protected theorem add_right_neg (a : Int) : a + -a = 0
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[norm_cast]
theorem coe_projIci (a x : α) : (projIci a x : α) = max a x
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem zero_testAgainstNN : (0 : FiniteMeasure Ω).testAgainstNN = 0
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
/--
A left adjoint functor `L : C ⥤ D` is *comonadic* if the comparison functor `Comonad.comparison L`
from `C` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class ComonadicLeftAdjoint (L : C ⥤ D) where
  /-- a choice of right adjoint for `L` -/
  R : D ⥤ C
  /-- `L` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Comonad.comparison adj).IsEquivalence
-- Mathlib/Data/Nat/Nth.lean
@[simp]
theorem nth_zero_of_zero (h : p 0) : nth p 0 = 0
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem bind_some (x : Option α) : x.bind some = x
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
/-- Construct a quadratic form on a product of two modules from the quadratic form on each module.
-/
@[simps!]
def prod (Q₁ : QuadraticMap R M₁ P) (Q₂ : QuadraticMap R M₂ P) : QuadraticMap R (M₁ × M₂) P
-- Mathlib/Analysis/BoxIntegral/Basic.lean
/-- Quite often it is more natural to prove an estimate of the form `a * ε`, not `ε` in the RHS of
`BoxIntegral.hasIntegral_iff`, so we provide this auxiliary lemma.  -/
theorem HasIntegral.of_mul (a : ℝ)
    (h : ∀ ε : ℝ, 0 < ε → ∃ r : ℝ≥0 → ℝⁿ → Ioi (0 : ℝ), (∀ c, l.RCond (r c)) ∧ ∀ c π,
      l.MemBaseSet I c (r c) π → IsPartition π → dist (integralSum f vol π) y ≤ a * ε) :
    HasIntegral I l f vol y
-- Mathlib/Data/Finset/Sups.lean
lemma union_mem_sups : s ∈ 𝒜 → t ∈ ℬ → s ∪ t ∈ 𝒜 ⊻ ℬ
-- Mathlib/GroupTheory/Complement.lean
theorem IsComplement.card_mul (h : IsComplement S T) :
    Nat.card S * Nat.card T = Nat.card G
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mk_initialSeg (o : Ordinal.{u}) :
    #{ o' : Ordinal | o' < o } = Cardinal.lift.{u + 1} o.card
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem restrictScalars_top : restrictScalars S (⊤ : Submodule R M) = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_lt_sub_left {a b : Int} (h : a < b) (c : Int) : c - b < c - a
-- Mathlib/Topology/Sets/Compacts.lean
/-- The type of compact open sets of a topological space. This is useful in non Hausdorff contexts,
in particular spectral spaces. -/
structure CompactOpens (α : Type*) [TopologicalSpace α] extends Compacts α where
  isOpen' : IsOpen carrier
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem zero_den : (0 : Rat).den = 1
-- Mathlib/NumberTheory/Dioph.lean
/-- A version of **Matiyasevic's theorem** -/
theorem pow_dioph : DiophFn fun v => f v ^ g v
-- Mathlib/Topology/Hom/Open.lean
@[simp]
theorem coe_comp (f : β →CO γ) (g : α →CO β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/Algebra/DirectSum/Ring.lean
theorem ofList_dProd {α} (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
    of A _ (l.dProd fι fA) = (l.map fun a => of A (fι a) (fA a)).prod
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp]
theorem forget₂_bialgebra_map (X Y : HopfAlgebraCat R) (f : X ⟶ Y) :
    (forget₂ (HopfAlgebraCat R) (BialgebraCat R)).map f = BialgebraCat.ofHom f.toBialgHom
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem seq_destruct_nil : Seq.destruct (nil : WSeq α) = none
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem aux_cobounded_eq : cobounded (PiLp p α) = @cobounded _ Pi.instBornology
-- Mathlib/Topology/Constructions.lean
@[continuity, fun_prop]
theorem Continuous.sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (hf : ∀ i, Continuous (f₂ i)) :
    Continuous (Sigma.map f₁ f₂)
-- Mathlib/LinearAlgebra/Dual.lean
theorem map_dualCoannihilator (W : Subspace K (Dual K V)) [FiniteDimensional K V] :
    W.dualCoannihilator.map (Dual.eval K V) = W.dualAnnihilator
-- Mathlib/GroupTheory/Perm/Fin.lean
theorem cycleRange_of_lt {n : ℕ} {i j : Fin n.succ} (h : j < i) : cycleRange i j = j + 1
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_or_gt_of_ne {a b : Int} : a ≠ b →  a < b ∨ b < a
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem inl_mul_inr [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M] (r : R) (m : M) :
    (inl r * inr m : tsze R M) = inr (r • m)
-- Mathlib/Algebra/Homology/Homotopy.lean
lemma prevD_eq_zero (f : ∀ i j, C.X i ⟶ D.X j) (i : ι) (hi : ¬ c.Rel (c.prev i) i) :
    prevD i f = 0
-- Mathlib/LinearAlgebra/Coevaluation.lean
theorem coevaluation_apply_one :
    (coevaluation K V) (1 : K) =
      let bV := Basis.ofVectorSpace K V
      ∑ i : Basis.ofVectorSpaceIndex K V, bV i ⊗ₜ[K] bV.coord i
-- Mathlib/Algebra/Order/Group/Abs.lean
/-- `|a - b| ≤ n` if `0 ≤ a ≤ n` and `0 ≤ b ≤ n`. -/
theorem abs_sub_le_of_nonneg_of_le {a b n : α} (a_nonneg : 0 ≤ a) (a_le_n : a ≤ n)
    (b_nonneg : 0 ≤ b) (b_le_n : b ≤ n) : |a - b| ≤ n
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
theorem foldr'Aux_foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
    (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (v : M) (x_fx) :
    foldr'Aux Q f v (foldr'Aux Q f v x_fx) = Q v • x_fx
-- Mathlib/Order/Filter/Basic.lean
protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
    map f (comap f G ⊓ F) = G ⊓ map f F
-- Mathlib/RingTheory/Ideal/Maps.lean
/-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f.symm (map f I) = I`. -/
@[simp]
theorem map_of_equiv (I : Ideal R) (f : R ≃+* S) :
    (I.map (f : R →+* S)).map (f.symm : S →+* R) = I
-- Mathlib/Data/Set/NAry.lean
theorem Subsingleton.image2 (hs : s.Subsingleton) (ht : t.Subsingleton) (f : α → β → γ) :
    (image2 f s t).Subsingleton
-- Mathlib/Topology/Sets/Opens.lean
protected theorem mem (U : OpenNhdsOf x) : x ∈ U
-- Mathlib/Order/LiminfLimsup.lean
theorem bliminf_congr {f : Filter β} {u v : β → α} {p : β → Prop} (h : ∀ᶠ a in f, p a → u a = v a) :
    bliminf u f p = bliminf v f p
-- Mathlib/Order/UpperLower/Basic.lean
theorem isUpperSet_iff_forall_lt : IsUpperSet s ↔ ∀ ⦃a b : α⦄, a < b → a ∈ s → b ∈ s
-- Mathlib/Analysis/Convex/Deriv.lean
lemma deriv_lt_slope (hfc : StrictConvexOn ℝ S f) (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y)
    (hfd : DifferentiableAt ℝ f x) :
    deriv f x < slope f x y
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem inv_inv [IsIso f] : inv (inv f) = f
-- Mathlib/RingTheory/Ideal/MinimalPrime.lean
theorem nilpotent_iff_mem_maximal_of_minimal {x : _} :
    IsNilpotent x ↔ x ∈ LocalRing.maximalIdeal (Localization I.primeCompl)
-- Mathlib/Order/Category/NonemptyFinLinOrd.lean
lemma forget_map_apply {A B : NonemptyFinLinOrd.{u}} (f : A ⟶ B) (a : A) :
    (forget NonemptyFinLinOrd).map f a = (f : OrderHom A B).toFun a
-- Mathlib/Algebra/Order/UpperLower.lean
@[to_additive (attr := simp,norm_cast)]
theorem coe_div (s t : UpperSet α) : (↑(s / t) : Set α) = s / t
-- Mathlib/Order/LiminfLimsup.lean
/-- A bounded below function `u` is in particular eventually bounded below. -/
lemma _root_.BddBelow.isBoundedUnder [Preorder α] {f : Filter β} {u : β → α} :
    BddBelow (Set.range u) → f.IsBoundedUnder (· ≥ ·) u
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem isAdjoinRoot_map_eq_mk : (AdjoinRoot.isAdjoinRoot f).map = AdjoinRoot.mk f
-- Mathlib/MeasureTheory/Function/Jacobian.lean
/-- Change of variable formula for differentiable functions, set version: if a function `f` is
injective and differentiable on a measurable set `s`, then the pushforward of the measure with
density `|(f' x).det|` on `s` is the Lebesgue measure on the image set. This version requires
that `f` is measurable, as otherwise `Measure.map f` is zero per our definitions.
For a version without measurability assumption but dealing with the restricted
function `s.restrict f`, see `restrict_map_withDensity_abs_det_fderiv_eq_addHaar`.
-/
theorem map_withDensity_abs_det_fderiv_eq_addHaar (hs : MeasurableSet s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hf : InjOn f s) (h'f : Measurable f) :
    Measure.map f ((μ.restrict s).withDensity fun x => ENNReal.ofReal |(f' x).det|) =
      μ.restrict (f '' s)
-- Mathlib/Topology/Constructions.lean
theorem nhds_swap (x : X) (y : Y) : 𝓝 (x, y) = (𝓝 (y, x)).map Prod.swap
-- Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
@[simp] lemma orthogonal_bot : B.orthogonal ⊥ = ⊤
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.add_const [AddCommSemigroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
    Antiperiodic (fun x => f (x + a)) c
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- A functor `F : C ⥤ D` is initial if for every `d : D`, the comma category of morphisms
`F.obj c ⟶ d` is connected.
-/
class Initial (F : C ⥤ D) : Prop where
  out (d : D) : IsConnected (CostructuredArrow F d)
-- Mathlib/Data/Analysis/Filter.lean
/-- A realizer for filter `f` is a cfilter which generates `f`. -/
structure Filter.Realizer (f : Filter α) where
  σ : Type*
  F : CFilter (Set α) σ
  eq : F.toFilter = f
-- Mathlib/Data/Set/Basic.lean
theorem insert_diff_singleton_comm (hab : a ≠ b) (s : Set α) :
    insert a (s \ {b}) = insert a s \ {b}
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
@[simp]
theorem gcdA_zero_left {s : R} : gcdA 0 s = 0
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_pair (x y : ZFSet.{u}) : (pair x y).toSet = {{x}, {x, y}}
-- Mathlib/Algebra/AddTorsor.lean
/-- If subtracting two points produces 0, they are equal. -/
theorem eq_of_vsub_eq_zero {p₁ p₂ : P} (h : p₁ -ᵥ p₂ = (0 : G)) : p₁ = p₂
-- Mathlib/Analysis/Convolution.lean
theorem _root_.BddAbove.continuous_convolution_left_of_integrable
    [FirstCountableTopology G] [SecondCountableTopologyEither G E]
    (hbf : BddAbove (range fun x => ‖f x‖)) (hf : Continuous f) (hg : Integrable g μ) :
    Continuous (f ⋆[L, μ] g)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- An `AddSubgroup` is characteristic if it is fixed by all automorphisms.
  Several equivalent conditions are provided by lemmas of the form `Characteristic.iff...` -/
structure Characteristic : Prop where
  /-- `H` is fixed by all automorphisms -/
  fixed : ∀ ϕ : A ≃+ A, H.comap ϕ.toAddMonoidHom = H
-- Mathlib/Data/Finset/Lattice.lean
protected theorem sup_eq_top_iff {α : Type*} [LinearOrder α] [BoundedOrder α] [Nontrivial α]
    {s : Finset ι} {f : ι → α} : s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem OrderBot.lowerBounds_univ [PartialOrder γ] [OrderBot γ] :
    lowerBounds (univ : Set γ) = {⊥}
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
lemma HasLineDerivWithinAt.mono (hf : HasLineDerivWithinAt 𝕜 f f' s x v) (hst : t ⊆ s) :
    HasLineDerivWithinAt 𝕜 f f' t x v
-- Mathlib/Probability/Kernel/Basic.lean
@[simp]
theorem setLIntegral_deterministic {f : β → ℝ≥0∞} {g : α → β} {a : α} (hg : Measurable g)
    [MeasurableSingletonClass β] (s : Set β) [Decidable (g a ∈ s)] :
    ∫⁻ x in s, f x ∂deterministic g hg a = if g a ∈ s then f (g a) else 0
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem comap_exp_nhdsWithin_zero : comap exp (𝓝[≠] 0) = comap re atBot
-- Mathlib/Topology/Separation.lean
theorem Filter.Tendsto.limUnder_eq {x : X} {f : Filter Y} [NeBot f] {g : Y → X}
    (h : Tendsto g f (𝓝 x)) : @limUnder _ _ _ ⟨x⟩ f g = x
-- Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
/-- The sheaf condition in terms of an equalizer diagram is equivalent
to the default sheaf condition.
-/
theorem isSheaf_iff_isSheafEqualizerProducts (F : Presheaf C X) :
    F.IsSheaf ↔ F.IsSheafEqualizerProducts
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[fun_prop]
theorem ContinuousAt.div₀ (hf : ContinuousAt f a) (hg : ContinuousAt g a) (h₀ : g a ≠ 0) :
    ContinuousAt (fun x => f x / g x) a
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
/-- Definition of `IsBigO` in terms of filters. -/
theorem isBigO_iff : f =O[l] g ↔ ∃ c : ℝ, ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/Init/Logic.lean
theorem right_comm : Commutative f → Associative f → RightCommutative f
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem comap_comap (s : Subring T) (g : S →+* T) (f : R →+* S) :
    (s.comap g).comap f = s.comap (g.comp f)
-- Mathlib/Data/NNRat/Defs.lean
@[simp] lemma mul_den_eq_num (q : ℚ≥0) : q * q.den = q.num
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrict_sum (μ : ι → Measure α) {s : Set α} (hs : MeasurableSet s) :
    (sum μ).restrict s = sum fun i => (μ i).restrict s
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitesimal_pos_iff_infinitePos_inv {x : ℝ*} :
    InfinitePos x⁻¹ ↔ Infinitesimal x ∧ 0 < x
-- Mathlib/Order/Basic.lean
@[simp]
theorem swap_lt_swap : x.swap < y.swap ↔ x < y
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem weightedSMul_apply {m : MeasurableSpace α} (μ : Measure α) (s : Set α) (x : F) :
    weightedSMul μ s x = (μ s).toReal • x
-- Mathlib/NumberTheory/ArithmeticFunction.lean
/-- This result only holds for `DivisionSemiring`s instead of `GroupWithZero`s because zeta takes
values in ℕ, and hence the coercion requires an `AddMonoidWithOne`. TODO: Generalise zeta -/
@[simp]
theorem pdiv_zeta [DivisionSemiring R] (f : ArithmeticFunction R) :
    pdiv f zeta = f
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem map_rightInverse [Nonempty α] [Nonempty γ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α}
    {g₂ : δ → γ} : RightInverse (map f₁ g₁) (map f₂ g₂) ↔ RightInverse f₁ f₂ ∧ RightInverse g₁ g₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma polynomialX_eq : W'.polynomialX =
    C W'.a₁ * X 1 * X 2 - (C 3 * X 0 ^ 2 + C (2 * W'.a₂) * X 0 * X 2 ^ 2 + C W'.a₄ * X 2 ^ 4)
-- Mathlib/Data/Finset/NAry.lean
theorem card_image₂_singleton_left (hf : Injective (f a)) : (image₂ f {a} t).card = t.card
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma setLIntegral_toKernel_univ [IsFiniteKernel κ] (hf : IsCondKernelCDF f κ ν)
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ b in s, hf.toKernel f (a, b) univ ∂(ν a) = κ a (s ×ˢ univ)
-- Mathlib/Logic/Basic.lean
@[simp]
lemma exists_apply_eq_apply3' {α β γ δ} {f : α → β → γ → δ} {a : α} {b : β} {c : γ} :
    ∃ x y z, f a b c = f x y z
-- Mathlib/Logic/Relation.lean
theorem cases_head (h : ReflTransGen r a b) : a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc (attr := simp)]
theorem prod.map_snd {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : prod.map f g ≫ prod.snd = prod.snd ≫ g
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem coe_id_of {X : Type u} [CommRing X] :
    @DFunLike.coe no_index (CommRingCat.of X ⟶ CommRingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X)
-- Mathlib/Algebra/NeZero.lean
theorem NeZero.ne (n : R) [h : NeZero n] : n ≠ 0
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem zero_im : (0 : ℍ[R,c₁,c₂]).im = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
/-- The derivative of `tan x - x` is `1/(cos x)^2 - 1` away from the zeroes of cos. -/
theorem deriv_tan_sub_id (x : ℝ) (h : cos x ≠ 0) :
    deriv (fun y : ℝ => tan y - y) x = 1 / cos x ^ 2 - 1
-- Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean
theorem HasAffineProperty.diagonal_iff
    (P) {Q} [HasAffineProperty P Q] {X Y} {f : X ⟶ Y} [IsAffine Y] :
    Q.diagonal f ↔ P.diagonal f
-- Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean
/-- The antidiagonal of `n` does not contain duplicate entries. -/
theorem nodup_antidiagonalTuple (k n : ℕ) : List.Nodup (antidiagonalTuple k n)