ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/RelSeries.lean
@[simp] lemma last_smash {p q : RelSeries r} (h : p.last = q.head) :
    (smash p q h).last = q.last
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_toMulHom (f : α →ₙ+* β) : ⇑f.toMulHom = f
-- Mathlib/Algebra/Group/Conj.lean
theorem forall_isConj {p : ConjClasses α → Prop} : (∀ a, p a) ↔ ∀ a, p (ConjClasses.mk a)
-- Mathlib/Data/Set/Pairwise/Basic.lean
protected theorem Pairwise.image {s : Set ι} (h : s.Pairwise (r on f)) : (f '' s).Pairwise r
-- Mathlib/RingTheory/Ideal/Over.lean
theorem comap_ne_bot_of_root_mem [IsDomain S] {r : S} (r_ne_zero : r ≠ 0) (hr : r ∈ I) {p : R[X]}
    (p_ne_zero : p ≠ 0) (hp : p.eval₂ f r = 0) : I.comap f ≠ ⊥
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem Finset.sum_apply' : (∑ k ∈ s, f k) i = ∑ k ∈ s, f k i
-- Mathlib/RingTheory/Localization/Module.lean
@[simp]
theorem Basis.localizationLocalization_apply {ι : Type*} (b : Basis ι R A) (i) :
    b.localizationLocalization Rₛ S Aₛ i = algebraMap A Aₛ (b i)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem eq_zero_of_tgt {X Y : C} (o : IsZero Y) (f : X ⟶ Y) : f = 0
-- Mathlib/Logic/Nontrivial/Basic.lean
/-- A pi type is nontrivial if it's nonempty everywhere and nontrivial somewhere. -/
theorem nontrivial_at (i' : I) [inst : ∀ i, Nonempty (f i)] [Nontrivial (f i')] :
    Nontrivial (∀ i : I, f i)
-- Mathlib/RingTheory/Bialgebra/Hom.lean
theorem coe_fn_inj {φ₁ φ₂ : A →ₐc[R] B} : (φ₁ : A → B) = φ₂ ↔ φ₁ = φ₂
-- Mathlib/Order/Interval/Finset/Nat.lean
@[simp]
theorem Ico_zero_eq_range : Ico 0 = range
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem snd_apply (p : Submodule R E) (p' : Submodule R F) (x : p.prod p') :
    LinearPMap.snd p p' x = (x : E × F).2
-- Mathlib/Order/Interval/Set/Infinite.lean
theorem Ico_infinite : (Ico a b).Infinite
-- Mathlib/CategoryTheory/Abelian/EpiWithInjectiveKernel.lean
/-- A morphism `g : X ⟶ Y` is epi with an injective kernel iff there exists a morphism
`f : I ⟶ X` with `I` injective such that `f ≫ g = 0` and
the short complex `I ⟶ X ⟶ Y` has a splitting. -/
lemma epiWithInjectiveKernel_iff {X Y : C} (g : X ⟶ Y) :
    epiWithInjectiveKernel g ↔ ∃ (I : C) (_ : Injective I) (f : I ⟶ X) (w : f ≫ g = 0),
      Nonempty (ShortComplex.mk f g w).Splitting
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem top_himp : ⊤ ⇨ a = a
-- Mathlib/Data/Real/EReal.lean
lemma bot_mul_of_neg {x : EReal} (h : x < 0) : ⊥ * x = ⊤
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem mapAccumr_cons :
    mapAccumr f (x ::ᵥ xs) s
    = let r := mapAccumr f xs s
      let q := f x r.1
      (q.1, q.2 ::ᵥ r.2)
-- Mathlib/Data/Set/Basic.lean
theorem diff_eq_empty {s t : Set α} : s \ t = ∅ ↔ s ⊆ t
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- Subtracting a point in the given subspace from the
`orthogonalProjection` produces a result in the direction of the
given subspace. -/
theorem orthogonalProjection_vsub_mem_direction {s : AffineSubspace ℝ P} [Nonempty s]
    [HasOrthogonalProjection s.direction] {p1 : P} (p2 : P) (hp1 : p1 ∈ s) :
    ↑(orthogonalProjection s p2 -ᵥ ⟨p1, hp1⟩ : s.direction) ∈ s.direction
