ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem le_sin_mul {x : ℝ} (hx : 0 ≤ x) (hx' : x ≤ 1) : x ≤ sin (π / 2 * x)
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ico_Iio {a b : α} (c : Ico a b) : Subtype.val '' Iio c = Ico a c
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem erase_of_not_mem_support {f : α →₀ M} {a} (haf : a ∉ f.support) : erase a f = f
-- Mathlib/Analysis/Calculus/LineDeriv/IntegrationByParts.lean
/-- **Integration by parts for line derivatives**
Version with a general bilinear form `B`.
If `B f g` is integrable, as well as `B f' g` and `B f g'` where `f'` and `g'` are derivatives
of `f` and `g` in a given direction `v`, then `∫ B f g' = - ∫ B f' g`. -/
theorem integral_bilinear_hasLineDerivAt_right_eq_neg_left_of_integrable
    {f f' : E → F} {g g' : E → G} {v : E} {B : F →L[ℝ] G →L[ℝ] W}
    (hf'g : Integrable (fun x ↦ B (f' x) (g x)) μ) (hfg' : Integrable (fun x ↦ B (f x) (g' x)) μ)
    (hfg : Integrable (fun x ↦ B (f x) (g x)) μ)
    (hf : ∀ x, HasLineDerivAt ℝ f (f' x) x v) (hg : ∀ x, HasLineDerivAt ℝ g (g' x) x v) :
    ∫ x, B (f x) (g' x) ∂μ = - ∫ x, B (f' x) (g x) ∂μ
-- Mathlib/Order/Fin/Basic.lean
@[simp]
lemma symm_castOrderIso (h : n = m) : (castOrderIso h).symm = castOrderIso h.symm
-- Mathlib/Algebra/Homology/Homotopy.lean
/-- An additive functor takes homotopies to homotopies. -/
@[simps]
def Functor.mapHomotopy (F : V ⥤ W) [F.Additive] {f g : C ⟶ D} (h : Homotopy f g) :
    Homotopy ((F.mapHomologicalComplex c).map f) ((F.mapHomologicalComplex c).map g)
-- Mathlib/Data/Rat/Lemmas.lean
@[norm_cast, simp]
theorem isSquare_intCast_iff {z : ℤ} : IsSquare (z : ℚ) ↔ IsSquare z
-- Mathlib/NumberTheory/Cyclotomic/Embeddings.lean
/-- If `K` is a `n`-th cyclotomic extension of `ℚ`, then there are `φ n / n` complex places
of `K`. Note that this uses `1 / 2 = 0` in the cases `n = 1, 2`. -/
theorem nrComplexPlaces_eq_totient_div_two [h : IsCyclotomicExtension {n} ℚ K] :
    haveI := IsCyclotomicExtension.numberField {n} ℚ K
    NrComplexPlaces K = φ n / 2
