ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem normalize_eq_one {a : G₀} (h0 : a ≠ 0) : normalize a = 1
-- Mathlib/Topology/PartialHomeomorph.lean
theorem inter_eq_of_inter_eq_of_eqOn {e' : PartialHomeomorph X Y} (h : e.IsImage s t)
    (h' : e'.IsImage s t) (hs : e.source ∩ s = e'.source ∩ s) (Heq : EqOn e e' (e.source ∩ s)) :
    e.target ∩ t = e'.target ∩ t
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem rel_of_chain_cons {a b : α} {l : List α} (p : Chain R a (b :: l)) : R a b
-- Mathlib/Analysis/Quaternion.lean
theorem inner_def (a b : ℍ) : ⟪a, b⟫ = (a * star b).re
-- Mathlib/Data/List/Infix.lean
theorem infix_rfl : l <:+: l
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem isAdjoinRootMonic_root_eq_root (hf : Monic f) :
    (AdjoinRoot.isAdjoinRootMonic f hf).root = AdjoinRoot.root f
-- Mathlib/Analysis/NormedSpace/IndicatorFunction.lean
theorem norm_indicator_eq_indicator_norm : ‖indicator s f a‖ = indicator s (fun a => ‖f a‖) a
-- Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean
theorem comp_PInfty_eq_zero_iff {Z : C} {n : ℕ} (f : Z ⟶ X _[n]) :
    f ≫ PInfty.f n = 0 ↔ f ≫ s.πSummand (IndexSet.id (op [n])) = 0
-- Mathlib/RingTheory/HahnSeries/Addition.lean
/--
`addOppositeEquiv` is an additive monoid isomorphism between
Hahn series over `Γ` with coefficients in the opposite additive monoid `Rᵃᵒᵖ`
and the additive opposite of Hahn series over `Γ` with coefficients `R`.
-/
@[simps (config := .lemmasOnly)]
def addOppositeEquiv : HahnSeries Γ (Rᵃᵒᵖ) ≃+ (HahnSeries Γ R)ᵃᵒᵖ
-- Mathlib/Topology/Algebra/GroupCompletion.lean
theorem continuous_toCompl : Continuous (toCompl : α → Completion α)
-- Mathlib/Data/Fin/Tuple/Basic.lean
lemma insertNth_self_removeNth (p : Fin (n + 1)) (f : ∀ j, α j) :
    insertNth p (f p) (removeNth p f) = f
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm of a natural `m` is one iff `p` doesn't divide `m`. -/
theorem nat_eq_one_iff (m : ℕ) : padicNorm p m = 1 ↔ ¬p ∣ m
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem fromLocalizedModule.inj : Function.Injective <| fromLocalizedModule S f
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
/-- Image of a bounded set in a normed space under scalar multiplication by a constant is
bounded. See also `Bornology.IsBounded.smul` for a similar lemma about an isometric action. -/
theorem Bornology.IsBounded.smul₀ {s : Set E} (hs : IsBounded s) (c : 𝕜) : IsBounded (c • s)
-- Mathlib/Data/List/Indexes.lean
@[simp]
theorem mapIdx_cons (l : List α) (f : ℕ → α → β) (a : α) :
    mapIdx f (a :: l) = f 0 a :: mapIdx (fun i ↦ f (i + 1)) l
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem lt_le_asymm {x y : Int} (h₁ : y < x) (h₂ : x ≤ y) : False
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
@[simp]
theorem zeroIsoIsInitial_inv {X : C} (t : IsInitial X) : (zeroIsoIsInitial t).inv = 0
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Expressing uniform convergence using `dist` -/
theorem tendstoUniformlyOnFilter_iff {F : ι → β → α} {f : β → α} {p : Filter ι} {p' : Filter β} :
    TendstoUniformlyOnFilter F f p p' ↔
      ∀ ε > 0, ∀ᶠ n : ι × β in p ×ˢ p', dist (f n.snd) (F n.fst n.snd) < ε
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_int_div_iff : Irrational (m / x) ↔ m ≠ 0 ∧ Irrational x
-- Mathlib/Data/Real/Basic.lean
/-- `Real.equivCauchy` as a ring equivalence. -/
@[simps]
def ringEquivCauchy : ℝ ≃+* CauSeq.Completion.Cauchy (abs : ℚ → ℚ)
-- Mathlib/Data/Finsupp/Multiset.lean
theorem Multiset.toFinsupp_strictMono [DecidableEq ι] : StrictMono (@Multiset.toFinsupp ι _)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem measurableSet_le {m : MeasurableSpace α} [TopologicalSpace β] [Preorder β]
    [OrderClosedTopology β] [PseudoMetrizableSpace β] {f g : α → β} (hf : StronglyMeasurable f)
    (hg : StronglyMeasurable g) : MeasurableSet { a | f a ≤ g a }
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_eq_sInf {m : MeasurableSpace α} (μ : Measure α) (f : α → β) :
    essSup f μ = sInf { a | μ { x | a < f x } = 0 }
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A non-unital normed ring is a not-necessarily-unital ring
endowed with a norm which satisfies the inequality `‖x y‖ ≤ ‖x‖ ‖y‖`. -/
class NonUnitalNormedRing (α : Type*) extends Norm α, NonUnitalRing α, MetricSpace α where
  /-- The distance is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = norm (x - y)
  /-- The norm is submultiplicative. -/
  norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem zeroLocus_span (S : Set (MvPolynomial σ k)) :
    zeroLocus (Ideal.span S) = { x | ∀ p ∈ S, eval x p = 0 }
-- Mathlib/Algebra/Polynomial/Div.lean
theorem degree_divByMonic_le (p q : R[X]) : degree (p /ₘ q) ≤ degree p
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp, norm_cast]
theorem coe_inf (S T : Subalgebra R A) : (↑(S ⊓ T) : Set A) = (S ∩ T : Set A)
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem toMonoidHom_refl : (RingEquiv.refl R).toMonoidHom = MonoidHom.id R
-- Mathlib/Data/Nat/Nth.lean
theorem range_nth_of_infinite (hf : (setOf p).Infinite) : Set.range (nth p) = setOf p
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
@[simp]
theorem invFun_eq_symm : e.invFun = e.symm
-- Mathlib/Algebra/MvPolynomial/PDeriv.lean
@[simp]
theorem pderiv_X [DecidableEq σ] (i j : σ) :
    pderiv i (X j : MvPolynomial σ R) = Pi.single (f := fun j => _) i 1 j
-- Mathlib/Algebra/Lie/Submodule.lean
/-- An equivalence of Lie modules yields an order-preserving equivalence of their lattices of Lie
Submodules. -/
@[simps] def orderIsoMapComap (e : M ≃ₗ⁅R,L⁆ M') :
    LieSubmodule R L M ≃o LieSubmodule R L M'
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem isWF_bUnion [Preorder α] (s : Finset ι) {f : ι → Set α} :
    (⋃ i ∈ s, f i).IsWF ↔ ∀ i ∈ s, (f i).IsWF
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem lipschitzOnWith (h : LipschitzWith K f) (s : Set α) : LipschitzOnWith K f s
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem lift_rank_map_le (f : M →ₗ[R] M') (p : Submodule R M) :
    Cardinal.lift.{v} (Module.rank R (p.map f)) ≤ Cardinal.lift.{v'} (Module.rank R p)
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem one_of_dist_le (hs : x ∈ (chartAt H c).source)
    (hd : dist (extChartAt I c x) (extChartAt I c c) ≤ f.rIn) : f x = 1
-- Mathlib/Combinatorics/Hindman.lean
@[to_additive]
theorem Ultrafilter.continuous_mul_left {M} [Semigroup M] (V : Ultrafilter M) :
    Continuous (· * V)
-- Mathlib/Data/List/ToFinsupp.lean
@[deprecated "This lemma is unused, and can be proved by `simp`." (since := "2024-06-12")]
theorem toFinsupp_cons_apply_zero (x : M) (xs : List M)
    [DecidablePred (getD (x::xs) · 0 ≠ 0)] : (x::xs).toFinsupp 0 = x
-- Mathlib/Analysis/Complex/RealDeriv.lean
/-- A real differentiable function of the complex plane into some complex normed space `E` is
    conformal at a point `z` if it is holomorphic at that point with a nonvanishing differential.
    This is a version of the Cauchy-Riemann equations. -/
theorem DifferentiableAt.conformalAt (h : DifferentiableAt ℂ f z) (hf' : deriv f z ≠ 0) :
    ConformalAt f z
-- Mathlib/Topology/UniformSpace/Separation.lean
protected theorem Inseparable.nhds_le_uniformity {x y : α} (h : Inseparable x y) :
    𝓝 (x, y) ≤ 𝓤 α
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem mem_div_iff_of_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) {x} :
    x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I
-- Mathlib/Logic/Equiv/PartialEquiv.lean
/-- Composition of the inverse of a partial equivalence and this partial equivalence is equivalent
to the restriction of the identity to the target. -/
theorem symm_trans_self : e.symm.trans e ≈ ofSet e.target
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem dslope_eventuallyEq_slope_of_ne (f : 𝕜 → E) (h : b ≠ a) : dslope f a =ᶠ[𝓝 b] slope f a
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem comp_continuous_iff' {γ} [TopologicalSpace γ] (h : α ≃ᵢ β) {f : β → γ} :
    Continuous (f ∘ h) ↔ Continuous f
-- Mathlib/CategoryTheory/Square.lean
/-- The bottom-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₃ : Square C ⥤ C
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.prod‖₊ ≤ (m.map fun x => ‖x‖₊).sum
-- Mathlib/Analysis/Convex/Cone/Proper.lean
@[simp]
theorem map_id (K : ProperCone ℝ E) : K.map (ContinuousLinearMap.id ℝ E) = K
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma lTensor.inverse_of_rightInverse_comp_lTensor
    {h : P → N} (hgh : Function.RightInverse h g) :
    (lTensor.inverse_of_rightInverse Q hfg hgh).comp (lTensor Q g) =
      Submodule.mkQ (p := LinearMap.range (lTensor Q f))
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem coe_spanSingleton (x : P) : (spanSingleton S x : Submodule R P) = span R {x}
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma ofNat_ne_top (n : ℕ) [n.AtLeastTwo] : no_index (OfNat.ofNat n : WithTop α) ≠ ⊤
-- Mathlib/Algebra/Module/Submodule/EqLocus.lean
theorem eqLocus_eq_ker_sub (f g : M →ₛₗ[τ₁₂] M₂) : eqLocus f g = ker (f - g)
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
/-- This typeclass expresses that the signs given by `[TotalComplexShapeSymmetry c₁ c₂ c₁₂]`
and by `[TotalComplexShapeSymmetry c₂ c₁ c₁₂]` are compatible. -/
class TotalComplexShapeSymmetrySymmetry [TotalComplexShape c₁ c₂ c₁₂]
    [TotalComplexShape c₂ c₁ c₁₂] [TotalComplexShapeSymmetry c₁ c₂ c₁₂]
    [TotalComplexShapeSymmetry c₂ c₁ c₁₂] : Prop where
  σ_symm i₁ i₂ : ComplexShape.σ c₂ c₁ c₁₂ i₂ i₁ = ComplexShape.σ c₁ c₂ c₁₂ i₁ i₂
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem map_le {S : Subalgebra R A} {f : A →ₐ[R] B} {U : Subalgebra R B} :
    map f S ≤ U ↔ S ≤ comap f U
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.congr {f f₁ : α → β} {s : Set α} {x : α} (h : ContinuousWithinAt f s x)
    (h₁ : ∀ y ∈ s, f₁ y = f y) (hx : f₁ x = f x) : ContinuousWithinAt f₁ s x
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes right covariance.
The lemma assuming left covariance is `Left.one_lt_mul_of_le_of_lt`. -/
@[to_additive Right.add_pos_of_nonneg_of_pos
"Assumes right covariance.
The lemma assuming left covariance is `Left.add_pos_of_nonneg_of_pos`."]
theorem Right.one_lt_mul_of_le_of_lt [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α}
    (ha : 1 ≤ a) (hb : 1 < b) :
    1 < a * b
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem mk_coe (e : A ≃⋆ₐ[R] B) (e' h₁ h₂ h₃ h₄ h₅ h₆) :
    (⟨⟨⟨e, e', h₁, h₂⟩, h₃, h₄⟩, h₅, h₆⟩ : A ≃⋆ₐ[R] B) = e
-- Mathlib/Data/Nat/Defs.lean
lemma mul_lt_mul_pow_succ (ha : 0 < a) (hb : 1 < b) : n * b < a * b ^ (n + 1)
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
protected theorem lt_of_not_le {i j : Fin n} (h : ¬ i ≤ j) : j < i
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem subset_closedBall_norm [NormOneClass A] (a : A) : σ a ⊆ Metric.closedBall (0 : 𝕜) ‖a‖
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem C_mul : C (a * b) = C a * C b
-- Mathlib/Topology/List.lean
theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*> 𝓝 l
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem id_apply (a : α) : LatticeHom.id α a = a
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem map_surjective_of_surjective : Function.Surjective (map f)
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma ratCast_re (q : ℚ) : (q : ℂ).re = q
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
lemma σ_ε₂ (i₁ : I₁) {i₂ i₂' : I₂} (h₂ : c₂.Rel i₂ i₂') :
    σ c₁ c₂ c₁₂ i₁ i₂ * ε₂ c₁ c₂ c₁₂ ⟨i₁, i₂⟩ = ε₁ c₂ c₁ c₁₂ ⟨i₂, i₁⟩ * σ c₁ c₂ c₁₂ i₁ i₂'
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem map_piecewise_smul [DecidableEq ι] (c : ι → R) (m : ι → M) (s : Finset ι) :
    f (s.piecewise (fun i => c i • m i) m) = (∏ i ∈ s, c i) • f m
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_subset_Ici_self : Icc a b ⊆ Ici a
-- Mathlib/Dynamics/Minimal.lean
@[to_additive]
theorem denseRange_smul [IsMinimal M α] (x : α) : DenseRange fun c : M ↦ c • x
-- Mathlib/Order/MinMax.lean
lemma min_max_distrib_right (a b c : α) : min (max a b) c = max (min a c) (min b c)
-- Mathlib/RingTheory/Localization/Basic.lean
/-- If the square below commutes, the bottom map is uniquely specified:
```
R  →  S
↓     ↓
Rₘ → Sₘ
```
-/
theorem IsLocalization.algebraMap_apply_eq_map_map_submonoid (x) :
    algebraMap Rₘ Sₘ x =
      map Sₘ (algebraMap R S)
        (show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) x
-- Mathlib/Algebra/Field/Subfield.lean
/-- If two ring homomorphisms are equal on a set, then they are equal on its subfield closure. -/
theorem eqOn_field_closure {f g : K →+* L} {s : Set K} (h : Set.EqOn f g s) :
    Set.EqOn f g (closure s)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.dual : ∀ {t : Ordnode α} {o₁ o₂}, Valid' o₁ t o₂ → @Valid' αᵒᵈ _ o₂ (dual t) o₁
-- .lake/packages/batteries/Batteries/Data/Rat/Basic.lean
theorem sub.aux (a b : Rat) {g ad bd} (hg : g = a.den.gcd b.den)
    (had : ad = a.den / g) (hbd : bd = b.den / g) :
    let den := ad * b.den; let num := a.num * bd - b.num * ad
    num.natAbs.gcd g = num.natAbs.gcd den
-- Mathlib/Logic/Function/FromTypes.lean
theorem fromTypes_nil (τ : Type u) : FromTypes ![] τ = τ
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_succ_right (n : ℕ) :
    ascPochhammer S (n + 1) = ascPochhammer S n * (X + (n : S[X]))
-- Mathlib/Topology/Instances/EReal.lean
theorem continuousAt_add_bot_bot : ContinuousAt (fun p : EReal × EReal => p.1 + p.2) (⊥, ⊥)
-- Mathlib/Order/CompleteSublattice.lean
@[simp, norm_cast] lemma coe_copy (s : Set α) (hs) : L.copy s hs = s
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem diam_range (hf : Isometry f) : Metric.diam (range f) = Metric.diam (univ : Set α)
-- Mathlib/Algebra/Order/AddGroupWithTop.lean
/-- A linearly ordered commutative monoid with an additively absorbing `⊤` element.
  Instances should include number systems with an infinite element adjoined. -/
class LinearOrderedAddCommMonoidWithTop (α : Type*) extends LinearOrderedAddCommMonoid α,
    OrderTop α where
  /-- In a `LinearOrderedAddCommMonoidWithTop`, the `⊤` element is invariant under addition. -/
  protected top_add' : ∀ x : α, ⊤ + x = ⊤
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
@[deprecated measure_pos_of_superset (since := "2024-05-14")]
theorem pos_of_subset_ne_zero (m : OuterMeasure α) {a b : Set α} (hs : a ⊆ b) (hnz : m a ≠ 0) :
    0 < m b
-- Mathlib/Algebra/Order/Sub/Canonical.lean
@[simp] theorem tsub_lt_self_iff : a - b < a ↔ 0 < a ∧ 0 < b
-- Mathlib/Algebra/Order/Sub/Canonical.lean
/-- See `lt_tsub_iff_right` for a stronger statement in a linear order. -/
theorem lt_tsub_iff_right_of_le (h : c ≤ b) : a < b - c ↔ a + c < b
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive Left.nsmul_neg_iff]
theorem Left.pow_lt_one_iff' [CovariantClass M M (· * ·) (· < ·)] {n : ℕ} {x : M} (hn : 0 < n) :
    x ^ n < 1 ↔ x < 1
-- Mathlib/Algebra/GCDMonoid/IntegrallyClosed.lean
theorem IsLocalization.surj_of_gcd_domain [GCDMonoid R] (M : Submonoid R) [IsLocalization M A]
    (z : A) : ∃ a b : R, IsUnit (gcd a b) ∧ z * algebraMap R A b = algebraMap R A a
-- Mathlib/Data/Set/Subsingleton.lean
@[simp]
theorem not_nontrivial_empty : ¬(∅ : Set α).Nontrivial
-- Mathlib/CategoryTheory/Comma/Over.lean
/-- To give an object in the over category, it suffices to give a morphism with codomain `X`. -/
@[simps! left hom]
def mk {X Y : T} (f : Y ⟶ X) : Over X
-- Mathlib/Topology/Category/TopCat/Basic.lean
@[simp]
lemma inv_hom_id_apply {X Y : TopCat} (f : X ≅ Y) (y : Y) : f.hom (f.inv y) = y
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem IciExtend_of_le (f : Ici a → β) (hx : x ≤ a) : IciExtend f x = f ⟨a, le_rfl⟩
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_mul_left_Icc' {a : α} (h : 0 < a) (b c : α) :
    (a * ·) '' Icc b c = Icc (a * b) (a * c)
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma compls_sups (s t : Finset α) : (s ⊻ t)ᶜˢ = sᶜˢ ⊼ tᶜˢ
-- Mathlib/Data/Stream/Init.lean
theorem exists_of_mem_map {f} {b : β} {s : Stream' α} : b ∈ map f s → ∃ a, a ∈ s ∧ f a = b
-- Mathlib/Probability/IdentDistrib.lean
/-- This lemma is superseded by `Memℒp.uniformIntegrable_of_identDistrib` which only requires
`AEStronglyMeasurable`. -/
theorem Memℒp.uniformIntegrable_of_identDistrib_aux {ι : Type*} {f : ι → α → E} {j : ι} {p : ℝ≥0∞}
    (hp : 1 ≤ p) (hp' : p ≠ ∞) (hℒp : Memℒp (f j) p μ) (hfmeas : ∀ i, StronglyMeasurable (f i))
    (hf : ∀ i, IdentDistrib (f i) (f j) μ μ) : UniformIntegrable f p μ
-- Mathlib/Data/Fintype/BigOperators.lean
@[to_additive]
theorem prod_eq_single {f : α → M} (a : α) (h : ∀ x ≠ a, f x = 1) : ∏ x, f x = f a
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- The composition of homotopy equivalences. -/
@[simps]
def trans (e : HomotopyEquiv S₁ S₂) (e' : HomotopyEquiv S₂ S₃) :
    HomotopyEquiv S₁ S₃
-- Mathlib/Data/Complex/Basic.lean
theorem ofReal_def (r : ℝ) : (r : ℂ) = ⟨r, 0⟩
-- Mathlib/Topology/Category/Stonean/Limits.lean
@[reassoc (attr := simp)]
lemma pullback.lift_snd {X Y Z W : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding i)
    (a : W ⟶ X) (b : W ⟶ Y) (w : a ≫ f = b ≫ i) :
    pullback.lift f hi a b w ≫ Stonean.pullback.snd f hi = b
-- Mathlib/Topology/Instances/CantorSet.lean
/-- The ternary Cantor set is compact. -/
lemma isCompact_cantorSet : IsCompact cantorSet
-- Mathlib/Topology/PartitionOfUnity.lean
theorem sum_nonneg (x : X) : 0 ≤ ∑ᶠ i, f i x
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem smul_tprodCoeff [DecidableEq ι] (z : R) (f : Π i, s i) (i : ι) (r : R₁) [SMul R₁ R]
    [IsScalarTower R₁ R R] [SMul R₁ (s i)] [IsScalarTower R₁ R (s i)] :
    tprodCoeff R z (update f i (r • f i)) = tprodCoeff R (r • z) f
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp] theorem fst_inv (x : tsze R M) : fst x⁻¹ = (fst x)⁻¹
-- Mathlib/Data/Set/Image.lean
theorem Surjective.preimage_injective (hf : Surjective f) : Injective (preimage f)
-- Mathlib/FieldTheory/Extension.lean
/-- Given a lift `x` and an integral element `s : E` over `x.carrier` whose conjugates over
`x.carrier` are all in `K`, we can extend the lift to a lift whose carrier contains `s`. -/
theorem Lifts.exists_lift_of_splits' (x : Lifts F E K) {s : E} (h1 : IsIntegral x.carrier s)
    (h2 : (minpoly x.carrier s).Splits x.emb.toRingHom) : ∃ y, x ≤ y ∧ s ∈ y.carrier
-- Mathlib/Algebra/Ring/Commute.lean
lemma neg_one_pow_eq_pow_mod_two (n : ℕ) : (-1 : R) ^ n = (-1) ^ (n % 2)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem add_equiv_add {f1 f2 g1 g2 : CauSeq β abv} (hf : f1 ≈ f2) (hg : g1 ≈ g2) :
    f1 + g1 ≈ f2 + g2
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem map_add (f : M₁ →SL[σ₁₂] M₂) (x y : M₁) : f (x + y) = f x + f y
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- Interpreting the legs of a cocone as a costructured arrow and then forgetting the arrow again
    does nothing. -/
@[simps!]
def Cocone.toCostructuredArrowCompProj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ ≅ 𝟭 J
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem ContinuousOn.integrableAt_nhdsWithin [TopologicalSpace α]
    [SecondCountableTopologyEither α E] [OpensMeasurableSpace α] {μ : Measure α}
    [IsLocallyFiniteMeasure μ] {a : α} {t : Set α} {f : α → E} (hft : ContinuousOn f t)
    (ht : MeasurableSet t) (ha : a ∈ t) : IntegrableAtFilter f (𝓝[t] a) μ
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive le_max_of_two_nsmul_le_add]
theorem le_max_of_sq_le_mul {a b c : M} (h : a ^ 2 ≤ b * c) : a ≤ max b c
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mul_union : s * (t₁ ∪ t₂) = s * t₁ ∪ s * t₂
-- Mathlib/Data/String/Basic.lean
theorem asString_eq {l : List Char} {s : String} : l.asString = s ↔ l = s.toList
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem out_one : (1 : Associates α).out = 1
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_empty : (∅ : Set α).infsep = 0
-- Mathlib/Deprecated/Submonoid.lean
/-- The image under a monoid hom of the submonoid generated by a set equals the submonoid generated
    by the image of the set under the monoid hom. -/
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
      the `AddSubmonoid` generated by the image of the set under the `AddMonoid` hom."]
theorem image_closure {A : Type*} [Monoid A] {f : M → A} (hf : IsMonoidHom f) (s : Set M) :
    f '' Closure s = Closure (f '' s)
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma isSMulRegular_iff_smul_eq_zero_imp_eq_zero :
    IsSMulRegular M r ↔ ∀ x : M, r • x = 0 → x = 0
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem support_zero : (0 : α →₀ M).support = ∅
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem image_source_eq_target : e '' e.source = e.target
-- Mathlib/Logic/Equiv/TransferInstance.lean
/-- Transfer `IsDomain` across an `Equiv` -/
protected theorem isDomain [Ring α] [Ring β] [IsDomain β] (e : α ≃+* β) : IsDomain α
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
theorem isTotallyDisconnected_singleton {x} : IsTotallyDisconnected ({x} : Set α)
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
theorem symm_apply_eq (e : P₁ ≃ᵃL[k] P₂)  {x y} : e.symm x = y ↔ x = e y
-- Mathlib/Data/Option/Basic.lean
theorem pmap_eq_some_iff {hf} {y : β} :
    pmap f x hf = some y ↔ ∃ (a : α) (H : x = some a), f a (hf a H) = y
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
theorem epi_of_cancel_zero {P Q : C} (f : P ⟶ Q) (h : ∀ {R : C} (g : Q ⟶ R), f ≫ g = 0 → g = 0) :
    Epi f
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- A measure `μ` on a measurable additive group is right invariant
  if the measure of right translations of a set are equal to the measure of the set itself. -/
class IsAddRightInvariant [Add G] (μ : Measure G) : Prop where
  map_add_right_eq_self : ∀ g : G, map (· + g) μ = μ
-- Mathlib/Tactic/Abel.lean
theorem term_atom_pf {α} [AddCommMonoid α] (x x' : α) (h : x = x') : x = term 1 x' 0
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_sub_le (p q : R[X]) : degree (p - q) ≤ max (degree p) (degree q)
-- Mathlib/Topology/Order.lean
/-- A function to a discrete topological space is continuous if and only if the preimage of every
singleton is open. -/
theorem continuous_discrete_rng [TopologicalSpace β] [DiscreteTopology β]
    {f : α → β} : Continuous f ↔ ∀ b : β, IsOpen (f ⁻¹' {b})
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive (attr := simp)]
lemma UniformFun.toFun_div [Div β] (f g : α →ᵤ β) : toFun (f / g) = toFun f / toFun g
-- Mathlib/Computability/NFA.lean
/-- `M.toNFA` is an `NFA` constructed from a `DFA` `M` by using the same start and accept
  states and a transition function which sends `s` with input `a` to the singleton `M.step s a`. -/
@[simps] def toNFA (M : DFA α σ') : NFA α σ'
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_pos {a : R} : 0 < abv a ↔ a ≠ 0
-- Mathlib/Algebra/GCDMonoid/Finset.lean
@[simp]
theorem lcm_empty : (∅ : Finset β).lcm f = 1
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem ball_subset (h : dist x y ≤ ε₂ - ε₁) : ball x ε₁ ⊆ ball y ε₂
-- Mathlib/Algebra/CharP/Basic.lean
theorem sub_pow_char_pow_of_commute [Ring R] {p : ℕ} [Fact p.Prime] [CharP R p] {n : ℕ} (x y : R)
    (h : Commute x y) : (x - y) ^ p ^ n = x ^ p ^ n - y ^ p ^ n
-- Mathlib/Algebra/Group/Ext.lean
@[to_additive (attr := ext)]
theorem Monoid.ext {M : Type u} ⦃m₁ m₂ : Monoid M⦄
    (h_mul : (letI := m₁; HMul.hMul : M → M → M) = (letI := m₂; HMul.hMul : M → M → M)) :
    m₁ = m₂
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
@[simp]
theorem op_top : (⊤ : Subsemiring R).op = ⊤
-- Mathlib/RingTheory/SimpleModule.lean
theorem injective_of_ne_zero [IsSimpleModule R M] {f : M →ₗ[R] N} (h : f ≠ 0) :
    Function.Injective f
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- (implementation detail) A function `Quot F → α` induces a cocone on `F` as long as the universes
    work out. -/
@[simps]
def toCocone {α : Type u} (f : Quot F → α) : Cocone F
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem exists_isTranscendenceBasis (h : Injective (algebraMap R A)) :
    ∃ s : Set A, IsTranscendenceBasis R ((↑) : s → A)