ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem exists_finite_card_le_of_finite_of_linearIndependent_of_span (ht : t.Finite)
    (hs : LinearIndependent K (fun x => x : s → V)) (hst : s ⊆ span K t) :
    ∃ h : s.Finite, h.toFinset.card ≤ ht.toFinset.card
-- Mathlib/Algebra/Module/Projective.lean
theorem projective_def :
    Projective R P ↔ ∃ s : P →ₗ[R] P →₀ R, Function.LeftInverse (Finsupp.total P P R id) s
-- Mathlib/Data/Set/Image.lean
@[simp, mfld_simps]
theorem range_id : range (@id α) = univ
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive, field_simps] -- The attributes are out of order on purpose
theorem div_div_eq_mul_div : a / (b / c) = a * c / b
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
@[simp]
theorem pointwise_smul_le_pointwise_smul_iff₀ {a : M} (ha : a ≠ 0) {S T : Subsemiring R} :
    a • S ≤ a • T ↔ S ≤ T
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_finset_subset_smul {s : Finset α} : a ∈ s → a • t ⊆ s • t
-- Mathlib/Order/Antisymmetrization.lean
@[refl]
theorem antisymmRel_refl [IsRefl α r] (a : α) : AntisymmRel r a a
-- Mathlib/RingTheory/AlgebraicIndependent.lean
/-- If every finite set of algebraically independent element has cardinality at most `n`,
then the same is true for arbitrary sets of algebraically independent elements. -/
theorem algebraicIndependent_bounded_of_finset_algebraicIndependent_bounded {n : ℕ}
    (H : ∀ s : Finset A, (AlgebraicIndependent R fun i : s => (i : A)) → s.card ≤ n) :
    ∀ s : Set A, AlgebraicIndependent R ((↑) : s → A) → Cardinal.mk s ≤ n
-- Mathlib/Data/PFunctor/Multivariate/Basic.lean
theorem supp_eq {α : TypeVec n} (a : P.A) (f : P.B a ⟹ α) (i) :
    @supp.{u} _ P.Obj _ α (⟨a, f⟩ : P α) i = f i '' univ
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem dedup_add (s t : Multiset α) : dedup (s + t) = ndunion s (dedup t)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_add_infinitePos {x y : ℝ*} :
    InfinitePos x → InfinitePos y → InfinitePos (x + y)
