ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Generator.lean
theorem wellPowered_of_isDetector [HasPullbacks C] (G : C) (hG : IsDetector G) : WellPowered C
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem inl_add [Add R] [AddZeroClass A] (r₁ r₂ : R) :
    (inl (r₁ + r₂) : Unitization R A) = inl r₁ + inl r₂
-- Mathlib/Topology/Homeomorph.lean
theorem comp_continuousAt_iff (h : X ≃ₜ Y) (f : Z → X) (z : Z) :
    ContinuousAt (h ∘ f) z ↔ ContinuousAt f z
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fdiv_add_fmod (a b : Int) : b * a.fdiv b + a.fmod b = a
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
protected theorem sup'_apply {C : β → Type*} [∀ b : β, SemilatticeSup (C b)]
    {s : Finset α} (H : s.Nonempty) (f : α → ∀ b : β, C b) (b : β) :
    s.sup' H f b = s.sup' H fun a => f a b
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem factorial_ne_zero (n : ℕ) : n ! ≠ 0
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
theorem toMultilinearMap_injective :
    Function.Injective
      (ContinuousMultilinearMap.toMultilinearMap :
        ContinuousMultilinearMap R M₁ M₂ → MultilinearMap R M₁ M₂)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem abs_div (a b : α) : |a / b| = |a| / |b|
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- Every continuous injective `f : (a, b) → δ` is strictly monotone
or antitone (increasing or decreasing). -/
theorem ContinuousOn.strictMonoOn_of_injOn_Ioo {a b : α} {f : α → δ} (hab : a < b)
    (hf_c : ContinuousOn f (Ioo a b)) (hf_i : InjOn f (Ioo a b)) :
    StrictMonoOn f (Ioo a b) ∨ StrictAntiOn f (Ioo a b)
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem mem_infPrepartition_comm :
    J ∈ π₁.infPrepartition π₂.toPrepartition ↔ J ∈ π₂.infPrepartition π₁.toPrepartition
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem reverse_eq_id :
    (reverse : CliffordAlgebra (0 : QuadraticForm R Unit) →ₗ[R] _) = LinearMap.id
-- Mathlib/Algebra/Polynomial/Reverse.lean
theorem trailingCoeff_mul {R : Type*} [Ring R] [NoZeroDivisors R] (p q : R[X]) :
    (p * q).trailingCoeff = p.trailingCoeff * q.trailingCoeff
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem inf_eq_add : ((· ⊓ ·) : Tropical R → Tropical R → Tropical R) = (· + ·)
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem card_roots_le_map_of_injective [IsDomain A] [IsDomain B] {p : A[X]} {f : A →+* B}
    (hf : Function.Injective f) : Multiset.card p.roots ≤ Multiset.card (p.map f).roots
-- Mathlib/Topology/Semicontinuous.lean
theorem IsClosed.upperSemicontinuousAt_indicator (hs : IsClosed s) (hy : 0 ≤ y) :
    UpperSemicontinuousAt (indicator s fun _x => y) x
-- Mathlib/Algebra/Category/AlgebraCat/Monoidal.lean
theorem forget₂_map_associator_hom (X Y Z : AlgebraCat.{u} R) :
    (forget₂ (AlgebraCat R) (ModuleCat R)).map (α_ X Y Z).hom =
      (α_
        (forget₂ _ (ModuleCat R) |>.obj X)
        (forget₂ _ (ModuleCat R) |>.obj Y)
        (forget₂ _ (ModuleCat R) |>.obj Z)).hom
-- Mathlib/Order/Filter/Prod.lean
theorem mem_prod_iff {s : Set (α × β)} {f : Filter α} {g : Filter β} :
    s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s