-- Mathlib/Data/List/Rotate.lean
@[refl]
theorem IsRotated.refl (l : List α) : l ~r l
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
theorem basis_toMatrix_basisFun_mul (b : Basis ι R (ι → R)) (A : Matrix ι ι R) :
    b.toMatrix (Pi.basisFun R ι) * A = of fun i j => b.repr (Aᵀ j) i
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem HasFDerivAtFilter.isBigO_sub (h : HasFDerivAtFilter f f' x L) :
    (fun x' => f x' - f x) =O[L] fun x' => x' - x
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
lemma Spec.map_inj : Spec.map φ = Spec.map ψ ↔ φ = ψ
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem valMinAbs_def_zero (x : ZMod 0) : valMinAbs x = x
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem dropFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) :
    dropFun (f₁ ⊚ f₀) = dropFun f₁ ⊚ dropFun f₀
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
@[simp] theorem ite_some_none_eq_some [Decidable P] :
    (if P then some x else none) = some y ↔ P ∧ x = y
-- Mathlib/Logic/Basic.lean
theorem Eq.rec_eq_cast {α : Sort _} {P : α → Sort _} {x y : α} (h : x = y) (z : P x) :
    h ▸ z = cast (congr_arg P h) z
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.mono (hf : HasFiniteFPowerSeriesOnBall f p x n r)
    (r'_pos : 0 < r') (hr : r' ≤ r) : HasFiniteFPowerSeriesOnBall f p x n r'
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- If `C` is cofiltered, then we can give an explicit condition for a functor `F : C ⥤ D` to
    be initial. -/
theorem Functor.initial_iff_of_isCofiltered [IsCofilteredOrEmpty C] :
    Initial F ↔ (∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) ∧ (∀ {d : D} {c : C} (s s' : F.obj c ⟶ d),
      ∃ (c' : C) (t : c' ⟶ c), F.map t ≫ s = F.map t ≫ s')
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_natCast (n : ℕ) : fract (n : α) = 0
-- Mathlib/Data/Nat/Choose/Factorization.lean
/-- Primes greater than about `2 * n / 3` and less than `n` do not appear in the factorization of
`centralBinom n`. -/
theorem factorization_centralBinom_of_two_mul_self_lt_three_mul (n_big : 2 < n) (p_le_n : p ≤ n)
    (big : 2 * n < 3 * p) : (centralBinom n).factorization p = 0
-- Mathlib/Order/Filter/CountableInter.lean
/-- A filter `l` has the countable intersection property if for any countable collection
of sets `s ∈ l` their intersection belongs to `l` as well. -/
class CountableInterFilter (l : Filter α) : Prop where
  /-- For a countable collection of sets `s ∈ l`, their intersection belongs to `l` as well. -/
  countable_sInter_mem : ∀ S : Set (Set α), S.Countable → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem lowerClosure_univ : lowerClosure (univ : Set α) = ⊤
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem tsupport_fderiv_subset : tsupport (fderiv 𝕜 f) ⊆ tsupport f
-- Mathlib/FieldTheory/IntermediateField.lean
theorem natCast_mem (n : ℕ) : (n : L) ∈ S
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le.dest_sub {a b : Int} (h : a ≤ b) : ∃ n : Nat, b - a = n
-- Mathlib/Data/Set/Image.lean
theorem range_eq_empty [IsEmpty ι] (f : ι → α) : range f = ∅
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[ext]
theorem ext {f g : X →ₑ[φ] Y} :
    (∀ x, f x = g x) → f = g
-- Mathlib/RingTheory/Jacobson.lean
private theorem quotient_mk_comp_C_isIntegral_of_jacobson' {R : Type*} [CommRing R] [IsJacobson R]
    (P : Ideal (MvPolynomial (Fin n) R)) (hP : P.IsMaximal) :
    RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P))
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem coeff_contract {p : ℕ} (hp : p ≠ 0) (f : R[X]) (n : ℕ) :
    (contract p f).coeff n = f.coeff (n * p)
-- Mathlib/FieldTheory/Finite/Basic.lean
@[simp]
theorem pow_card_pow {n p : ℕ} [Fact p.Prime] (x : ZMod p) : x ^ p ^ n = x
-- Mathlib/Data/Sigma/Basic.lean
@[simp]
theorem elim_val {γ} (f : ∀ a, β a → γ) (a b) : PSigma.elim f ⟨a, b⟩ = f a b
-- Mathlib/Order/Filter/Prod.lean
theorem inf_prod {f₁ f₂ : Filter α} : (f₁ ⊓ f₂) ×ˢ g = (f₁ ×ˢ g) ⊓ (f₂ ×ˢ g)
-- Mathlib/Probability/Independence/Conditional.lean
@[symm]
theorem CondIndep.symm {m' m₁ m₂ : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω}
    [StandardBorelSpace Ω] [Nonempty Ω] {hm' : m' ≤ mΩ} {μ : Measure Ω} [IsFiniteMeasure μ]
    (h : CondIndep m' m₁ m₂ hm' μ) :
    CondIndep m' m₂ m₁ hm' μ
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem exists_lt_norm (r : ℝ) : ∃ x : α, r < ‖x‖
-- Mathlib/Order/Filter/Basic.lean
theorem comap_surjective_eq_bot {f : Filter β} {m : α → β} (hm : Surjective m) :
    comap m f = ⊥ ↔ f = ⊥
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem coe_real_preimage_closedBall_eq_iUnion (x ε : ℝ) :
    (↑) ⁻¹' closedBall (x : AddCircle p) ε = ⋃ z : ℤ, closedBall (x + z • p) ε
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive le_addIndex_mul]
theorem le_index_mul (K₀ : PositiveCompacts G) (K : Compacts G) {V : Set G}
    (hV : (interior V).Nonempty) :
    index (K : Set G) V ≤ index (K : Set G) K₀ * index (K₀ : Set G) V
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem ext' {g h : A ⊗[R] B →ₐ[S] C} (H : ∀ a b, g (a ⊗ₜ b) = h (a ⊗ₜ b)) : g = h
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem pullback_eq_top_iff_mem (f : Y ⟶ X) : S f ↔ S.pullback f = ⊤
-- Mathlib/Computability/TMToPartrec.lean
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S
-- Mathlib/Algebra/DirectLimit.lean
lemma map_comp [IsDirected ι (· ≤ ·)]
    (g₁ : (i : ι) → G i →+* G' i) (g₂ : (i : ι) → G' i →+* G'' i)
    (hg₁ : ∀ i j h, (g₁ j).comp (f i j h) = (f' i j h).comp (g₁ i))
    (hg₂ : ∀ i j h, (g₂ j).comp (f' i j h) = (f'' i j h).comp (g₂ i)) :
    ((map g₂ hg₂).comp (map g₁ hg₁) :
      DirectLimit G (fun _ _ h ↦ f _ _ h) →+* DirectLimit G'' fun _ _ h ↦ f'' _ _ h) =
    (map (fun i ↦ (g₂ i).comp (g₁ i)) fun i j h ↦ by
      rw [RingHom.comp_assoc, hg₁ i, ← RingHom.comp_assoc, hg₂ i, RingHom.comp_assoc] :
      DirectLimit G (fun _ _ h ↦ f _ _ h) →+* DirectLimit G'' fun _ _ h ↦ f'' _ _ h)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc (attr := simp)]
theorem inr_comp_pushoutSymmetry_inv [HasPushout f g] :
    pushout.inr _ _ ≫ (pushoutSymmetry f g).inv = pushout.inl _ _
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem pred_succ (o) : pred (succ o) = o
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem LinearMap.BilinForm.toMatrixAux_apply (B : BilinForm R₂ M₂) (b : n → M₂) (i j : n) :
    -- Porting note: had to hint the base ring even though it should be clear from context...
    BilinForm.toMatrixAux (R₂ := R₂) b B i j = B (b i) (b j)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem coe_rangeRestrict (f : G →* N) (g : G) : (f.rangeRestrict g : N) = f g
-- Mathlib/Order/Hom/Basic.lean
theorem OrderIso.map_bot [LE α] [PartialOrder β] [OrderBot α] [OrderBot β] (f : α ≃o β) : f ⊥ = ⊥
-- Mathlib/Data/String/Basic.lean
theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos) :
    ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ = ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩
-- Mathlib/Analysis/Complex/Basic.lean
theorem norm_int_of_nonneg {n : ℤ} (hn : 0 ≤ n) : ‖(n : ℂ)‖ = n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem foldl_reverse (l : List α) (f : β → α → β) (b) :
    l.reverse.foldl f b = l.foldr (fun x y => f y x) b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addU_of_Z_eq_zero_right {P Q : Fin 3 → F} (hQz : Q z = 0) : addU P Q = 0
-- Mathlib/GroupTheory/Order/Min.lean
@[simp]
lemma minOrder_of_prime {p : ℕ} (hp : p.Prime) : minOrder (ZMod p) = p
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
theorem Submonoid.toAddSubmonoid'_closure (S : Set (Multiplicative A)) :
    Submonoid.toAddSubmonoid' (Submonoid.closure S)
      = AddSubmonoid.closure (Additive.ofMul ⁻¹' S)
-- Mathlib/CategoryTheory/Simple.lean
theorem Simple.not_isZero (X : C) [Simple X] : ¬IsZero X
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- In a Hilbert space, the orthogonal complement of the orthogonal complement of a subspace `K`
is the topological closure of `K`.

Note that the completeness assumption is necessary. Let `E` be the space `ℕ →₀ ℝ` with inner space
structure inherited from `PiLp 2 (fun _ : ℕ ↦ ℝ)`. Let `K` be the subspace of sequences with the sum
of all elements equal to zero. Then `Kᗮ = ⊥`, `Kᗮᗮ = ⊤`.  -/
theorem Submodule.orthogonal_orthogonal_eq_closure [CompleteSpace E] :
    Kᗮᗮ = K.topologicalClosure
-- Mathlib/Algebra/NeZero.lean
theorem not_neZero {n : R} : ¬NeZero n ↔ n = 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem dvdNotUnit_iff_normalizedFactors_lt_normalizedFactors {x y : α} (hx : x ≠ 0) (hy : y ≠ 0) :
    DvdNotUnit x y ↔ normalizedFactors x < normalizedFactors y
-- Mathlib/Analysis/Normed/Group/Quotient.lean
/-- For any `m : M` and any `0 < ε`, there is `s ∈ S` such that `‖m + s‖ < ‖mk' S m‖ + ε`. -/
theorem norm_mk_lt' (S : AddSubgroup M) (m : M) {ε : ℝ} (hε : 0 < ε) :
    ∃ s ∈ S, ‖m + s‖ < ‖mk' S m‖ + ε
-- Mathlib/NumberTheory/EulerProduct/Basic.lean
/-- A version of `EulerProduct.summable_and_hasSum_factoredNumbers_prod_filter_prime_tsum`
in terms of the value of the series. -/
lemma prod_filter_prime_tsum_eq_tsum_factoredNumbers (hsum : Summable (‖f ·‖)) (s : Finset ℕ) :
    ∏ p ∈ s.filter Nat.Prime, ∑' n : ℕ, f (p ^ n) = ∑' m : factoredNumbers s, f m
-- Mathlib/Algebra/Order/CauSeq/BigOperators.lean
lemma of_decreasing_bounded (f : ℕ → α) {a : α} {m : ℕ} (ham : ∀ n ≥ m, |f n| ≤ a)
    (hnm : ∀ n ≥ m, f n.succ ≤ f n) : IsCauSeq abs f
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem natDegree_of_a_ne_zero (ha : P.a ≠ 0) : P.toPoly.natDegree = 3
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@[simp]
theorem Proj.res_apply (x) : ((Proj.structureSheaf 𝒜).1.map i s).1 x = s.1 (i.unop x)
-- Mathlib/Data/Nat/Squarefree.lean
lemma prod_primeFactors_of_squarefree (hn : Squarefree n) : ∏ p ∈ n.primeFactors, p = n
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
/-- A Young diagram is a finite collection of cells on the `ℕ × ℕ` grid such that whenever
a cell is present, so are all the ones above and to the left of it. Like matrices, an `(i, j)` cell
is a cell in row `i` and column `j`, where rows are enumerated downward and columns rightward.

Young diagrams are modeled as finite sets in `ℕ × ℕ` that are lower sets with respect to the
standard order on products. -/
@[ext]
structure YoungDiagram where
  /-- A finite set which represents a finite collection of cells on the `ℕ × ℕ` grid. -/
  cells : Finset (ℕ × ℕ)
  /-- Cells are up-left justified, witnessed by the fact that `cells` is a lower set in `ℕ × ℕ`. -/
  isLowerSet : IsLowerSet (cells : Set (ℕ × ℕ))
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[simp, reassoc]
theorem lift_fac (H : Set.range g.base ⊆ Set.range f.base) : lift f g H ≫ f = g
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lift_down' {a : Cardinal.{u}} {b : Ordinal.{max u v}}
    (h : card.{max u v} b ≤ Cardinal.lift.{v,u} a) : ∃ a', lift.{v,u} a' = b
-- Mathlib/Data/Set/Function.lean
lemma InjOn.image_inter {s t u : Set α} (hf : u.InjOn f) (hs : s ⊆ u) (ht : t ⊆ u) :
    f '' (s ∩ t) = f '' s ∩ f '' t
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem apply_symm_apply (e : R ≃+* S) : ∀ x, e (e.symm x) = x
-- Mathlib/LinearAlgebra/Span.lean
theorem iSup_span {ι : Sort*} (p : ι → Set M) : ⨆ i, span R (p i) = span R (⋃ i, p i)
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
noncomputable def colimitCocone (F : J ⥤ Type u) [Small.{u} (Quot F)] : Cocone F
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_iff_of_neg' (hc : c < 0) : b / c ≤ a ↔ c * a ≤ b
-- Mathlib/LinearAlgebra/FreeProduct/Basic.lean
/--Multiplication in the free product of the injections of any two `aᵢ aᵢ': A i` for
the same `i` is just the injection of multiplication `aᵢ * aᵢ'` in `A i`.-/
theorem mul_injections (a₁ a₂ : A i) :
    ι' R A (DirectSum.lof R I A i a₁) * ι' R A (DirectSum.lof R I A i a₂)
      = ι' R A (DirectSum.lof R I A i (a₁ * a₂))
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem Step.zero : Step k 0 = k
-- Mathlib/Data/Sym/Sym2.lean
/-- Note: `Sym2.map_id` will not simplify `Sym2.map id z` due to `Sym2.map_congr`. -/
@[simp]
theorem map_id' : (map fun x : α => x) = id
-- Mathlib/CategoryTheory/DifferentialObject.lean
@[simp]
theorem isoApp_symm {X Y : DifferentialObject S C} (f : X ≅ Y) : isoApp f.symm = (isoApp f).symm
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.mapsTo_lineMap (h : Convex 𝕜 s) {x y : E} (hx : x ∈ s) (hy : y ∈ s) :
    MapsTo (AffineMap.lineMap x y) (Icc (0 : 𝕜) 1) s
-- Mathlib/Data/PNat/Prime.lean
theorem Coprime.factor_eq_gcd_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n) :
    a = (b * a).gcd m
-- Mathlib/RingTheory/Unramified/Basic.lean
/-- An `R`-algebra `A` is formally unramified if for every `R`-algebra, every square-zero ideal
`I : Ideal B` and `f : A →ₐ[R] B ⧸ I`, there exists at most one lift `A →ₐ[R] B`.

See <https://stacks.math.columbia.edu/tag/00UM>. -/
@[mk_iff]
class FormallyUnramified : Prop where
  comp_injective :
    ∀ ⦃B : Type u⦄ [CommRing B],
      ∀ [Algebra R B] (I : Ideal B) (_ : I ^ 2 = ⊥),
        Function.Injective ((Ideal.Quotient.mkₐ R I).comp : (A →ₐ[R] B) → A →ₐ[R] B ⧸ I)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpIndL1_add (x y : G) :
    condexpIndL1 hm μ s (x + y) = condexpIndL1 hm μ s x + condexpIndL1 hm μ s y
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem zsmul_coeff (m : ℤ) (x : 𝕎 R) (n : ℕ) :
    (m • x).coeff n = peval (wittZSMul p m n) ![x.coeff]
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem LinearIndependent.union_of_quotient
    {M' : Submodule R M} {s : Set M} (hs : s ⊆ M') (hs' : LinearIndependent (ι := s) R Subtype.val)
  {t : Set M} (ht : LinearIndependent (ι := t) R (Submodule.Quotient.mk (p := M') ∘ Subtype.val)) :
    LinearIndependent (ι := (s ∪ t : _)) R Subtype.val
-- Mathlib/Tactic/PushNeg.lean
theorem not_lt_eq (a b : β) : (¬ (a < b)) = (b ≤ a)
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_neg_Iio : Neg.neg '' Iio a = Ioi (-a)
-- Mathlib/RingTheory/Flat/Stability.lean
private lemma auxLTensor_eq [Module.Flat R S] {I : Ideal R} :
    (auxLTensor R S M I : M ⊗[R] I →ₗ[R] M) =
    TensorProduct.rid R M ∘ₗ lTensor M (I.subtype)
-- Mathlib/CategoryTheory/Abelian/Basic.lean
theorem factorThruImage_comp_coimageIsoImage'_inv :
    factorThruImage f ≫ (coimageIsoImage' f).inv = cokernel.π _
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem le_natDegree_of_ne_zero (h : coeff p n ≠ 0) : n ≤ natDegree p
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem le_degrees_add {p q : MvPolynomial σ R} (h : p.degrees.Disjoint q.degrees) :
    p.degrees ≤ (p + q).degrees
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem smooth_snd : Smooth (I.prod J) J (@Prod.snd M N)
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
/-- A submonoid `S` includes `closure s` if and only if it includes `s`. -/
@[to_additive (attr := simp)
"An additive submonoid `S` includes `closure s` if and only if it includes `s`"]
theorem closure_le : closure s ≤ S ↔ s ⊆ S
-- Mathlib/SetTheory/Ordinal/CantorNormalForm.lean
/-- Every coefficient in a Cantor normal form is positive. -/
theorem CNF_lt_snd {b o : Ordinal.{u}} {x : Ordinal × Ordinal} : x ∈ CNF b o → 0 < x.2
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem X_inj [Nontrivial R] (m n : σ) : X m = (X n : MvPolynomial σ R) ↔ m = n
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem infty_not_mem_range_coe : ∞ ∉ range ((↑) : X → OnePoint X)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem add_mul (a b c : Int) : (a + b) * c = a * c + b * c
-- Mathlib/MeasureTheory/Order/Lattice.lean
/-- We say that a type has `MeasurableSup₂` if `uncurry (· ⊔ ·)` is a measurable functions.
For a typeclass assuming measurability of `(c ⊔ ·)` and `(· ⊔ c)` see `MeasurableSup`. -/
class MeasurableSup₂ (M : Type*) [MeasurableSpace M] [Sup M] : Prop where
  measurable_sup : Measurable fun p : M × M => p.1 ⊔ p.2
-- Mathlib/Analysis/BoxIntegral/Basic.lean
theorem HasIntegral.integrable (h : HasIntegral I l f vol y) : Integrable I l f vol
-- Mathlib/Logic/Basic.lean
@[mfld_simps]
theorem forall_true_iff : (α → True) ↔ True
-- Mathlib/Data/Matrix/Basic.lean
theorem vec_one_mul [Fintype m] (A : Matrix m n α) : 1 ᵥ* A = fun j => ∑ i, A i j
-- Mathlib/Algebra/Algebra/Equiv.lean
/-- If `A₁` is equivalent to `A₁'` and `A₂` is equivalent to `A₂'`, then the type of maps
`A₁ →ₐ[R] A₂` is equivalent to the type of maps `A₁' →ₐ[R] A₂'`. -/
@[simps apply]
def arrowCongr (e₁ : A₁ ≃ₐ[R] A₁') (e₂ : A₂ ≃ₐ[R] A₂') : (A₁ →ₐ[R] A₂) ≃ (A₁' →ₐ[R] A₂')
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem sign_pi_sub (θ : Angle) : ((π : Angle) - θ).sign = θ.sign
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
theorem modelWithCorners_prod_toPartialEquiv :
    (I.prod J).toPartialEquiv = I.toPartialEquiv.prod J.toPartialEquiv
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem isUniversalColimit_extendCofan {n : ℕ} (f : Fin (n + 1) → C)
    {c₁ : Cofan fun i : Fin n ↦ f i.succ} {c₂ : BinaryCofan (f 0) c₁.pt}
    (t₁ : IsUniversalColimit c₁) (t₂ : IsUniversalColimit c₂)
    [∀ {Z} (i : Z ⟶ c₂.pt), HasPullback c₂.inr i] :
    IsUniversalColimit (extendCofan c₁ c₂)
-- Mathlib/LinearAlgebra/Lagrange.lean
@[simp]
theorem degree_nodal [Nontrivial R] : (nodal s v).degree = s.card
-- Mathlib/Control/EquivFunctor.lean
theorem mapEquiv_symm_apply (y : f β) : (mapEquiv f e).symm y = EquivFunctor.map e.symm y
-- Mathlib/NumberTheory/NumberField/Norm.lean
theorem norm_algebraMap [Algebra.IsSeparable K L] (x : 𝓞 K) :
    norm K (algebraMap (𝓞 K) (𝓞 L) x) = x ^ finrank K L
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem smul_mem_iff {c : 𝕜} (hc : 0 < c) {x : E} : c • x ∈ S ↔ x ∈ S
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem div_mul : a / b * c = a / (b / c)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toFinset_union (l l' : List α) : (l ∪ l').toFinset = l.toFinset ∪ l'.toFinset
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
lemma Asymptotics.IsBigO.comp_summable_norm {ι E F : Type*}
    [SeminormedAddCommGroup E] [SeminormedAddCommGroup F] {f : E → F} {g : ι → E}
    (hf : f =O[𝓝 0] id) (hg : Summable (‖g ·‖)) : Summable (‖f <| g ·‖)
-- Mathlib/Data/ZMod/Basic.lean
theorem intCast_zmod_eq_zero_iff_dvd (a : ℤ) (b : ℕ) : (a : ZMod b) = 0 ↔ (b : ℤ) ∣ a
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem rat_mul_continuous_lemma {ε K₁ K₂ : α} (ε0 : 0 < ε) :
    ∃ δ > 0, ∀ {a₁ a₂ b₁ b₂ : β}, abv a₁ < K₁ → abv b₂ < K₂ → abv (a₁ - b₁) < δ →
      abv (a₂ - b₂) < δ → abv (a₁ * a₂ - b₁ * b₂) < ε
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem of_b_eq_zero' : toPoly ⟨0, 0, c, d⟩ = C c * X + C d
-- Mathlib/Data/Finset/Lattice.lean
theorem max'_insert (a : α) (s : Finset α) (H : s.Nonempty) :
    (insert a s).max' (s.insert_nonempty a) = max (s.max' H) a
-- Mathlib/Order/Filter/NAry.lean
theorem NeBot.of_map₂_left (h : (map₂ m f g).NeBot) : f.NeBot
-- Mathlib/Data/ENNReal/Inv.lean
theorem exists_inv_two_pow_lt (ha : a ≠ 0) : ∃ n : ℕ, 2⁻¹ ^ n < a
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp]
lemma RingEquiv_coe_eq {X Y : Type _} [Ring X] [Ring Y] (e : X ≃+* Y) :
    (@DFunLike.coe (RingCat.of X ⟶ RingCat.of Y) _ (fun _ => (forget RingCat).obj _)
      ConcreteCategory.instFunLike (e : X →+* Y) : X → Y) = ↑e
-- Mathlib/ModelTheory/Skolem.lean
theorem coeSort_elementarySkolem₁Reduct (S : (L.sum L.skolem₁).Substructure M) :
    (S.elementarySkolem₁Reduct : Type w) = S
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
theorem rnDeriv_sub (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [hst : (s - t).HaveLebesgueDecomposition μ] :
    (s - t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ - t.rnDeriv μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasDerivWithinAt.ccos (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') s x
-- Mathlib/Data/Num/Lemmas.lean
theorem add_succ : ∀ m n : Num, m + succ n = succ (m + n)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem get?_nil : @get? α [] n = none
-- Mathlib/Topology/Order/OrderClosed.lean
protected theorem Dense.exists_le [NoMinOrder α] {s : Set α} (hs : Dense s) (x : α) :
    ∃ y ∈ s, y ≤ x
-- Mathlib/Logic/Embedding/Basic.lean
@[simp]
theorem setValue_eq_iff {α β} (f : α ↪ β) {a a' : α} {b : β} [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : setValue f a b a' = b ↔ a' = a
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
    a + b < a + c