-- Mathlib/Data/Set/Function.lean
@[simp]
lemma graphOn_singleton (f : α → β) (x : α) : graphOn f {x} = {(x, f x)}
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem eq_false_imp_eq_true : ∀(b:Bool), (b = false → b = true) ↔ (b = true)
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
theorem one_def : (1 : X ≃ᵈ X) = refl X
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
theorem sum_lt {α : Type*} {F : α → ℚ} {t : ℚ} {s : Finset α} :
    s.Nonempty → (∀ i ∈ s, padicNorm p (F i) < t) → padicNorm p (∑ i ∈ s, F i) < t
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem max_const (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => max (f x) a
-- Mathlib/Data/List/Basic.lean
theorem indexOf_append_of_mem {a : α} (h : a ∈ l₁) : indexOf a (l₁ ++ l₂) = indexOf a l₁
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.mul_dvd_of_right_isPrimal (H : IsRelPrime x y) (H1 : x ∣ z) (H2 : y ∣ z)
    (hy : IsPrimal y) : x * y ∣ z
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem zero_apply (a : α) : (0 : CentroidHom α) a = 0
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le_of_sub_one_lt {a b : Int} (H : a - 1 < b) : a ≤ b
-- Mathlib/Tactic/ComputeDegree.lean
theorem degree_smul_le_of_le {n : ℕ} {a : R} {f : R[X]} (hf : degree f ≤ n) :
    degree (a • f) ≤ n
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
/-- The antipodal map is smooth. -/
theorem contMDiff_neg_sphere {n : ℕ} [Fact (finrank ℝ E = n + 1)] :
    ContMDiff (𝓡 n) (𝓡 n) ∞ fun x : sphere (0 : E) 1 => -x
-- Mathlib/Data/Finset/Card.lean
theorem List.toFinset_card_le : l.toFinset.card ≤ l.length
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem contMDiffAt_proj {p : TotalSpace F E} : ContMDiffAt (IB.prod 𝓘(𝕜, F)) IB n (π F E) p
-- Mathlib/Algebra/Module/CharacterModule.lean
@[ext] theorem ext {c c' : CharacterModule A} (h : ∀ x, c x = c' x) : c = c'
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem preimage_mul_left_one : (a * ·) ⁻¹' 1 = {a⁻¹}
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem unitOfDetInvertible_eq_nonsingInvUnit [Invertible A.det] :
    unitOfDetInvertible A = nonsingInvUnit A (isUnit_of_invertible _)
-- Mathlib/RingTheory/Filtration.lean
/-- If the components of a filtration are finitely generated, then the filtration is stable iff
its associated submodule of is finitely generated. -/
theorem submodule_fg_iff_stable (hF' : ∀ i, (F.N i).FG) : F.submodule.FG ↔ F.Stable
-- Mathlib/Topology/Inseparable.lean
theorem preimage_mk_frontier : mk ⁻¹' frontier t = frontier (mk ⁻¹' t)
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma BoundaryLE.false_of_isTruncGE {j : ι} (hj : e.BoundaryLE j) [e.IsTruncGE] : False
-- Mathlib/Data/Stream/Init.lean
theorem inits_core_eq (l : List α) (s : Stream' α) :
    initsCore l s = l::initsCore (l ++ [head s]) (tail s)
-- Mathlib/LinearAlgebra/Span.lean
theorem map_le_map_iff' {f : F} (hf : ker f = ⊥) {p p'} : map f p ≤ map f p' ↔ p ≤ p'
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem continuous_snd : Continuous (@Prod.snd X Y)
-- Mathlib/Logic/Function/Basic.lean
theorem injective_of_isPartialInv {α β} {f : α → β} {g} (H : IsPartialInv f g) :
    Injective f
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Icc_coe_coe : Icc (a : WithBot α) b = (Icc a b).map Embedding.some
-- Mathlib/Order/Heyting/Regular.lean
@[simp]
theorem coe_inj {a b : Regular α} : (a : α) = b ↔ a = b
-- Mathlib/Logic/Lemmas.lean
theorem ite_dite_distrib_left {a : α} {b : q → α} {c : ¬q → α} :
    ite p a (dite q b c) = dite q (fun hq ↦ ite p a <| b hq) fun hq ↦ ite p a <| c hq
-- Mathlib/Algebra/Lie/Abelian.lean
theorem Function.Surjective.isLieAbelian {R : Type u} {L₁ : Type v} {L₂ : Type w} [CommRing R]
    [LieRing L₁] [LieRing L₂] [LieAlgebra R L₁] [LieAlgebra R L₂] {f : L₁ →ₗ⁅R⁆ L₂}
    (h₁ : Function.Surjective f) (h₂ : IsLieAbelian L₁) : IsLieAbelian L₂
-- Mathlib/RingTheory/Congruence/Basic.lean
/-- Definition of the infimum of two congruence relations. -/
theorem inf_iff_and {c d : RingCon R} {x y} : (c ⊓ d) x y ↔ c x y ∧ d x y
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem covariant_lt_of_covariant_le_of_contravariant_eq [ContravariantClass M N μ (· = ·)]
    [PartialOrder N] [CovariantClass M N μ (· ≤ ·)] : CovariantClass M N μ (· < ·)
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive]
theorem mk'_eq_mk' {x y : G} : mk' N x = mk' N y ↔ ∃ z ∈ N, x * z = y
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma toENat_eq_zero {a : Cardinal} : toENat a = 0 ↔ a = 0
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem monic_restriction {p : R[X]} : Monic (restriction p) ↔ Monic p
-- Mathlib/Algebra/Order/CompleteField.lean
theorem lt_inducedMap_iff : b < inducedMap α β a ↔ ∃ q : ℚ, b < q ∧ (q : α) < a
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem eq_tsub_iff_add_eq_of_le (hc : AddLECancellable c) (h : c ≤ b) :
    a = b - c ↔ a + c = b
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_nonneg_iff : 0 ≤ a • b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- If `w` is a nontorsion weight function, then a multivariate polynomial has weighted total
  degree zero if and only if for every `m ∈ p.support` and `x : σ`, `m x = 0`. -/