-- Mathlib/RingTheory/Ideal/Operations.lean
/-- If `x` is an `I`-multiple of the submodule spanned by `f '' s`,
then we can write `x` as an `I`-linear combination of the elements of `f '' s`. -/
theorem mem_ideal_smul_span_iff_exists_sum {ι : Type*} (f : ι → M) (x : M) :
    x ∈ I • span R (Set.range f) ↔
      ∃ (a : ι →₀ R) (_ : ∀ i, a i ∈ I), (a.sum fun i c => c • f i) = x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem lt_log2_self : n < 2 ^ (n.log2 + 1)
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofMul_eq_zero {A : Type*} [One A] {x : A} : Additive.ofMul x = 0 ↔ x = 1
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- Linearly disjoint is symmetric if elements in the module commute. -/
theorem linearDisjoint_symm_of_commute
    (hc : ∀ (m : M) (n : N), Commute m.1 n.1) : M.LinearDisjoint N ↔ N.LinearDisjoint M
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
/-- This is a helper construction that can be useful when verifying that a category has all
    pushout. Given `F : WalkingSpan ⥤ C`, which is really the same as
    `span (F.map fst) (F.map snd)`, and a pushout cocone on `F.map fst` and `F.map snd`,
    we get a cocone on `F`.

    If you're thinking about using this, have a look at `hasPushouts_of_hasColimit_span`, which
    you may find to be an easier way of achieving your goal. -/
@[simps]
def Cocone.ofPushoutCocone {F : WalkingSpan ⥤ C} (t : PushoutCocone (F.map fst) (F.map snd)) :
    Cocone F