-- Mathlib/Algebra/Group/Invertible/Defs.lean
theorem mul_left_eq_iff_eq_invOf_mul : c * a = b ↔ a = ⅟c * b
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
theorem injective_of_mono_of_preservesPullback {X Y : C} (f : X ⟶ Y) [Mono f]
    [PreservesLimitsOfShape WalkingCospan (forget C)] : Function.Injective f
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- If `‖r‖ < 1`, then `∑' n : ℕ, n * r ^ n = r / (1 - r) ^ 2`. -/
theorem tsum_coe_mul_geometric_of_norm_lt_one {𝕜 : Type*} [NormedDivisionRing 𝕜] [CompleteSpace 𝕜]
    {r : 𝕜} (hr : ‖r‖ < 1) : (∑' n : ℕ, n * r ^ n : 𝕜) = r / (1 - r) ^ 2
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem sumCompl_apply_inr {α : Type u} (s : Set α) [DecidablePred (· ∈ s)] (x : (sᶜ : Set α)) :
    Equiv.Set.sumCompl s (Sum.inr x) = x
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem norm_snd (a : 𝓜(𝕜, A)) : ‖a.snd‖ = ‖a‖
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem quotientEquiv_apply_mk [Fintype ι] (x : E) :
    quotientEquiv b (Submodule.Quotient.mk x) = fractRestrict b x
-- Mathlib/Topology/Separation.lean
theorem closed_nhds_basis (x : X) : (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsClosed s) id
-- Mathlib/Data/Set/Basic.lean
theorem insert_inter_of_not_mem (h : a ∉ t) : insert a s ∩ t = s ∩ t
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The associator isomorphism can be passed through a map by swapping the order. -/
@[reassoc]
theorem biprod.associator_natural {U V W X Y Z : C} (f : U ⟶ X) (g : V ⟶ Y) (h : W ⟶ Z) :
    biprod.map (biprod.map f g) h ≫ (biprod.associator _ _ _).hom
      = (biprod.associator _ _ _).hom ≫ biprod.map f (biprod.map g h)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem cmp_mul_pos_right [MulPosStrictMono α]
    (ha : 0 < a) (b c : α) : cmp (b * a) (c * a) = cmp b c
-- Mathlib/RingTheory/MvPolynomial/Ideal.lean
/-- `x` is in a monomial ideal generated by `s` iff every element of its support dominates one of
the generators. Note that `si ≤ xi` is analogous to saying that the monomial corresponding to `si`
divides the monomial corresponding to `xi`. -/
theorem mem_ideal_span_monomial_image {x : MvPolynomial σ R} {s : Set (σ →₀ ℕ)} :
    x ∈ Ideal.span ((fun s => monomial s (1 : R)) '' s) ↔ ∀ xi ∈ x.support, ∃ si ∈ s, si ≤ xi
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := elab_as_elim)]
theorem induction_on₃ {p : Localization S → Localization S → Localization S → Prop} (x y z)
    (H : ∀ x y z : M × S, p (mk x.1 x.2) (mk y.1 y.2) (mk z.1 z.2)) : p x y z
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem tendsto_approxOn_L1_nnnorm [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f)
    {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] {μ : Measure β}
    (hμ : ∀ᵐ x ∂μ, f x ∈ closure s) (hi : HasFiniteIntegral (fun x => f x - y₀) μ) :
    Tendsto (fun n => ∫⁻ x, ‖approxOn f hf s y₀ h₀ n x - f x‖₊ ∂μ) atTop (𝓝 0)
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem moveLeft_le {x : PGame} (o : Numeric x) (i) : x.moveLeft i ≤ x
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem lift_mk_fin (n : ℕ) : lift #(Fin n) = n
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
/-- Variant of `mul_lt_of_lt_one_left` for `b` negative instead of positive. -/
theorem lt_mul_of_lt_one_left [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hb : b < 0) (h : a < 1) : b < a * b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Simproc.lean
theorem eq_add_le {a : Nat} (b : Nat) {c : Nat} (h : c ≤ a) : (a = b + c) = (b = a - c)
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
@[simp]
theorem volumeForm_neg_orientation : (-o).volumeForm = -o.volumeForm
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
    ∃ l : List G, (∀ x ∈ l, x ∈ s ∨ x⁻¹ ∈ s) ∧ l.prod = a
-- Mathlib/Order/LiminfLimsup.lean
lemma isBoundedUnder_ge_add [Add R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u v : α → R} (u_bdd_ge : f.IsBoundedUnder (· ≥ ·) u) (v_bdd_ge : f.IsBoundedUnder (· ≥ ·) v) :
    f.IsBoundedUnder (· ≥ ·) (u + v)