theorem weightedTotalDegree_eq_zero_iff (hw : NonTorsionWeight w) (p : MvPolynomial σ R) :
    p.weightedTotalDegree w = 0 ↔ ∀ (m : σ →₀ ℕ) (_ : m ∈ p.support) (x : σ), m x = 0
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_add_eq_add_tsub (h : b ≤ a) : a - b + c = a + c - b
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- An uncurried version of `Finset.prod_product`. -/
@[to_additive "An uncurried version of `Finset.sum_product`"]
theorem prod_product' {s : Finset γ} {t : Finset α} {f : γ → α → β} :
    ∏ x ∈ s ×ˢ t, f x.1 x.2 = ∏ x ∈ s, ∏ y ∈ t, f x y
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp] lemma pow_addRight (n : ℕ) : Equiv.addRight a ^ n = Equiv.addRight (n • a)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- In a preadditive category, if the coproduct over `f : J → C` exists,
    then the biproduct over `f` exists. -/
theorem HasBiproduct.of_hasCoproduct (f : J → C) [HasCoproduct f] : HasBiproduct f
-- Mathlib/Data/Set/Basic.lean
theorem subset_eq_empty {s t : Set α} (h : t ⊆ s) (e : s = ∅) : t = ∅
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
theorem eval_apply (n : ℕ) (f : AdicCompletion I M) : eval I M n f = f.1 n
-- Mathlib/RingTheory/RootsOfUnity/Minpoly.lean
/-- If `m : ℕ` is coprime with `n`,
then the minimal polynomial of a primitive `n`-th root of unity `μ`
has `μ ^ m` as root. -/
theorem pow_isRoot_minpoly {m : ℕ} (hcop : Nat.Coprime m n) :
    IsRoot (map (Int.castRingHom K) (minpoly ℤ μ)) (μ ^ m)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- The `sSup` of a non-empty set is its least upper bound for a conditionally
complete lattice with a top. -/
theorem isLUB_sSup' {β : Type*} [ConditionallyCompleteLattice β] {s : Set (WithTop β)}
    (hs : s.Nonempty) : IsLUB s (sSup s)
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_of_linearEquiv (e : M ≃ₗ[R] P) (h : (⊤ : Submodule R P).FG) : (⊤ : Submodule R M).FG
-- Mathlib/Algebra/Module/DedekindDomain.lean
/-- A finitely generated torsion module over a Dedekind domain is an internal direct sum of its
`p i ^ e i`-torsion submodules for some prime ideals `p i` and numbers `e i`. -/
theorem exists_isInternal_prime_power_torsion [Module.Finite R M] (hM : Module.IsTorsion R M) :
    ∃ (P : Finset <| Ideal R) (_ : DecidableEq P) (_ : ∀ p ∈ P, Prime p) (e : P → ℕ),
      DirectSum.IsInternal fun p : P => torsionBySet R M (p ^ e p : Ideal R)
