ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem apply_order_ne_zero' (hp : p.order ≠ 0) : p p.order ≠ 0
-- Mathlib/Data/Finset/Sups.lean
theorem Nonempty.of_sups_right : (s ⊻ t).Nonempty → t.Nonempty
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_of_isEmpty [IsEmpty α] (f : α → M) : ∏ᶠ i, f i = 1
-- Mathlib/LinearAlgebra/InvariantBasisNumber.lean
theorem card_le_of_injective [StrongRankCondition R] {α β : Type*} [Fintype α] [Fintype β]
    (f : (α → R) →ₗ[R] β → R) (i : Injective f) : Fintype.card α ≤ Fintype.card β
-- Mathlib/CategoryTheory/Sites/SheafOfTypes.lean
/--
The base of a sieve `S` is a colimit of `S` iff all Yoneda-presheaves satisfy
the sheaf condition for `S`.
-/
theorem forallYonedaIsSheaf_iff_colimit (S : Sieve X) :
    (∀ W : C, Presieve.IsSheafFor (yoneda.obj W) (S : Presieve X)) ↔
      Nonempty (IsColimit S.arrows.cocone)
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem compQuasiMeasurePreserving_eq_mk (g : β →ₘ[ν] γ) (hf : QuasiMeasurePreserving f μ ν) :
    g.compQuasiMeasurePreserving f hf =
      mk (g ∘ f) (g.aestronglyMeasurable.comp_quasiMeasurePreserving hf)