-- Mathlib/Algebra/Lie/Basic.lean
theorem coe_injective : @Function.Injective (L₁ →ₗ⁅R⁆ L₂) (L₁ → L₂) (↑)
-- Mathlib/Tactic/CategoryTheory/BicategoricalComp.lean
@[simps]
instance assoc (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (i : a ⟶ d)
    [BicategoricalCoherence (f ≫ g ≫ h) i] :
    BicategoricalCoherence ((f ≫ g) ≫ h) i
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_add_nonpos_right' (hf : Tendsto f l atBot) (hg : ∀ᶠ x in l, g x ≤ 0) :
    Tendsto (fun x => f x + g x) l atBot
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem zero_xor (n : ℕ) : 0 ^^^ n = n
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem coe_injective ⦃f g : α →ₛ β⦄ (H : (f : α → β) = g) : f = g
-- Mathlib/Data/Bundle.lean
@[simp 1001, mfld_simps 1001]
theorem TotalSpace.mk_inj {b : B} {y y' : E b} : mk' F b y = mk' F b y' ↔ y = y'
-- Mathlib/Topology/MetricSpace/Polish.lean
/-- Given a closed set `s` in a Polish space, one can construct a finer Polish topology for
which `s` is both open and closed. -/
theorem _root_.IsClosed.isClopenable [TopologicalSpace α] [PolishSpace α] {s : Set α}
    (hs : IsClosed s) : IsClopenable s
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem supDegree_single_ne_zero (a : A) {r : R} (hr : r ≠ 0) :
    (single a r).supDegree D = D a
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem extend_function_finite {α : Type u} {β : Type v} [Finite α] {s : Set α} (f : s ↪ β)
    (h : Nonempty (α ≃ β)) : ∃ g : α ≃ β, ∀ x : s, g x = f x
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
/-- Pull a subalgebra back to an opposite subalgebra along `MulOpposite.unop` -/
@[simps toSubsemiring]
protected def op (S : Subalgebra R A) : Subalgebra R Aᵐᵒᵖ
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem ω_pow_formula (p' : ℕ) (h : lucasLehmerResidue (p' + 2) = 0) :
    ∃ k : ℤ,
      (ω : X (q (p' + 2))) ^ 2 ^ (p' + 1) =
        k * mersenne (p' + 2) * (ω : X (q (p' + 2))) ^ 2 ^ p' - 1
-- Mathlib/Data/List/Cycle.lean
theorem Chain.eq_nil_of_well_founded [IsWellFounded α r] (h : Chain r s) : s = Cycle.nil
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem zero_apply {a : α} : (0 : SummableFamily Γ R α) a = 0
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
theorem coneOfHom_homOfCone (s : Cone F) : coneOfHom h (homOfCone h s) = s
-- Mathlib/Data/Nat/Defs.lean
/-- A subset of `ℕ` containing zero and closed under `Nat.succ` contains all of `ℕ`. -/
lemma set_induction {S : Set ℕ} (hb : 0 ∈ S) (h_ind : ∀ k : ℕ, k ∈ S → k + 1 ∈ S) (n : ℕ) :
    n ∈ S
-- Mathlib/Data/Finsupp/Basic.lean
theorem sum_comapDomain [Zero M] [AddCommMonoid N] (f : α → β) (l : β →₀ M) (g : β → M → N)
    (hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support) :
    (comapDomain f l hf.injOn).sum (g ∘ f) = l.sum g
-- Mathlib/Order/SuccPred/Basic.lean
lemma succ_min (a b : α) : succ (min a b) = min (succ a) (succ b)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem rid_symm_apply (a : A) : (TensorProduct.rid R S A).symm a = a ⊗ₜ 1
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem prod_toNonUnitalSubalgebra :
    (S.prod S₁).toNonUnitalSubalgebra = S.toNonUnitalSubalgebra.prod S₁.toNonUnitalSubalgebra
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast]
theorem coe_div (x y : s) : (↑(x / y) : K) = ↑x / ↑y
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[ext]
theorem ext {S T : NonUnitalSubalgebra R A} (h : ∀ x : A, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Computability/Language.lean
theorem join_mem_kstar {L : List (List α)} (h : ∀ y ∈ L, y ∈ l) : L.join ∈ l∗
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- If `D ⋙ forget T` has a colimit, then `D` has a colimit. -/
theorem hasColimit_of_comp_forget_hasColimit (D : J ⥤ Coalgebra T) [HasColimit (D ⋙ forget T)] :
    HasColimit D
-- Mathlib/Logic/Function/Conjugate.lean
/-- The identity map commutes with any self-map. -/
theorem id_left : Commute id f
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem orderTop_single_le : a ≤ (single a r).orderTop
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem coeff_def {s : Unit →₀ ℕ} {n : ℕ} (h : s () = n) : coeff R n = MvPowerSeries.coeff R s
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem swap_leftInverse : Function.LeftInverse (@swap α β) swap
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- The difference with `NonUnitalSubring.closure_induction` is that this acts on the
subtype. -/
@[elab_as_elim]
theorem closure_induction' {s : Set R} {p : closure s → Prop} (a : closure s)
    (mem : ∀ (x) (hx : x ∈ s), p ⟨x, subset_closure hx⟩) (zero : p 0)
    (add : ∀ x y, p x → p y → p (x + y)) (neg : ∀ x, p x → p (-x))
    (mul : ∀ x y, p x → p y → p (x * y)) : p a
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictMono.comp_strictAnti (hg : StrictMono g) (hf : StrictAnti f) : StrictAnti (g ∘ f)
-- Mathlib/Order/Interval/Set/Basic.lean
lemma Ici_eq_singleton_iff_isTop {x : α} : (Ici x = {x}) ↔ IsTop x
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem fst_comp_inl : (fst M N).comp (inl M N) = id M
-- Mathlib/Computability/Partrec.lean
theorem encode_iff {f : α → σ} : (Computable fun a => encode (f a)) ↔ Computable f
-- Mathlib/LinearAlgebra/Span.lean
theorem span_singleton_eq_span_singleton {R M : Type*} [Ring R] [AddCommGroup M] [Module R M]
    [NoZeroSMulDivisors R M] {x y : M} : ((R ∙ x) = R ∙ y) ↔ ∃ z : Rˣ, z • x = y
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem smuld_val (n x y : ℤ) : sqrtd * (n : ℤ√d) * ⟨x, y⟩ = ⟨d * n * y, n * x⟩
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem toIdeal_inf (I J : HomogeneousIdeal 𝒜) : (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal
-- Mathlib/Data/ENat/Basic.lean
@[elab_as_elim]
theorem nat_induction {P : ℕ∞ → Prop} (a : ℕ∞) (h0 : P 0) (hsuc : ∀ n : ℕ, P n → P n.succ)
    (htop : (∀ n : ℕ, P n) → P ⊤) : P a
-- .lake/packages/batteries/Batteries/Classes/Order.lean
/-- `LTCmp cmp` asserts that `cmp x y = .lt` and `x < y` coincide. -/
class LTCmp [LT α] (cmp : α → α → Ordering) extends OrientedCmp cmp : Prop where
  /-- `cmp x y = .lt` holds iff `x < y` is true. -/
  cmp_iff_lt : cmp x y = .lt ↔ x < y
-- Mathlib/LinearAlgebra/TensorProduct/Opposite.lean
@[simp]
theorem opAlgEquiv_symm_tmul (a : A) (b : B) :
    (opAlgEquiv R S A B).symm (op <| a ⊗ₜ[R] b) = op a ⊗ₜ op b
-- Mathlib/GroupTheory/Sylow.lean
theorem Sylow.smul_def {g : G} {P : Sylow p G} : g • P = MulAut.conj g • P
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_pi_sub (x : ℂ) : cos (π - x) = -cos x
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuousAt_ciInf {f : ι → α → δ'}
    (bdd : ∀ᶠ y in 𝓝 x, BddBelow (range fun i => f i y)) (h : ∀ i, UpperSemicontinuousAt (f i) x) :
    UpperSemicontinuousAt (fun x' => ⨅ i, f i x') x
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem coe_mapRingHom_eq_coe_map [RingHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ S[X]⁰.comap φ) :
    (mapRingHom φ hφ : RatFunc R → RatFunc S) = map φ hφ
-- Mathlib/Topology/Compactness/Compact.lean
/-- The neighborhood filter of a compact set is disjoint with a filter `l` if and only if the
neighborhood filter of each point of this set is disjoint with `l`. -/
theorem IsCompact.disjoint_nhdsSet_left {l : Filter X} (hs : IsCompact s) :
    Disjoint (𝓝ˢ s) l ↔ ∀ x ∈ s, Disjoint (𝓝 x) l
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem symm_apply_apply (b : M) : e.symm (e b) = b
-- Mathlib/Data/Nat/Factorization/Defs.lean
/-- For nonzero `a` and `b`, the power of `p` in `a * b` is the sum of the powers in `a` and `b` -/
@[simp]
theorem factorization_mul {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).factorization = a.factorization + b.factorization
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma contractible_distinguished (X : Cᵒᵖ) :
    contractibleTriangle X ∈ distinguishedTriangles C
-- Mathlib/Data/Real/Basic.lean
theorem ofCauchy_neg (a) : (⟨-a⟩ : ℝ) = -⟨a⟩
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem coequalizer.π_colimMap_desc {X' Y' Z : C} (f' g' : X' ⟶ Y') [HasCoequalizer f' g']
    (p : X ⟶ X') (q : Y ⟶ Y') (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') (h : Y' ⟶ Z)
    (wh : f' ≫ h = g' ≫ h) :
    coequalizer.π f g ≫ colimMap (parallelPairHom f g f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive AddCommute.prod]
theorem Commute.prod {x y : M × N} (hm : Commute x.1 y.1) (hn : Commute x.2 y.2) : Commute x y
-- Mathlib/CategoryTheory/Galois/Decomposition.lean
/-- Any object with non-empty fiber admits a hom from a Galois object. -/
lemma exists_hom_from_galois_of_fiber_nonempty (X : C) (h : Nonempty (F.obj X)) :
    ∃ (A : C) (_ : A ⟶ X), IsGalois A
-- Mathlib/AlgebraicGeometry/Morphisms/UnderlyingMap.lean
lemma Scheme.Hom.surjective (f : X.Hom Y) [Surjective f] : Function.Surjective f.1.base
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
/-- If each `f i`, `i ∈ s` belongs to `[0, 1]`, then their product is less than or equal to one.
See also `Finset.prod_le_one'` for the case of an ordered commutative multiplicative monoid. -/
lemma prod_le_one (h0 : ∀ i ∈ s, 0 ≤ f i) (h1 : ∀ i ∈ s, f i ≤ 1) : ∏ i ∈ s, f i ≤ 1
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_mono {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 : α → G'}
    (hf : Integrable f μ) (hg : Integrable g μ) (hfg : f ≤ᵐ[μ] g) :
    setToFun μ T hT f ≤ setToFun μ T hT g
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_nndist_eq_sup [PseudoMetricSpace α] [PseudoMetricSpace β] (x y : WithLp ∞ (α × β)) :
    nndist x y = nndist x.fst y.fst ⊔ nndist x.snd y.snd
-- Mathlib/Data/Set/SMulAntidiagonal.lean
@[to_additive VAddAntidiagonal.eq_of_snd_eq_snd]
theorem eq_of_snd_eq_snd (h : (x : G × P).snd = (y : G × P).snd) : x = y
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma lowerClosure_le {t : LowerSet α} : lowerClosure s ≤ t ↔ s ⊆ t
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_sup_inf (s : Finset ι) (t : Finset κ) (f : ι → α) (g : κ → α) :
    s.inf f ⊔ t.inf g = (s ×ˢ t).inf fun i => f i.1 ⊔ g i.2
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem nullMeasurableSet_eq {a : α} : NullMeasurableSet { x | x = a } μ
-- Mathlib/Analysis/Convex/Gauge.lean
@[simp]
theorem gauge_closure_zero : gauge (closure (0 : Set E)) = 0
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem mem_closure_iff {s : Set R} {x} :
    x ∈ closure s ↔ x ∈ AddSubmonoid.closure (Submonoid.closure s : Set R)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem padicValInt_dvd (a : ℤ) : (p : ℤ) ^ padicValInt p a ∣ a
-- Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean
@[to_additive]
lemma fn_min_mul_fn_max  (f : α → β) (a b : α) : f (min a b) * f (max a b) = f a * f b
-- Mathlib/Topology/Compactness/Compact.lean
/-- If `Y` is a compact topological space, then `Prod.fst : X × Y → X` is a closed map. -/
theorem isClosedMap_fst_of_compactSpace [CompactSpace Y] : IsClosedMap (Prod.fst : X × Y → X)
-- Mathlib/RingTheory/Localization/Integral.lean
theorem RingHom.isIntegralElem_localization_at_leadingCoeff {R S : Type*} [CommRing R] [CommRing S]
    (f : R →+* S) (x : S) (p : R[X]) (hf : p.eval₂ f x = 0) (M : Submonoid R)
    (hM : p.leadingCoeff ∈ M) {Rₘ Sₘ : Type*} [CommRing Rₘ] [CommRing Sₘ] [Algebra R Rₘ]
    [IsLocalization M Rₘ] [Algebra S Sₘ] [IsLocalization (M.map f : Submonoid S) Sₘ] :
    (map Sₘ f M.le_comap_map : Rₘ →+* _).IsIntegralElem (algebraMap S Sₘ x)
-- Mathlib/Algebra/Algebra/Subalgebra/Operations.lean
theorem ker_rangeRestrict (f : A →ₐ[R] B) : RingHom.ker f.rangeRestrict = RingHom.ker f
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆
-- Mathlib/Analysis/Complex/Basic.lean
/-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexLinearIsometryEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃ₗᵢ[ℝ] ℂ
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem natCast_lt_iff {m n : ℕ} : (m : EReal) < (n : EReal) ↔ m < n
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem comp_continuous_iff {f : α → E} : Continuous (e ∘ f) ↔ Continuous f
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem Filter.HasBasis.uniformEmbedding_iff' {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
    (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
    UniformEmbedding f ↔ Injective f ∧
      (∀ i, p' i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
        (∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j)
-- Mathlib/Data/Sym/Sym2.lean
theorem fromRel_prop {sym : Symmetric r} {a b : α} : s(a, b) ∈ fromRel sym ↔ r a b
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
theorem neg_left (x y : M₁) : B₁ (-x) y = -B₁ x y
-- Mathlib/CategoryTheory/Subobject/Comma.lean
@[simp]
theorem projectQuotient_mk [HasColimits C] [PreservesColimits S] {A : CostructuredArrow S T}
    {P : (CostructuredArrow S T)ᵒᵖ} (f : P ⟶ op A) [Mono f] :
    projectQuotient (Subobject.mk f) = Subobject.mk f.unop.left.op
-- Mathlib/Order/RelIso/Set.lean
@[simp]
theorem RelEmbedding.codRestrict_apply (p) (f : r ↪r s) (H a) :
    RelEmbedding.codRestrict p f H a = ⟨f a, H a⟩
-- Mathlib/Analysis/Analytic/Basic.lean
protected theorem hasSum [CompleteSpace F] (p : FormalMultilinearSeries 𝕜 E F) {x : E}
    (hx : x ∈ EMetric.ball (0 : E) p.radius) : HasSum (fun n : ℕ => p n fun _ => x) (p.sum x)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem normal_subgroupOf_iff {H K : Subgroup G} (hHK : H ≤ K) :
    (H.subgroupOf K).Normal ↔ ∀ h k, h ∈ H → k ∈ K → k * h * k⁻¹ ∈ H
-- Mathlib/Data/Real/Pi/Wallis.lean
theorem W_le (k : ℕ) : W k ≤ π / 2
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive]
theorem prod_congr' {M : Type*} [CommMonoid M] {a b : ℕ} (f : Fin b → M) (h : a = b) :
    (∏ i : Fin a, f (cast h i)) = ∏ i : Fin b, f i
-- Mathlib/Probability/Kernel/Basic.lean
@[simp]
theorem setIntegral_restrict {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : β → E} {a : α} (hs : MeasurableSet s) (t : Set β) :
    ∫ x in t, f x ∂κ.restrict hs a = ∫ x in t ∩ s, f x ∂κ a
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem linear_ne_zero (cd : Fin 2 → ℝ) (z : ℍ) (h : cd ≠ 0) : (cd 0 : ℂ) * z + cd 1 ≠ 0
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem measurable_map (f : α → β) (hf : Measurable f) :
    Measurable fun μ : Measure α => map f μ
-- Mathlib/Probability/Kernel/CondDistrib.lean
/-- `condDistrib` is a.e. uniquely defined as the kernel satisfying the defining property of
`condKernel`. -/
theorem condDistrib_ae_eq_of_measure_eq_compProd (hX : Measurable X) (hY : Measurable Y)
    (κ : Kernel β Ω) [IsFiniteKernel κ] (hκ : μ.map (fun x => (X x, Y x)) = μ.map X ⊗ₘ κ) :
    ∀ᵐ x ∂μ.map X, κ x = condDistrib Y X μ x
-- Mathlib/Order/Disjoint.lean
theorem IsComplemented.sup : IsComplemented a → IsComplemented b → IsComplemented (a ⊔ b)
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
@[simp]
theorem comp_F {S₁ S₂ S₃ : Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃) :
    (Φ₁₂ ≫ Φ₂₃).F = Φ₁₂.F ≫ Φ₂₃.F
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
theorem count_coe {J : Ideal R} (hJ : J ≠ 0) :
    count K v J = (Associates.mk v.asIdeal).count (Associates.mk J).factors
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pairwise_iff_get : Pairwise R l ↔ ∀ (i j) (_hij : i < j), R (get l i) (get l j)
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
theorem uncurry_pre (f : B ⟶ A) [Exponentiable B] (X : C) :
    CartesianClosed.uncurry ((pre f).app X) = Limits.prod.map f (𝟙 _) ≫ (exp.ev A).app X
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem USize.size_le : USize.size ≤ 2 ^ 64
-- Mathlib/Order/Directed.lean
theorem directed_of (r : α → α → Prop) [IsDirected α r] (a b : α) : ∃ c, r a c ∧ r b c
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
/-- A vector space has dimension `1` if and only if there is a
single non-zero vector of which all vectors are multiples. -/
theorem rank_eq_one_iff [Module.Free K V] :
    Module.rank K V = 1 ↔ ∃ v₀ : V, v₀ ≠ 0 ∧ ∀ v, ∃ r : K, r • v₀ = v
-- Mathlib/Algebra/Polynomial/Basic.lean
/-- Expressing the product of two polynomials as a double sum. -/
theorem mul_eq_sum_sum :
    p * q = ∑ i ∈ p.support, q.sum fun j a => (monomial (i + j)) (p.coeff i * a)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1
-- Mathlib/Data/Set/Pairwise/Basic.lean
protected theorem PairwiseDisjoint.insert (hs : s.PairwiseDisjoint f) {i : ι}
    (h : ∀ j ∈ s, i ≠ j → Disjoint (f i) (f j)) : (insert i s).PairwiseDisjoint f
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem lcm_pos {m n : ℕ} : 0 < m → 0 < n → 0 < m.lcm n
-- Mathlib/Order/Filter/NAry.lean
theorem image2_mem_map₂ (hs : s ∈ f) (ht : t ∈ g) : image2 m s t ∈ map₂ m f g
-- Mathlib/Analysis/Convex/Function.lean
/-- The pointwise maximum of strictly convex functions is strictly convex. -/
theorem StrictConvexOn.sup (hf : StrictConvexOn 𝕜 s f) (hg : StrictConvexOn 𝕜 s g) :
    StrictConvexOn 𝕜 s (f ⊔ g)
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem ne_zero (hp : p.IsUnitTrinomial) : p ≠ 0
-- Mathlib/LinearAlgebra/Vandermonde.lean
theorem eq_zero_of_forall_index_sum_pow_mul_eq_zero {R : Type*} [CommRing R] [IsDomain R] {n : ℕ}
    {f v : Fin n → R} (hf : Function.Injective f)
    (hfv : ∀ j, (∑ i : Fin n, f j ^ (i : ℕ) * v i) = 0) : v = 0
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_sub : cfcₙ (fun x ↦ f x - g x) a = cfcₙ f a - cfcₙ g a
-- Mathlib/Algebra/GroupWithZero/Hom.lean
lemma copy_eq {_ : MulZeroOneClass α} {_ : MulZeroOneClass β} (f : α →*₀ β) (f' : α → β) (h) :
    f.copy f' h = f
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
@[continuity]
theorem continuous_reflTransSymmAux : Continuous reflTransSymmAux
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- C2.1.3 in [Elephant] -/
theorem isSheafFor_iff_generate (R : Presieve X) :
    IsSheafFor P R ↔ IsSheafFor P (generate R : Presieve X)
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_succ_of_lt (p i : Fin n) (h : i < p) (hi := succ_ne_last_of_lt h) :
    p.predAbove (succ i) = (i.succ).castPred hi
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem symm_trans_self (e : M ≃* N) : e.symm.trans e = refl N
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- If `K / E / F` is a field extension tower, then `E` adjoin `separableClosure F K` is contained
in `separableClosure E K`. -/
theorem separableClosure.adjoin_le [Algebra E K] [IsScalarTower F E K] :
    adjoin E (separableClosure F K) ≤ separableClosure E K
-- Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean
lemma distinguished_iff_iso_trianglehOfDegreewiseSplit
    (T : Triangle (HomotopyCategory C (ComplexShape.up ℤ))) :
    (T ∈ distTriang _) ↔ ∃ (S : ShortComplex (CochainComplex C ℤ))
      (σ : ∀ n, (S.map (HomologicalComplex.eval C _ n)).Splitting),
      Nonempty (T ≅ CochainComplex.trianglehOfDegreewiseSplit S σ)
-- Mathlib/RingTheory/IntegralClosure/Algebra/Basic.lean
nonrec theorem IsIntegral.mul {x y : A} (hx : IsIntegral R x) (hy : IsIntegral R y) :
    IsIntegral R (x * y)
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eval_nodal {x : R} : (nodal s v).eval x = ∏ i ∈ s, (x - v i)
-- Mathlib/GroupTheory/Perm/Support.lean
theorem disjoint_iff_eq_or_eq : Disjoint f g ↔ ∀ x : α, f x = x ∨ g x = x
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem apply_symm_apply (h : X ≃ₜ Y) (y : Y) : h (h.symm y) = y