-- Mathlib/RingTheory/PowerBasis.lean
theorem constr_pow_mul (pb : PowerBasis A S) {y : S'} (hy : aeval y (minpoly A pb.gen) = 0)
    (x x' : S) : pb.basis.constr A (fun i => y ^ (i : ℕ)) (x * x') =
      pb.basis.constr A (fun i => y ^ (i : ℕ)) x * pb.basis.constr A (fun i => y ^ (i : ℕ)) x'
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
@[simp]
theorem map_eq_zero [Semiring S] [Nontrivial S] (f : R →+* S) : p.map f = 0 ↔ p = 0
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_apply_getElem (xs : List α) (w : Nodup xs) (i : Nat) (h : i < xs.length) :
    formPerm xs xs[i] =
      xs[(i + 1) % xs.length]'(Nat.mod_lt _ (i.zero_le.trans_lt h))
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp] theorem congr_toLinearEquiv (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) :
    (Algebra.TensorProduct.congr f g).toLinearEquiv =
      TensorProduct.AlgebraTensorModule.congr f.toLinearEquiv g.toLinearEquiv
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_self_le_mul_self {a b : Int} (h1 : 0 ≤ a) (h2 : a ≤ b) : a * a ≤ b * b
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
theorem id_app {X : Scheme} (U : X.Opens) :
    (𝟙 X : _).app U = 𝟙 _
-- Mathlib/Algebra/Lie/Submodule.lean
theorem coe_injective : Function.Injective ((↑) : LieSubmodule R L M → Set M)
-- Mathlib/Logic/Basic.lean
theorem or_congr_right' {c : Prop} (h : ¬a → (b ↔ c)) : a ∨ b ↔ a ∨ c
-- Mathlib/Data/Finset/Sigma.lean
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem sigma_nonempty : (s.sigma t).Nonempty ↔ ∃ i ∈ s, (t i).Nonempty
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem nextn : ∀ {s}, ValidFor l (m₁ ++ m₂) r s →
    ∀ n, s.nextn n ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + utf8Len (m₂.take n)⟩
-- Mathlib/Order/BooleanAlgebra.lean
private theorem sdiff_sup_self' : y \ x ⊔ x = y ⊔ x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side, version subtracting vectors. -/
theorem norm_div_tan_oangle_sub_left_of_oangle_eq_pi_div_two {x y : V}
    (h : o.oangle x y = ↑(π / 2)) : ‖y‖ / Real.Angle.tan (o.oangle (x - y) x) = ‖x‖
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- The averaging of a uniformly integrable sequence is also uniformly integrable. -/
theorem uniformIntegrable_average
    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (hp : 1 ≤ p) {f : ℕ → α → E} (hf : UniformIntegrable f p μ) :
    UniformIntegrable (fun (n : ℕ) => (n : ℝ)⁻¹ • (∑ i ∈ Finset.range n, f i)) p μ
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_eq_one_iff_of_le_one (hf : f ≤ 1) : ∏ i, f i = 1 ↔ f = 1
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
@[to_additive minimalPeriod_eq_one_iff_fixedBy]
theorem minimalPeriod_eq_one_iff_fixedBy {a : α} {g : G} :
    Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ fixedBy α g
-- Mathlib/Order/Heyting/Basic.lean
@[simp] theorem lt_compl_self [Nontrivial α] : a < aᶜ ↔ a = ⊥
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem mem_one : a ∈ (1 : Finset α) ↔ a = 1
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- Swapping the factors of a cartesian product of categories twice is naturally isomorphic
to the identity functor.
-/
@[simps]
def symmetry : swap C D ⋙ swap D C ≅ 𝟭 (C × D)
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem splitOnP_nil : [].splitOnP p = [[]]
-- Mathlib/Topology/Defs/Induced.lean
/-- A closed embedding is an embedding with closed image. -/
@[mk_iff]
structure ClosedEmbedding (f : X → Y) extends Embedding f : Prop where
  /-- The range of a closed embedding is a closed set. -/
  isClosed_range : IsClosed <| range f
-- Mathlib/GroupTheory/FixedPointFree.lean
theorem odd_card_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) :
    Odd (Nat.card G)
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a positive constant, `x ↦ f x / r` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter. -/
lemma tendsto_div_const_atTop_of_pos (hr : 0 < r) :
    Tendsto (fun x ↦ f x / r) l atTop ↔ Tendsto f l atTop
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem toFun_eq_coe : f.toFun = ⇑f
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[ext]
theorem ext {f g : A →⋆ₐ[R] B} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem ofInjective_apply (f : A →ₐ[R] B) (hf : Function.Injective f) (x : A) :
    ↑(ofInjective f hf x) = f x