-- Mathlib/CategoryTheory/Equivalence.lean
/-- A functor is an equivalence of categories if it is faithful, full and
essentially surjective. -/
class Functor.IsEquivalence (F : C ⥤ D) : Prop where
  faithful : F.Faithful := by infer_instance
  full : F.Full := by infer_instance
  essSurj : F.EssSurj := by infer_instance
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
lemma AutGalois.π_apply (A : PointedGaloisObject F) (x : AutGalois F) :
    AutGalois.π F A x = x.val A
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem soln_dist_to_a_lt_deriv : ‖soln - a‖ < ‖F.derivative.eval a‖
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
@[simp]
lemma trace_eq_zero_of_isEmpty [IsEmpty n] (A : Matrix n n R) : trace A = 0
-- Mathlib/Algebra/Order/AbsoluteValue.lean
@[simp]
theorem coe_mk (f : R →ₙ* S) {h₁ h₂ h₃} : (AbsoluteValue.mk f h₁ h₂ h₃ : R → S) = f
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem tendsto_exp_comp_nhds_zero {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto f l atBot
-- Mathlib/Algebra/Group/Basic.lean
lemma eq_of_mul_inv_eq_one (h : a * b⁻¹ = 1) : a = b
-- Mathlib/Probability/Kernel/Basic.lean
@[simp] lemma add_apply (κ η : Kernel α β) (a : α) : (κ + η) a = κ a + η a
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.hasDerivAt_convolution_left [IsNegInvariant μ]
    (hcf : HasCompactSupport f₀) (hf : ContDiff 𝕜 1 f₀) (hg : LocallyIntegrable g₀ μ) (x₀ : 𝕜) :
    HasDerivAt (f₀ ⋆[L, μ] g₀) ((deriv f₀ ⋆[L, μ] g₀) x₀) x₀
-- Mathlib/Probability/Martingale/OptionalStopping.lean
theorem smul_le_stoppedValue_hitting [IsFiniteMeasure μ] (hsub : Submartingale f 𝒢 μ) {ε : ℝ≥0}
    (n : ℕ) : ε • μ {ω | (ε : ℝ) ≤ (range (n + 1)).sup' nonempty_range_succ fun k => f k ω} ≤
    ENNReal.ofReal (∫ ω in {ω | (ε : ℝ) ≤ (range (n + 1)).sup' nonempty_range_succ fun k => f k ω},
      stoppedValue f (hitting f {y : ℝ | ↑ε ≤ y} 0 n) ω ∂μ)
-- Mathlib/CategoryTheory/Adhesive.lean
theorem adhesive_of_preserves_and_reflects_isomorphism (F : C ⥤ D)
    [Adhesive D] [HasPullbacks C] [HasPushouts C]
    [PreservesLimitsOfShape WalkingCospan F]
    [PreservesColimitsOfShape WalkingSpan F]
    [F.ReflectsIsomorphisms] :
    Adhesive C
-- Mathlib/Algebra/Associated/Basic.lean
theorem forall_associated [Monoid α] {p : Associates α → Prop} :
    (∀ a, p a) ↔ ∀ a, p (Associates.mk a)
-- Mathlib/Order/Basic.lean
@[simp]
theorem le_update_self_iff : x ≤ update x i a ↔ x i ≤ a
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem normUnit_eq (z : ℤ) : normUnit z = if 0 ≤ z then 1 else -1
-- Mathlib/Order/PartialSups.lean
theorem partialSups_eq_biSup (f : ℕ → α) (n : ℕ) : partialSups f n = ⨆ i ≤ n, f i
-- Mathlib/Topology/Category/TopCat/Limits/Konig.lean
theorem partialSections.nonempty [IsCofilteredOrEmpty J] [h : ∀ j : J, Nonempty (F.obj j)]
    {G : Finset J} (H : Finset (FiniteDiagramArrow G)) : (partialSections F H).Nonempty
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem mem_lpMeas_iff_aeStronglyMeasurable' {m m0 : MeasurableSpace α} {μ : Measure α}
    {f : Lp F p μ} : f ∈ lpMeas F 𝕜 m p μ ↔ AEStronglyMeasurable' m f μ
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem le_add_tsub : a ≤ b + (a - b)
-- Mathlib/GroupTheory/FreeGroup/NielsenSchreier.lean
/-- Two functors from a free groupoid to a group are equal when they agree on the generating
quiver. -/
@[ext]
theorem ext_functor {G} [Groupoid.{v} G] [IsFreeGroupoid G] {X : Type v} [Group X]
    (f g : G ⥤ CategoryTheory.SingleObj X) (h : ∀ (a b) (e : a ⟶ b), f.map (of e) = g.map (of e)) :
    f = g
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem coe_copy (f : α →*₀o β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem _root_.SimpleGraph.Preconnected.subsingleton_connectedComponent (h : G.Preconnected) :
    Subsingleton G.ConnectedComponent
-- Mathlib/Topology/Algebra/UniformRing.lean
theorem algebraMap_def (r : R) :
    algebraMap R (Completion A) r = (algebraMap R A r : Completion A)
-- Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean
theorem le_maximalIdeal {J : Ideal R} (hJ : J ≠ ⊤) : J ≤ maximalIdeal R
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem eq_X_sub_C_of_splits_of_single_root {x : K} {h : K[X]} (h_splits : Splits i h)
    (h_roots : (h.map i).roots = {i x}) : h = C h.leadingCoeff * (X - C x)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bsup_comp {o o' : Ordinal.{max u v}} {f : ∀ a < o, Ordinal.{max u v w}}
    (hf : ∀ {i j} (hi) (hj), i ≤ j → f i hi ≤ f j hj) {g : ∀ a < o', Ordinal.{max u v}}
    (hg : blsub.{_, u} o' g = o) :
    (bsup.{_, w} o' fun a ha => f (g a ha) (by rw [← hg]; apply lt_blsub)) = bsup.{_, w} o f
-- Mathlib/Probability/Density.lean
theorem integrable_pdf_smul_iff [IsFiniteMeasure ℙ] {X : Ω → E} [HasPDF X ℙ μ] {f : E → F}
    (hf : AEStronglyMeasurable f μ) :
    Integrable (fun x => (pdf X ℙ μ x).toReal • f x) μ ↔ Integrable (fun x => f (X x)) ℙ
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem rel_of_act_rel_act (m : M) {a b : N} (ab : r (μ m a) (μ m b)) : r a b
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem memℒp_const_iff {p : ℝ≥0∞} {c : E} (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp (fun _ : α => c) p μ ↔ c = 0 ∨ μ Set.univ < ∞
-- Mathlib/Algebra/Homology/HomotopyCategory.lean
lemma quotient_inverts_homotopyEquivalences :
    (HomologicalComplex.homotopyEquivalences V c).IsInvertedBy (quotient V c)
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
lemma ShortExact.moduleCat_surjective_g (hS : S.ShortExact) :
    Function.Surjective S.g
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- If a matrix has a repeated row, the determinant will be zero. -/
theorem det_zero_of_row_eq (i_ne_j : i ≠ j) (hij : M i = M j) : M.det = 0
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_preimage_of_not_mem (s : Set α) (f : α → M) {t : Set M} (ht : (1 : M) ∉ t) :
    mulIndicator s f ⁻¹' t = f ⁻¹' t ∩ s
-- Mathlib/Data/List/Sublists.lean
@[simp]
theorem sublists'_nil : sublists' (@nil α) = [[]]
-- Mathlib/Data/Finset/PImage.lean
@[simp]
theorem mem_pimage : b ∈ s.pimage f ↔ ∃ a ∈ s, b ∈ f a
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem le_iff_compact_le_imp {a b : α} :
    a ≤ b ↔ ∀ c : α, CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b
-- Mathlib/Data/DFinsupp/Order.lean
theorem support_sup_union_support_inf : (f ⊔ g).support ∪ (f ⊓ g).support = f.support ∪ g.support
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_mul [Mul β] (f g : α →ₛ β) : ⇑(f * g) = ⇑f * ⇑g
-- Mathlib/Analysis/LocallyConvex/Basic.lean
lemma Absorbs.exists_pos (h : Absorbs 𝕜 A B) : ∃ r > 0, ∀ c : 𝕜, r ≤ ‖c‖ → B ⊆ c • A
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
theorem mapsTo_reflection_root :
    MapsTo (P.reflection i) (range P.root) (range P.root)
-- Mathlib/Order/WellFoundedSet.lean
nonrec theorem IsWF.not_lt_min (hs : IsWF s) (hn : s.Nonempty) (ha : a ∈ s) : ¬a < hs.min hn
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem Filter.Tendsto.cexp {l : Filter α} {f : α → ℂ} {z : ℂ} (hf : Tendsto f l (𝓝 z)) :
    Tendsto (fun x => exp (f x)) l (𝓝 (exp z))
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem Ico_subset_closure_interior (a b : α) : Ico a b ⊆ closure (interior (Ico a b))
-- Mathlib/CategoryTheory/UnivLE.lean
theorem UnivLE_iff_essSurj :
    UnivLE.{max u v, v} ↔ (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem HasMFDerivAt.add (hf : HasMFDerivAt I 𝓘(𝕜, E') f z f')
    (hg : HasMFDerivAt I 𝓘(𝕜, E') g z g') : HasMFDerivAt I 𝓘(𝕜, E') (f + g) z (f' + g')
-- Mathlib/Logic/Function/Basic.lean
theorem apply_update₂ {ι : Sort*} [DecidableEq ι] {α β γ : ι → Sort*} (f : ∀ i, α i → β i → γ i)
    (g : ∀ i, α i) (h : ∀ i, β i) (i : ι) (v : α i) (w : β i) (j : ι) :
    f j (update g i v j) (update h i w j) = update (fun k ↦ f k (g k) (h k)) i (f i v w) j
-- Mathlib/Order/Circular.lean
theorem sbtw_iff_btw_not_btw {a b c : α} : sbtw a b c ↔ btw a b c ∧ ¬btw c b a
-- Mathlib/Order/Directed.lean
theorem exists_ge_ge [LE α] [IsDirected α (· ≤ ·)] (a b : α) : ∃ c, a ≤ c ∧ b ≤ c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_nat_mul_pi_sub (x : ℝ) (n : ℕ) : sin (n * π - x) = -((-1) ^ n * sin x)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem IsOpen.mul_left : IsOpen t → IsOpen (s * t)
-- Mathlib/Computability/Language.lean
@[simp]
lemma reverse_mul (l m : Language α) : (l * m).reverse = m.reverse * l.reverse
-- Mathlib/NumberTheory/Divisors.lean
theorem Prime.properDivisors {p : ℕ} (pp : p.Prime) : properDivisors p = {1}
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- An orthonormal set in a finite-dimensional `InnerProductSpace` is maximal, if and only if it
is a basis. -/
theorem maximal_orthonormal_iff_basis_of_finiteDimensional (hv : Orthonormal 𝕜 ((↑) : v → E)) :
    (∀ u ⊇ v, Orthonormal 𝕜 ((↑) : u → E) → u = v) ↔ ∃ b : Basis v 𝕜 E, ⇑b = ((↑) : v → E)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Replacing the third point by one on the same line does not change twice the oriented angle. -/
theorem _root_.Collinear.two_zsmul_oangle_eq_right {p₁ p₂ p₃ p₃' : P}
    (h : Collinear ℝ ({p₃, p₂, p₃'} : Set P)) (hp₃p₂ : p₃ ≠ p₂) (hp₃'p₂ : p₃' ≠ p₂) :
    (2 : ℤ) • ∡ p₁ p₂ p₃ = (2 : ℤ) • ∡ p₁ p₂ p₃'
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem basisDivisor_ne_zero_iff : basisDivisor x y ≠ 0 ↔ x ≠ y
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIdIso_hom_fst :
    (pullbackDiagonalMapIdIso f g i).hom ≫ pullback.fst _ _ =
      pullback.snd _ _ ≫ pullback.fst _ _
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- A homotopy between two morphisms of short complexes `S₁ ⟶ S₂` consists of various
maps and conditions which will be sufficient to show that they induce the same morphism
in homology. -/
@[ext]
structure Homotopy where
  /-- a morphism `S₁.X₁ ⟶ S₂.X₁` -/
  h₀ : S₁.X₁ ⟶ S₂.X₁
  h₀_f : h₀ ≫ S₂.f = 0 := by aesop_cat
  /-- a morphism `S₁.X₂ ⟶ S₂.X₁` -/
  h₁ : S₁.X₂ ⟶ S₂.X₁
  /-- a morphism `S₁.X₃ ⟶ S₂.X₂` -/
  h₂ : S₁.X₃ ⟶ S₂.X₂
  /-- a morphism `S₁.X₃ ⟶ S₂.X₃` -/
  h₃ : S₁.X₃ ⟶ S₂.X₃
  g_h₃ : S₁.g ≫ h₃ = 0 := by aesop_cat
  comm₁ : φ₁.τ₁ = S₁.f ≫ h₁ + h₀ + φ₂.τ₁ := by aesop_cat
  comm₂ : φ₁.τ₂ = S₁.g ≫ h₂ + h₁ ≫ S₂.f + φ₂.τ₂ := by aesop_cat
  comm₃ : φ₁.τ₃ = h₃ + h₂ ≫ S₂.g + φ₂.τ₃ := by aesop_cat
-- Mathlib/Data/ZMod/Basic.lean
/-- Any ring homomorphism into `ZMod n` has a right inverse. -/
theorem ringHom_rightInverse [Ring R] (f : R →+* ZMod n) :
    Function.RightInverse (cast : ZMod n → R) f
-- Mathlib/Data/Matrix/RowCol.lean
theorem reindex_updateColumn [DecidableEq o] [DecidableEq n] (A : Matrix m n α) (j : n) (c : m → α)
    (e : m ≃ l) (f : n ≃ o) :
    reindex e f (A.updateColumn j c) = updateColumn (reindex e f A) (f j) fun i => c (e.symm i)
-- Mathlib/Data/Finset/Sort.lean
theorem sort_perm_toList (s : Finset α) : sort r s ~ s.toList
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
/-- Given an open cover `{ Xᵢ }` of `X` and an open cover `{ Yⱼ }` of `Y`, then
`X ×[Z] Y` is covered by `Xᵢ ×[Z] Yⱼ`. -/
@[simps! J obj map]
def openCoverOfLeftRight (𝒰X : X.OpenCover) (𝒰Y : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) :
    (pullback f g).OpenCover
-- Mathlib/RingTheory/Derivation/Basic.lean
@[simp]
theorem coe_smul (r : S) (D : Derivation R A M) : ⇑(r • D) = r • ⇑D
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuousOn_iff_limsup_le {f : α → γ} :
    UpperSemicontinuousOn f s ↔ ∀ x ∈ s, limsup f (𝓝[s] x) ≤ f x
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem cast_addNat_right {n m m' : Nat} (i : Fin n) (h : n + m' = n + m) :
    cast h (addNat i m') = addNat i m
-- Mathlib/RingTheory/Localization/InvSubmonoid.lean
theorem span_invSubmonoid : Submodule.span R (invSubmonoid M S : Set S) = ⊤
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem mem_toNonUnitalSubalgebra {S : NonUnitalStarSubalgebra R A} {x} :
    x ∈ S.toNonUnitalSubalgebra ↔ x ∈ S
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma ratCast_im (q : ℚ) : (q : ℂ).im = 0
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem coequalizer.existsUnique {W : C} (k : Y ⟶ W) (h : f ≫ k = g ≫ k) :
    ∃! d : coequalizer f g ⟶ W, coequalizer.π f g ≫ d = k
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem leadingCoeff_smul_normalizeScaleRoots (p : R[X]) :
    p.leadingCoeff • normalizeScaleRoots p = scaleRoots p p.leadingCoeff
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem skeletal : Skeletal SimplexCategory
-- Mathlib/Topology/Constructions.lean
/-- Precomposing `f` with `Prod.fst` is continuous -/
theorem Continuous.fst' {f : X → Z} (hf : Continuous f) : Continuous fun x : X × Y => f x.fst
-- Mathlib/Algebra/Star/RingQuot.lean
private irreducible_def star' (hr : ∀ a b, r a b → r (star a) (star b)) : RingQuot r → RingQuot r
-- Mathlib/Data/Complex/Module.lean
theorem skewAdjoint.I_smul_neg_I (a : skewAdjoint A) : I • (skewAdjoint.negISMul a : A) = a
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_mono_set]
theorem prod_mono_set' (f : ι → M) : Monotone fun s ↦ ∏ x ∈ s, f x
-- Mathlib/RingTheory/Idempotents.lean
lemma OrthogonalIdempotents.isIdempotentElem_sum [Fintype I] : IsIdempotentElem (∑ i, e i)
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma unit_mem_of_mem_ofUnits (S : Subgroup Mˣ) {x : M} {h₁ : IsUnit x}
    (h₂ : x ∈ S.ofUnits) : h₁.unit ∈ S
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[ext 1100]
lemma ext₀ (z₁ z₂ : Cochain F G 0)
    (h : ∀ (p : ℤ), z₁.v p p (add_zero p) = z₂.v p p (add_zero p)) : z₁ = z₂
-- Mathlib/Topology/Separation.lean
lemma isClosed_inter_singleton [T1Space X] {A : Set X} {a : X} : IsClosed (A ∩ {a})
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Icc : (some : α → WithBot α) ⁻¹' Icc a b = Icc a b
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
@[simp]
theorem toFinsupp_toFreeAbelianGroup (f : X →₀ ℤ) :
    FreeAbelianGroup.toFinsupp (Finsupp.toFreeAbelianGroup f) = f
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := simp)]
theorem mem_fixedBy {m : M} {a : α} : a ∈ fixedBy α m ↔ m • a = a
-- Mathlib/Topology/Connected/PathConnected.lean
theorem JoinedIn.refl (h : x ∈ F) : JoinedIn F x x
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- The generalized eigenspace of an eigenvalue has positive dimension for positive exponents. -/
theorem pos_finrank_genEigenspace_of_hasEigenvalue [FiniteDimensional K V] {f : End K V}
    {k : ℕ} {μ : K} (hx : f.HasEigenvalue μ) (hk : 0 < k) :
    0 < finrank K (f.genEigenspace μ k)
-- Mathlib/Order/UpperLower/Basic.lean
theorem isUpperSet_empty : IsUpperSet (∅ : Set α)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
/-- In the specific case of continuous multilinear maps on spaces indexed by `Fin (n+1)`, where one
can build an element of `(i : Fin (n+1)) → M i` using `cons`, one can express directly the
multiplicativity of a multilinear map along the first variable. -/
theorem cons_smul (f : ContinuousMultilinearMap R M M₂) (m : ∀ i : Fin n, M i.succ) (c : R)
    (x : M 0) : f (cons (c • x) m) = c • f (cons x m)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem is_le (i : Fin (n + 1)) : i ≤ n
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
protected theorem add_ciSup (c : Cardinal.{v}) : c + (⨆ i, f i) = ⨆ i, c + f i
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem le_mul_of_pos_left (m) (h : 0 < n) : m ≤ n * m
-- Mathlib/Algebra/Star/StarAlgHom.lean
lemma coe_restrictScalars' (f : A →⋆ₙₐ[S] B) : (f.restrictScalars R : A → B) = f
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
theorem smul_mem_orbit_smul (g h : G) (a : α) : g • a ∈ orbit G (h • a)
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_le_sInf_of_subset_insert_top (h : s ⊆ insert ⊤ t) : sInf t ≤ sInf s
-- Mathlib/Topology/Spectral/Hom.lean
@[simp]
theorem comp_assoc (f : SpectralMap γ δ) (g : SpectralMap β γ) (h : SpectralMap α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/RingTheory/Ideal/Cotangent.lean
theorem map_toCotangent_ker : I.toCotangent.ker.map I.subtype = I ^ 2
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The category of binary bicones on a given diagram. -/
@[simps]
instance BinaryBicone.category {P Q : C} : Category (BinaryBicone P Q)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_normalizer_iff {g : G} : g ∈ H.normalizer ↔ ∀ h, h ∈ H ↔ g * h * g⁻¹ ∈ H
-- Mathlib/ModelTheory/LanguageMap.lean
@[simp]
theorem withConstants_relMap_sum_inl [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
    {n} {R : L.Relations n} {x : Fin n → M} : @RelMap (L[[α]]) M _ n (Sum.inl R) x = RelMap R x
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_pow_anti (a1 : 1 ≤ a) : Antitone fun n : ℕ => (a ^ n)⁻¹
-- Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean
lemma map_eq_mapOfHomotopy : map φ₁ φ₂ a b comm = mapOfHomotopy (Homotopy.ofEq comm)
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem sub_eq (p₁ p₂ : Pos) : p₁ - p₂ = ⟨p₁.byteIdx - p₂.byteIdx⟩
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem sup_le_of_range_subset {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
    (h : Set.range f ⊆ Set.range g) : sup.{u, max v w} f ≤ sup.{v, max u w} g
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem IsUniform.mono {ε ε' : 𝕜} (hP : P.IsUniform G ε) (h : ε ≤ ε') : P.IsUniform G ε'
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_pf_add_lt (a₁ : R) (_ : a₂ + b = c) : (a₁ + a₂) + b = a₁ + c
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem MeasureTheory.AEStronglyMeasurable.prod_mk_left {γ : Type*} [SFinite ν]
    [TopologicalSpace γ] {f : α × β → γ} (hf : AEStronglyMeasurable f (μ.prod ν)) :
    ∀ᵐ x ∂μ, AEStronglyMeasurable (fun y => f (x, y)) ν
-- Mathlib/LinearAlgebra/Quotient.lean
theorem mkQ_surjective (A : Submodule R M) : Function.Surjective A.mkQ
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.filter (p : α → Bool) {l} : Nodup l → Nodup (filter p l)
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem UniqueMDiffWithinAt.inter' (hs : UniqueMDiffWithinAt I s x) (ht : t ∈ 𝓝[s] x) :
    UniqueMDiffWithinAt I (s ∩ t) x
-- Mathlib/Data/Rat/Cast/Defs.lean
theorem cast_comm (r : ℚ) (a : α) : (r : α) * a = a * r
-- Mathlib/Data/Finsupp/Defs.lean
/-- Bundle `Finsupp.embDomain f` as an additive map from `α →₀ M` to `β →₀ M`. -/
@[simps]
def embDomain.addMonoidHom (f : α ↪ β) : (α →₀ M) →+ β →₀ M
-- Mathlib/Data/Seq/WSeq.lean
theorem toList_ofList (l : List α) : l ∈ toList (ofList l)
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_1_approx_succ_eq {n} {a₁ b₁ : ℝ} {m : ℕ} (en : n + 1 = m) {rm : ℝ} (er : ↑m = rm)
    (h : |exp 1 - expNear m 1 ((a₁ - 1) * rm)| ≤ |1| ^ m / m.factorial * (b₁ * rm)) :
    |exp 1 - expNear n 1 a₁| ≤ |1| ^ n / n.factorial * b₁
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- The cartesian product of two equivalences of categories. -/
@[simps]
def prod (E₁ : A ≌ B) (E₂ : C ≌ D) : A × C ≌ B × D
-- Mathlib/Order/Heyting/Basic.lean
lemma himp_ne_himp_iff : b ⇨ a ≠ a ⇨ b ↔ a ≠ b
-- Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
/-- The constant factor occurring in the conclusion of `eLpNorm_le_eLpNorm_fderiv_of_eq`.
It only depends on `E`, `F`, `μ` and `p`. -/
irreducible_def SNormLESNormFDerivOfEqConst [FiniteDimensional ℝ F] (p : ℝ) : ℝ≥0
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
/-- Nonzero fractional ideals contain a nonzero integer. -/
theorem exists_ne_zero_mem_isInteger [Nontrivial R] (hI : I ≠ 0) :
    ∃ x, x ≠ 0 ∧ algebraMap R K x ∈ I
-- Mathlib/RingTheory/Perfection.lean
theorem preVal_mul {x y : ModP K v O hv p} (hxy0 : x * y ≠ 0) :
    preVal K v O hv p (x * y) = preVal K v O hv p x * preVal K v O hv p y
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
/-- If the restriction to a set `s` of a σ-algebra `m` is included in the restriction to `s` of
another σ-algebra `m₂` (hypothesis `hs`), the set `s` is `m` measurable and a function `f` almost
everywhere supported on `s` is `m`-ae-strongly-measurable, then `f` is also
`m₂`-ae-strongly-measurable. -/
theorem AEStronglyMeasurable'.aeStronglyMeasurable'_of_measurableSpace_le_on {α E}
    {m m₂ m0 : MeasurableSpace α} {μ : Measure α} [TopologicalSpace E] [Zero E] (hm : m ≤ m0)
    {s : Set α} {f : α → E} (hs_m : MeasurableSet[m] s)
    (hs : ∀ t, MeasurableSet[m] (s ∩ t) → MeasurableSet[m₂] (s ∩ t))
    (hf : AEStronglyMeasurable' m f μ) (hf_zero : f =ᵐ[μ.restrict sᶜ] 0) :
    AEStronglyMeasurable' m₂ f μ
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
@[simp]
theorem gramSchmidt_zero {ι : Type*} [LinearOrder ι] [LocallyFiniteOrder ι] [OrderBot ι]
    [IsWellOrder ι (· < ·)] (f : ι → E) : gramSchmidt 𝕜 f ⊥ = f ⊥
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[to_additive (attr := simp) pi_nnnorm_const]
lemma pi_nnnorm_const' [Nonempty ι] (a : E) : ‖fun _i : ι => a‖₊ = ‖a‖₊
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
/-- Two open immersions with equal range is isomorphic. -/
@[simps]
def isoOfRangeEq [IsOpenImmersion g] (e : Set.range f.base = Set.range g.base) : X ≅ Y
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem singleton_one : ({1} : Finset α) = 1
-- Mathlib/Data/Nat/PartENat.lean
theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
    get ((x : PartENat) + y) h = x + get y h.2
-- Mathlib/Combinatorics/Additive/Energy.lean
@[to_additive (attr := simp)] lemma mulEnergy_empty_right : Eₘ[s, ∅] = 0
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProdFun_tsum_right (κ : Kernel α β) (η : Kernel (α × β) γ) [IsSFiniteKernel η] (a : α)
    (hs : MeasurableSet s) : compProdFun κ η a s = ∑' n, compProdFun κ (seq η n) a s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_id' : cfcₙ (fun x : R ↦ x) a = a
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
/-- Coefficients of a product of power series -/
theorem coeff_prod [DecidableEq σ]
    (f : ι → MvPowerSeries σ R) (d : σ →₀ ℕ) (s : Finset ι) :
    coeff R d (∏ j ∈ s, f j) =
      ∑ l ∈ finsuppAntidiag s d,
        ∏ i ∈ s, coeff R (l i) (f i)
-- Mathlib/Analysis/Convex/Combination.lean
@[simp] lemma convexHull_pi (s : Set ι) (t : Π i, Set (E i)) :
    convexHull 𝕜 (s.pi t) = s.pi (fun i ↦ convexHull 𝕜 (t i))
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
@[aesop safe apply]
lemma max_bi_le {b : α → ℝ} (i : α) : b i ≤ b (max_bi b)
-- Mathlib/Topology/Algebra/Field.lean
/-- Left-multiplication by a nonzero element of a topological division ring is proper, i.e.,
inverse images of compact sets are compact. -/
theorem Filter.tendsto_cocompact_mul_left₀ [ContinuousMul K] {a : K} (ha : a ≠ 0) :
    Filter.Tendsto (fun x : K => a * x) (Filter.cocompact K) (Filter.cocompact K)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_nhds_iff : s ∈ 𝓝 x ↔ ∃ ε > 0, ball x ε ⊆ s