-- Mathlib/Topology/Sequences.lean
protected theorem SequentialSpace.iSup {ι : Sort*} {t : ι → TopologicalSpace X}
    (h : ∀ i, @SequentialSpace X (t i)) : @SequentialSpace X (⨆ i, t i)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem symm_le_uniformity : map (@Prod.swap α α) (𝓤 _) ≤ 𝓤 _
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem smulRight_one_one (c : R₁ →L[R₁] M₂) : smulRight (1 : R₁ →L[R₁] R₁) (c 1) = c
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
    a + c < b + d
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.rec_heq {β : List α → Sort _} {f : ∀ a l, β l → β (a :: l)} {b : β []} {l l' : List α}
    (hl : l ~ l') (f_congr : ∀ {a l l' b b'}, l ~ l' → HEq b b' → HEq (f a l b) (f a l' b'))
    (f_swap : ∀ {a a' l b}, HEq (f a (a' :: l) (f a' l b)) (f a' (a :: l) (f a l b))) :
    HEq (@List.rec α β b f l) (@List.rec α β b f l')
-- Mathlib/Order/Atoms.lean
@[simp]
theorem Set.Iic.isCoatom_iff {a : Set.Iic b} : IsCoatom a ↔ ↑a ⋖ b
-- Mathlib/Data/Finset/Sym.lean
theorem injective_sym2 : Function.Injective (Finset.sym2 : Finset α → _)
-- Mathlib/Algebra/Quandle.lean
lemma act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem sub_le_add_right_sub (a i j : Nat) : a - i ≤ a + j - i
-- Mathlib/Data/Matroid/Basic.lean
/-- A family of sets with the exchange property is an antichain. -/
theorem antichain (hB : Base B) (hB' : Base B') (h : B ⊆ B') : B = B'
-- Mathlib/Data/Setoid/Basic.lean
lemma sInf_equiv {S : Set (Setoid α)} {x y : α} :
    letI := sInf S
    x ≈ y ↔ ∀ s ∈ S, s.Rel x y
-- Mathlib/Data/List/Range.lean
theorem nodup_range (n : ℕ) : Nodup (range n)
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem Multipliable.trans_div (hg : Multipliable g) (hfg : Multipliable fun b ↦ f b / g b) :
    Multipliable f
-- Mathlib/Algebra/GroupWithZero/Defs.lean
/-- A mixin for left cancellative multiplication by nonzero elements. -/
class IsLeftCancelMulZero (M₀ : Type u) [Mul M₀] [Zero M₀] : Prop where
  /-- Multiplication by a nonzero element is left cancellative. -/
  protected mul_left_cancel_of_ne_zero : ∀ {a b c : M₀}, a ≠ 0 → a * b = a * c → b = c
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
/-- Two affine maps from a Pi-tyoe of modules `(i : ι) → φv i` are equal if they are equal in their
  operation on `Pi.single` and at zero. Analogous to `LinearMap.pi_ext`. See also `pi_ext_nonempty`,
  which instead of agrement at zero requires `Nonempty ι`. -/
theorem pi_ext_zero (h : ∀ i x, f (Pi.single i x) = g (Pi.single i x)) (h₂ : f 0 = g 0) :
    f = g
-- Mathlib/Topology/Homotopy/Basic.lean
theorem coe_toContinuousMap (F : HomotopyWith f₀ f₁ P) : ⇑F.toContinuousMap = F
-- Mathlib/Init/Quot.lean
theorem Quotient.mk'_eq_mk [s : Setoid α] : Quotient.mk' = Quotient.mk s
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem support_smul {S₁ : Type*} [SMulZeroClass S₁ R] {a : S₁} {f : MvPolynomial σ R} :
    (a • f).support ⊆ f.support
-- Mathlib/GroupTheory/OrderOfElement.lean
/-- If `gcd(|G|,n)=1` then the `n`th power map is a bijection -/
@[to_additive (attr := simps) "If `gcd(|G|,n)=1` then the smul by `n` is a bijection"]
noncomputable def powCoprime {G : Type*} [Group G] (h : (Nat.card G).Coprime n) : G ≃ G
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
protected theorem Nat.lt_irrefl (n : Nat) : Not (LT.lt n n)
-- Mathlib/Order/Heyting/Regular.lean
@[simp, norm_cast]
theorem coe_inf (a b : Regular α) : (↑(a ⊓ b) : α) = (a : α) ⊓ b
-- Mathlib/Algebra/IsPrimePow.lean
/-- An equivalent definition for prime powers: `n` is a prime power iff there is a prime `p` and a
natural `k` such that `n` can be written as `p^(k+1)`. -/
theorem isPrimePow_iff_pow_succ : IsPrimePow n ↔ ∃ (p : R) (k : ℕ), Prime p ∧ p ^ (k + 1) = n
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem one_lt_rpow_of_pos_of_lt_one_of_neg (hx1 : 0 < x) (hx2 : x < 1) (hz : z < 0) :
    1 < x ^ z
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
protected theorem neg {B : BilinForm R₁ M₁} (hB : B.IsRefl) : (-B).IsRefl
-- Mathlib/Topology/ContinuousOn.lean
theorem dense_pi {ι : Type*} {α : ι → Type*} [∀ i, TopologicalSpace (α i)] {s : ∀ i, Set (α i)}
    (I : Set ι) (hs : ∀ i ∈ I, Dense (s i)) : Dense (pi I s)
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfp_eq_self {f : Ordinal → Ordinal} {a} (h : f a = a) : nfp f a = a
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- For every unbounded operator `f` the submodule `f.domain` is a core of its closure.

Note that we don't require that `f` is closable, due to the definition of the closure. -/
theorem closureHasCore (f : E →ₗ.[R] F) : f.closure.HasCore f.domain
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem hasProd_iff_hasProd {g : γ → α}
    (h₁ : ∀ u : Finset γ, ∃ v : Finset β, ∀ v', v ⊆ v' →
      ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b)
    (h₂ : ∀ v : Finset β, ∃ u : Finset γ, ∀ u', u ⊆ u' →
      ∃ v', v ⊆ v' ∧ ∏ b ∈ v', f b = ∏ x ∈ u', g x) :
    HasProd f a ↔ HasProd g a
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.smul_congr (hs : Balanced 𝕜 A) (h : ‖a‖ = ‖b‖) : a • A = b • A
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem Measurable.inf (hf : Measurable f) (hg : Measurable g) : Measurable fun a => f a ⊓ g a
-- Mathlib/Probability/IdentDistrib.lean
theorem measure_mem_eq (h : IdentDistrib f g μ ν) {s : Set γ} (hs : MeasurableSet s) :
    μ (f ⁻¹' s) = ν (g ⁻¹' s)
-- Mathlib/Data/Finset/Lattice.lean
theorem exists_mem_eq_inf' (f : ι → α) : ∃ i, i ∈ s ∧ s.inf' H f = f i
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
@[simp]
theorem op_unop (S : Subsemiring Rᵐᵒᵖ) : S.unop.op = S
-- Mathlib/Order/Filter/Basic.lean
@[simp]
lemma mem_comk {p : Set α → Prop} {he hmono hunion s} :
    s ∈ comk p he hmono hunion ↔ p sᶜ
-- Mathlib/Data/Set/Image.lean
lemma sigma_mk_preimage_image_eq_self : Sigma.mk i ⁻¹' (Sigma.mk i '' s) = s
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps, norm_cast]
theorem imCLM_coe : ((imCLM : K →L[ℝ] ℝ) : K →ₗ[ℝ] ℝ) = imLm
-- Mathlib/Order/Filter/Archimedean.lean
@[simp]
theorem Rat.comap_cast_atTop [LinearOrderedField R] [Archimedean R] :
    comap ((↑) : ℚ → R) atTop = atTop
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
@[simp]
theorem mem_op {x : Rᵐᵒᵖ} {S : Subsemiring R} : x ∈ S.op ↔ x.unop ∈ S
-- Mathlib/Algebra/Polynomial/GroupRingAction.lean
@[simp]
theorem smul_X (m : M) : (m • X : R[X]) = X
-- Mathlib/Order/Basic.lean
theorem le_iff_eq (h : a ≤ b) : b ≤ a ↔ b = a
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_pos (hx : 1 < x) : 0 < log x
-- Mathlib/Probability/Kernel/Basic.lean
theorem IsMarkovKernel.comapRight (κ : Kernel α β) (hf : MeasurableEmbedding f)
    (hκ : ∀ a, κ a (Set.range f) = 1) : IsMarkovKernel (comapRight κ hf)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- The subgroup generated by a set includes the set. -/
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubgroup` generated by a set includes the set."]
theorem subset_closure : k ⊆ closure k
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem orthonormal_sUnion_of_directed {s : Set (Set E)} (hs : DirectedOn (· ⊆ ·) s)
    (h : ∀ a ∈ s, Orthonormal 𝕜 (fun x => ((x : a) : E))) :
    Orthonormal 𝕜 (fun x => x : ⋃₀ s → E)
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem coe_ne_top : (r : ℝ≥0∞) ≠ ∞
-- Mathlib/Algebra/Order/Interval/Finset.lean
@[simp] lemma map_add_right_Icc (a b c : α) :
    (Icc a b).map (addRightEmbedding c) = Icc (a + c) (b + c)
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem inv_hom_id_apply {X Y : Type u} (f : X ≅ Y) (y : Y) : f.hom (f.inv y) = y
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
/-- The composition `l ∘ f` where `l : F → E` and `f : 𝕜 → F`, has a derivative within a set
equal to the Fréchet derivative of `l` applied to the derivative of `f`. -/
theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
    (hl : HasFDerivWithinAt l l' t y)
    (hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
    HasDerivWithinAt (l ∘ f) (l' f') s x
-- Mathlib/LinearAlgebra/Matrix/Spectrum.lean
/-- **Diagonalization theorem**, **spectral theorem** for matrices; A hermitian matrix can be
diagonalized by a change of basis. For the spectral theorem on linear maps, see
`LinearMap.IsSymmetric.eigenvectorBasis_apply_self_apply`.-/
theorem spectral_theorem :
    A = (eigenvectorUnitary hA : Matrix n n 𝕜) * diagonal (RCLike.ofReal ∘ hA.eigenvalues)
      * (star (eigenvectorUnitary hA : Matrix n n 𝕜))
-- Mathlib/Algebra/MvPolynomial/Rename.lean
theorem rename_eval₂ (g : τ → MvPolynomial σ R) :
    rename k (p.eval₂ C (g ∘ k)) = (rename k p).eval₂ C (rename k ∘ g)
-- Mathlib/Data/Matroid/Closure.lean
lemma not_mem_of_mem_diff_closure (he : e ∈ M.E \ M.closure X) : e ∉ X
-- Mathlib/Analysis/Calculus/Rademacher.lean
/-- If a Lipschitz functions has line derivatives in a dense set of directions, all of them given by
a single continuous linear map `L`, then it admits `L` as Fréchet derivative. -/
theorem hasFderivAt_of_hasLineDerivAt_of_closure {f : E → F}
    (hf : LipschitzWith C f) {s : Set E} (hs : sphere 0 1 ⊆ closure s)
    {L : E →L[ℝ] F} {x : E} (hL : ∀ v ∈ s, HasLineDerivAt ℝ f (L v) x v) :
    HasFDerivAt f L x
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem cof_bsup_le {o : Ordinal} {f : ∀ a < o, Ordinal} :
    (∀ i h, f i h < bsup.{u, u} o f) → cof (bsup.{u, u} o f) ≤ o.card
-- Mathlib/Data/List/EditDistance/Defs.lean
/--
Cost structure for strings, where cost is the length of the token.
-/
@[simps!]
def stringLengthCost : Cost String String ℕ
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem add_apply (f g : CuspForm Γ k) (z : ℍ) : (f + g) z = f z + g z
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
/-- There is a rational power between any two positive elements of an archimedean ordered field. -/
theorem exists_rat_pow_btwn {α : Type*} [LinearOrderedField α] [Archimedean α] (hn : n ≠ 0)
    {x y : α} (h : x < y) (hy : 0 < y) : ∃ q : ℚ, 0 < q ∧ x < (q : α) ^ n ∧ (q : α) ^ n < y
-- Mathlib/Data/Seq/WSeq.lean
theorem head_congr : ∀ {s t : WSeq α}, s ~ʷ t → head s ~ head t
-- Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean
@[simp]
theorem toNonneg_of_nonneg {a : α} (h : 0 ≤ a) : toNonneg a = ⟨a, h⟩
-- Mathlib/Data/List/Zip.lean
theorem map_prod_left_eq_zip {l : List α} (f : α → β) :
    (l.map fun x => (x, f x)) = l.zip (l.map f)
-- Mathlib/Order/RelIso/Basic.lean
/-- `Quotient.out'` as a relation embedding between the lift of a relation and the relation. -/
@[simps]
noncomputable def Quotient.out'RelEmbedding {_ : Setoid α} {r : α → α → Prop}
    (H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂) :
    (fun a b => Quotient.liftOn₂' a b r H) ↪r r
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mul_le_max_of_aleph0_le_left {a b : Cardinal} (h : ℵ₀ ≤ a) : a * b ≤ max a b
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp high]
theorem toFinsupp_C_mul_X_pow (a : R) (n : ℕ) :
    Polynomial.toFinsupp (C a * X ^ n) = Finsupp.single n a
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- `HasFTaylorSeriesUpTo n f p` registers the fact that `p 0 = f` and `p (m+1)` is a
derivative of `p m` for `m < n`, and is continuous for `m ≤ n`. This is a predicate analogous to
`HasFDerivAt` but for higher order derivatives.

Notice that `p` does not sum up to `f` on the diagonal (`FormalMultilinearSeries.sum`), even if
`f` is analytic and `n = ∞`: an addition `1/m!` factor on the `m`th term is necessary for that. -/
structure HasFTaylorSeriesUpTo (n : ℕ∞) (f : E → F) (p : E → FormalMultilinearSeries 𝕜 E F) :
  Prop where
  zero_eq : ∀ x, (p x 0).uncurry0 = f x
  fderiv : ∀ m : ℕ, (m : ℕ∞) < n → ∀ x, HasFDerivAt (fun y => p y m) (p x m.succ).curryLeft x
  cont : ∀ m : ℕ, (m : ℕ∞) ≤ n → Continuous fun x => p x m
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[simp]
theorem zero_oreDiv' (s : S) : (0 : R) /ₒ s = 0
-- Mathlib/Probability/Distributions/Gamma.lean
lemma isProbabilityMeasureGamma {a r : ℝ} (ha : 0 < a) (hr : 0 < r) :
    IsProbabilityMeasure (gammaMeasure a r)
-- Mathlib/Analysis/Convex/Body.lean
protected theorem convex (K : ConvexBody V) : Convex ℝ (K : Set V)
-- Mathlib/Algebra/Regular/Basic.lean
/-- If all multiplications cancel then every element is regular. -/
@[to_additive "If all additions cancel then every element is add-regular."]
theorem IsRegular.all [Mul R] [IsCancelMul R] (g : R) : IsRegular g
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem mul_ediv_cancel_of_emod_eq_zero {a b : Int} (H : a % b = 0) : b * (a / b) = a
-- Mathlib/GroupTheory/DoubleCoset.lean
theorem rel_bot_eq_right_group_rel (H : Subgroup G) :
    (setoid ↑H ↑(⊥ : Subgroup G)).Rel = (QuotientGroup.rightRel H).Rel
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive ofReal_norm_eq_coe_nnnorm]
theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_congr {f g : α → β} (h : f =ᵐ[μ] g) : Integrable f μ ↔ Integrable g μ
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem continuousWithinAt_Ioc_iff_Ioi (h : a < b) :
    ContinuousWithinAt f (Ioc a b) a ↔ ContinuousWithinAt f (Ioi a) a
-- Mathlib/Algebra/Lie/Weights/Killing.lean
/-- If a Lie algebra `L` has non-degenerate Killing form, the only element of a Cartan subalgebra
whose adjoint action on `L` is nilpotent, is the zero element.

Over a perfect field a much stronger result is true, see
`LieAlgebra.IsKilling.isSemisimple_ad_of_mem_isCartanSubalgebra`. -/
lemma eq_zero_of_isNilpotent_ad_of_mem_isCartanSubalgebra {x : L} (hx : x ∈ H)
    (hx' : _root_.IsNilpotent (ad K L x)) : x = 0
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
@[simp] theorem id_map' [Functor m] [LawfulFunctor m] (x : m α) : (fun a => a) <$> x = x
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma differentiable_hurwitzZetaEven_sub_hurwitzZetaEven (a b : UnitAddCircle) :
    Differentiable ℂ (fun s ↦ hurwitzZetaEven a s - hurwitzZetaEven b s)
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerTMul_assoc (A : Matrix l m α) (B : Matrix n p β) (C : Matrix q r γ) :
    reindex (Equiv.prodAssoc l n q) (Equiv.prodAssoc m p r)
        (((A ⊗ₖₜ[R] B) ⊗ₖₜ[R] C).map (TensorProduct.assoc R α β γ)) =
      A ⊗ₖₜ[R] B ⊗ₖₜ[R] C
-- Mathlib/SetTheory/Surreal/Multiplication.lean
theorem Equiv.mul_congr_right (he : y₁ ≈ y₂) : x * y₁ ≈ x * y₂
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem toNFA_evalFrom_match (start : Set σ) :
    M.toNFA.evalFrom (M.εClosure start) = M.evalFrom start
-- Mathlib/Algebra/Group/Semiconj/Defs.lean
/-- The relation “there exists an element that semiconjugates `a` to `b`” on a semigroup
is transitive. -/
@[to_additive "The relation “there exists an element that semiconjugates `a` to `b`” on an additive
semigroup is transitive."]
protected theorem transitive : Transitive fun a b : S ↦ ∃ c, SemiconjBy c a b
-- Mathlib/Order/RelClasses.lean
lemma eq_of_subset_of_not_ssubset [IsAntisymm α (· ⊆ ·)] (hab : a ⊆ b) (hba : ¬ a ⊂ b) : a = b
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPostcomp (f : S ⟶ T.obj Y) (g : Y ⟶ Y') : mk f ⟶ mk (f ≫ T.map g)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive sum_boole_nsmul]
theorem prod_pow_boole [DecidableEq α] (s : Finset α) (f : α → β) (a : α) :
    (∏ x ∈ s, f x ^ ite (a = x) 1 0) = ite (a ∈ s) (f a) 1
-- Mathlib/Data/Matroid/Restrict.lean
theorem restrict_strictRestriction {M : Matroid α} (hR : R ⊂ M.E) : M ↾ R <r M
-- Mathlib/Data/Set/Image.lean
theorem exists_subtype_range_iff {p : range f → Prop} :
    (∃ a : range f, p a) ↔ ∃ i, p ⟨f i, mem_range_self _⟩
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem continuousOn (hf : LipschitzOnWith K f s) : ContinuousOn f s
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem symm_mapsTo : MapsTo e.symm e.target e.source
-- Mathlib/Data/Set/Basic.lean
@[simp] theorem setOf_bot : { _x : α | ⊥ } = ∅
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.mono (h : HasDerivWithinAt f f' t x) (hst : s ⊆ t) :
    HasDerivWithinAt f f' s x
-- Mathlib/Analysis/Analytic/Composition.lean
@[simp]
theorem comp_removeZero (q : FormalMultilinearSeries 𝕜 F G) (p : FormalMultilinearSeries 𝕜 E F) :
    q.comp p.removeZero = q.comp p
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.pow_succ_lt_pow {P : Ideal A} [P_prime : P.IsPrime] (hP : P ≠ ⊥) (i : ℕ) :
    P ^ (i + 1) < P ^ i
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem le_of_lf {x y : PGame} (h : x ⧏ y) (ox : Numeric x) (oy : Numeric y) : x ≤ y
-- Mathlib/Algebra/GCDMonoid/Basic.lean
lemma gcd_neg' [GCDMonoid α] {a b : α} : Associated (gcd a (-b)) (gcd a b)
-- Mathlib/RingTheory/Valuation/Basic.lean
/-- If `v` is a valuation on a division ring then `v(x) = 0` iff `x = 0`. -/
-- @[simp] Porting note (#10618): simp can prove this
theorem zero_iff [Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K} : v x = 0 ↔ x = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_nonneg_of_mem_Icc {x : ℝ} (hx : x ∈ Icc (-(π / 2)) (π / 2)) : 0 ≤ cos x
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
lemma W.isLocallyInjective (hf : J.W f) : Presheaf.IsLocallyInjective J f
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x
-- Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean
theorem contDiffAt_log {x : ℂ} (h : x ∈ slitPlane) {n : ℕ∞} : ContDiffAt ℂ n log x
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
protected theorem repr_symm_single (b : HilbertBasis ι 𝕜 E) (i : ι) :
    b.repr.symm (lp.single 2 i (1 : 𝕜)) = b i
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem Kernel.indep_limsup_atTop_self (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s κ μα) :
    Indep (limsup s atTop) (limsup s atTop) κ μα