-- Mathlib/Data/Fin/Basic.lean
theorem succ_castPred_eq_add_one {a : Fin (n + 1)} (ha : a ≠ last n) :
    (a.castPred ha).succ = a + 1
-- Mathlib/GroupTheory/Congruence/Basic.lean
@[to_additive (attr := simp)]
-- Porting note: removed dot notation
theorem mrange_mk' : MonoidHom.mrange c.mk' = ⊤
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_def_of_nonneg {x : ℝ} (hx : 0 ≤ x) (y : ℝ) :
    x ^ y = if x = 0 then if y = 0 then 1 else 0 else exp (log x * y)
-- Mathlib/CategoryTheory/Skeletal.lean
/-- `IsSkeletonOf C D F` says that `F : D ⥤ C` exhibits `D` as a skeletal full subcategory of `C`,
in particular `F` is a (strong) equivalence and `D` is skeletal.
-/
structure IsSkeletonOf (F : D ⥤ C) : Prop where
  /-- The category `D` has isomorphic objects equal -/
  skel : Skeletal D
  /-- The functor `F` is an equivalence -/
  eqv : F.IsEquivalence := by infer_instance
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem prime_three : Prime (3 : ℤ)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem inv_unique (hy : x * y = 1) (hz : x * z = 1) : y = z
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[simp, measurability]
theorem measurableSet_Iio : MeasurableSet (Iio a)
-- Mathlib/Analysis/Convex/Strict.lean
/-- The preimage of a strictly convex set under an affine map is strictly convex. -/
theorem StrictConvex.affine_preimage {s : Set F} (hs : StrictConvex 𝕜 s) {f : E →ᵃ[𝕜] F}
    (hf : Continuous f) (hfinj : Injective f) : StrictConvex 𝕜 (f ⁻¹' s)
-- Mathlib/NumberTheory/Dioph.lean
theorem pell_dioph :
    Dioph fun v : Vector3 ℕ 4 => ∃ h : 1 < v &0, xn h (v &1) = v &2 ∧ yn h (v &1) = v &3
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem coe_prodCongr (h₁ : M ≃ₘ^n⟮I, I'⟯ M') (h₂ : N ≃ₘ^n⟮J, J'⟯ N') :
    ⇑(h₁.prodCongr h₂) = Prod.map h₁ h₂
-- Mathlib/Init/Logic.lean
theorem iff_self_iff (a : Prop) : (a ↔ a) ↔ True
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
/-- Dropping the elements up to `l₁.length + i` in `l₁ + l₂` is the same as dropping the elements
up to `i` in `l₂`. -/
@[simp]
theorem drop_append {l₁ l₂ : List α} (i : Nat) : drop (l₁.length + i) (l₁ ++ l₂) = drop i l₂
-- Mathlib/Order/Monotone/Monovary.lean
theorem Antivary.comp_right (h : Antivary f g) (k : ι' → ι) : Antivary (f ∘ k) (g ∘ k)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
theorem _root_.List.aestronglyMeasurable_prod
    (l : List (α → M)) (hl : ∀ f ∈ l, AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun x => (l.map fun f : α → M => f x).prod) μ
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[elab_as_elim]
protected theorem inductionOn₃
    {s₃ : Setoid φ}
    {motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop}
    (q₁ : Quotient s₁)
    (q₂ : Quotient s₂)
    (q₃ : Quotient s₃)
    (h : (a : α) → (b : β) → (c : φ) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c))
    : motive q₁ q₂ q₃
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tendsto_const_div_atTop_nhds_zero_nat (C : ℝ) :
    Tendsto (fun n : ℕ ↦ C / n) atTop (𝓝 0)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_self_nonneg {x : F} : 0 ≤ ⟪x, x⟫_ℝ
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
theorem pos_of_pos (h : 0 < x) : 0 < smoothTransition x
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem typein_lt_type (r : α → α → Prop) [IsWellOrder α r] (a : α) : typein r a < type r
-- Mathlib/Data/ZMod/Basic.lean
lemma intCast_cast_add (x y : ZMod n) : (cast (x + y) : ℤ) = (cast x + cast y) % n
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem le_insertNth_iff {i : Fin (n + 1)} {x : α i} {p : ∀ j, α (i.succAbove j)} {q : ∀ j, α j} :
    q ≤ i.insertNth x p ↔ q i ≤ x ∧ (fun j ↦ q (i.succAbove j)) ≤ p
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem degree_eq_card_roots' {p : K[X]} {i : K →+* L} (p_ne_zero : p.map i ≠ 0)
    (hsplit : Splits i p) : (p.map i).degree = Multiset.card (p.map i).roots
-- Mathlib/Data/List/Basic.lean
theorem foldl_assoc : ∀ {l : List α} {a₁ a₂}, (l <*> a₁ ⋆ a₂) = a₁ ⋆ l <*> a₂
-- Mathlib/Order/Booleanisation.lean
@[simp] lemma lift_sdiff_comp (a b : α) : lift a \ comp b = lift (a ⊓ b)
-- Mathlib/Data/Sign.lean
@[simp]
theorem coe_neg_one : ↑(-1 : SignType) = (-1 : α)
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem normSq_conj (z : K) : normSq (conj z) = normSq z
-- Mathlib/Topology/Instances/NNReal.lean
nonrec theorem hasSum_nat_add_iff {f : ℕ → ℝ≥0} (k : ℕ) {a : ℝ≥0} :
    HasSum (fun n => f (n + k)) a ↔ HasSum f (a + ∑ i ∈ range k, f i)
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem span_empty : span (∅ : Set α) = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem bind_eq_none' {o : Option α} {f : α → Option β} :
    o.bind f = none ↔ ∀ b a, a ∈ o → b ∉ f a
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem coe_copy (f : FrameHom α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem fst_compl [HasCompl α] [HasCompl β] (a : α × β) : aᶜ.1 = a.1ᶜ
-- Mathlib/RingTheory/Unramified/Basic.lean
theorem of_equiv [FormallyUnramified R A] (e : A ≃ₐ[R] B) :
    FormallyUnramified R B
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
@[simp]
theorem infEdist_thickening (hδ : 0 < δ) (s : Set E) (x : E) :
    infEdist x (thickening δ s) = infEdist x s - ENNReal.ofReal δ
-- Mathlib/Probability/Kernel/Basic.lean
theorem integral_piecewise {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a : α) (g : β → E) :
    ∫ b, g b ∂piecewise hs κ η a = if a ∈ s then ∫ b, g b ∂κ a else ∫ b, g b ∂η a
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem mul_mem_sup {S T : Subalgebra R A} {x y : A} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem coe_of_injective_castLE_symm {n k : ℕ} (h : n ≤ k) (i : Fin k) (hi) :
    ((Equiv.ofInjective _ (castLE_injective h)).symm ⟨i, hi⟩ : ℕ) = i
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem traverse_mul' :
    Function.comp (traverse F) ∘ (HMul.hMul : FreeSemigroup α → FreeSemigroup α → FreeSemigroup α) =
      fun x y ↦ (· * ·) <$> traverse F x <*> traverse F y
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem curry_symm_apply (f : α →o β →o γ) (x : α × β) : curry.symm f x = f x.1 x.2
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem zero_ne_top : 0 ≠ ∞
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem continuousAt_log (hx : x ≠ 0) : ContinuousAt log x
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem mem_extChartAt_ind_source (x : M) (hx : x ∈ s) :
    x ∈ (extChartAt I (fs.c (fs.ind x hx))).source
-- Mathlib/CategoryTheory/Monoidal/Mod_.lean
/-- A morphism of module objects. -/
@[ext]
structure Hom (M N : Mod_ A) where
  hom : M.X ⟶ N.X
  act_hom : M.act ≫ hom = (A.X ◁ hom) ≫ N.act := by aesop_cat
-- .lake/packages/batteries/Batteries/Data/LazyList.lean
@[simp]
theorem mem_cons {α} (x y : α) (ys : Thunk (LazyList α)) :
    x ∈ @LazyList.cons α y ys ↔ x = y ∨ x ∈ ys.get
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_inter_add_diff (ht : MeasurableSet t) (hfs : IntegrableOn f s μ) :
    ∫ x in s ∩ t, f x ∂μ + ∫ x in s \ t, f x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Analysis/Complex/OpenMapping.lean
/-- The *open mapping theorem* for holomorphic functions, local version: is a function `g : E → ℂ`
is analytic at a point `z₀`, then either it is constant in a neighborhood of `z₀`, or it maps every
neighborhood of `z₀` to a neighborhood of `z₀`. For the particular case of a holomorphic function on
`ℂ`, see `AnalyticAt.eventually_constant_or_nhds_le_map_nhds_aux`. -/
theorem AnalyticAt.eventually_constant_or_nhds_le_map_nhds {z₀ : E} (hg : AnalyticAt ℂ g z₀) :
    (∀ᶠ z in 𝓝 z₀, g z = g z₀) ∨ 𝓝 (g z₀) ≤ map g (𝓝 z₀)
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem smooth_finset_prod' (h : ∀ i ∈ t, Smooth I' I (f i)) : Smooth I' I (∏ i ∈ t, f i)
-- Mathlib/Algebra/Algebra/Tower.lean
theorem smul_mem_span_smul' {s : Set S} (hs : span R s = ⊤) {t : Set A} {k : S} {x : A}
    (hx : x ∈ span R (s • t)) : k • x ∈ span R (s • t)
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem finite_Ici : (Ici a).Finite
-- Mathlib/Algebra/Divisibility/Units.lean
/-- Units of a monoid divide any element of the monoid. -/
@[simp]
theorem dvd (hu : IsUnit u) : u ∣ a
-- Mathlib/Data/Quot.lean
@[elab_as_elim]
theorem Quotient.induction_on_pi {ι : Type*} {α : ι → Sort*} [s : ∀ i, Setoid (α i)]
    {p : (∀ i, Quotient (s i)) → Prop} (f : ∀ i, Quotient (s i))
    (h : ∀ a : ∀ i, α i, p fun i ↦ ⟦a i⟧) : p f
-- Mathlib/GroupTheory/GroupAction/Group.lean
theorem smul_ne_zero_iff_ne (a : α) {x : β} : a • x ≠ 0 ↔ x ≠ 0
-- Mathlib/NumberTheory/ADEInequality.lean
theorem admissible_A' (q r : ℕ+) : Admissible (A' q r)
-- Mathlib/Computability/Primrec.lean
theorem sum_casesOn {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ → σ} (hf : Primrec f)
    (hg : Primrec₂ g) (hh : Primrec₂ h) : @Primrec _ σ _ _ fun a => Sum.casesOn (f a) (g a) (h a)
-- Mathlib/Probability/Kernel/MeasureCompProd.lean
lemma compProd_of_not_isSFiniteKernel (μ : Measure α) (κ : Kernel α β) (h : ¬ IsSFiniteKernel κ) :
    μ ⊗ₘ κ = 0
-- Mathlib/LinearAlgebra/Basis.lean
theorem apply_eq_iff {b : Basis ι R M} {x : M} {i : ι} : b i = x ↔ b.repr x = Finsupp.single i 1
-- Mathlib/Algebra/Star/Pointwise.lean
protected theorem star_inv' [DivisionSemiring α] [StarRing α] (s : Set α) : s⁻¹⋆ = s⋆⁻¹
-- Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean
private lemma filter_pairs_lt (k : ℕ) :
    (pairs σ k).filter (fun (s, _) ↦ s.card < k) =
      (range k).disjiUnion (powersetCard · univ) ((pairwise_disjoint_powersetCard _).set_pairwise _)
        ×ˢ univ
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean
@[simp]
theorem colimitPresheafObjIsoComponentwiseLimit_inv_ι_app (F : J ⥤ PresheafedSpace.{_, _, v} C)
    (U : Opens (Limits.colimit F).carrier) (j : J) :
    (colimitPresheafObjIsoComponentwiseLimit F U).inv ≫ (colimit.ι F j).c.app (op U) =
      limit.π _ (op j)