ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/IsWellOrderLimitElement.lean
@[simp]
lemma Nat.wellOrderSucc_eq (a : ℕ) : wellOrderSucc a = succ a
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem coe_support {u v : V} (p : G.Walk u v) :
    (p.support : Multiset V) = {u} + p.support.tail
-- Mathlib/RingTheory/Ideal/Over.lean
theorem IntegralClosure.eq_bot_of_comap_eq_bot [Nontrivial R] {I : Ideal (integralClosure R S)} :
    I.comap (algebraMap R (integralClosure R S)) = ⊥ → I = ⊥
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
@[reassoc (attr := simp)]
lemma rightDerivedNatTrans_app (τ : F ⟶ F') (X : C) :
    α.app X ≫ (rightDerivedNatTrans RF RF' α α' W τ).app (L.obj X) =
    τ.app X ≫ α'.app X
-- Mathlib/Computability/Language.lean
lemma reverse_mem_reverse : a.reverse ∈ l.reverse ↔ a ∈ l
-- Mathlib/Data/ENNReal/Operations.lean
@[simp, norm_cast]
theorem coe_finset_sum {s : Finset α} {f : α → ℝ≥0} : ↑(∑ a ∈ s, f a) = ∑ a ∈ s, (f a : ℝ≥0∞)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma preΨ_ne_zero [Nontrivial R] {n : ℤ} (h : (n : R) ≠ 0) : W.preΨ n ≠ 0
-- Mathlib/Data/Real/ConjExponents.lean
lemma one_le : 1 ≤ p
-- .lake/packages/lean4/src/lean/Init/Data/List/Control.lean
@[simp] theorem forIn'_eq_forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : List α) (init : β) (f : α → β → m (ForInStep β)) : forIn' as init (fun a _ b => f a b) = forIn as init f
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
protected theorem closedEmbedding : ClosedEmbedding I
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp]
theorem map_C (a : R) : map σ f (C σ R a) = C σ S (f a)
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean
/-- A category has all finite limits if every functor `J ⥤ C` with a `FinCategory J`
instance and `J : Type` has a limit.

This is often called 'finitely complete'.
-/
class HasFiniteLimits : Prop where
  /-- `C` has all limits over any type `J` whose objects and morphisms lie in the same universe
  and which has `FinType` objects and morphisms-/
  out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasLimitsOfShape J 𝒥 C _
-- Mathlib/Order/Basic.lean
theorem le_of_le_of_eq' : b ≤ c → a = b → a ≤ c
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuousOn_univ [UniformSpace β] {f : α → β} :
    UniformContinuousOn f univ ↔ UniformContinuous f
-- Mathlib/Combinatorics/HalesJewett.lean
lemma apply_inl (h : l.idxFun i = Sum.inl a) : l x i = a
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuous_iff_le_liminf {f : α → γ} :
    LowerSemicontinuous f ↔ ∀ x, f x ≤ liminf f (𝓝 x)
-- Mathlib/MeasureTheory/Function/LpSpace/ContinuousCompMeasurePreserving.lean
theorem ContinuousWithinAt.compMeasurePreservingLp (hf : ContinuousWithinAt f s z)
    (hg : ContinuousWithinAt g s z) (hgm : ∀ z, MeasurePreserving (g z) μ ν) (hp : p ≠ ∞) :
    ContinuousWithinAt (fun z ↦ Lp.compMeasurePreserving (g z) (hgm z) (f z)) s z
-- Mathlib/Data/Vector/MapLemmas.lean
/--
  If an accumulation function `f`, given an initial state `s`, produces `s` as its output state
  for all possible input bits, then the state is redundant and can be optimized out
-/
@[simp]
theorem mapAccumr_eq_map_of_constant_state (f : α → σ → σ × β) (s : σ) (h : ∀ a, (f a s).fst = s) :
    mapAccumr f xs s = (s, (map (fun x => (f x s).snd) xs))
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem _root_.Finset.nullMeasurableSet_biUnion {f : ι → Set α} (s : Finset ι)
    (h : ∀ b ∈ s, NullMeasurableSet (f b) μ) : NullMeasurableSet (⋃ b ∈ s, f b) μ
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem map_mul_right_nhds₀ (ha : a ≠ 0) (b : G₀) : map (· * a) (𝓝 b) = 𝓝 (b * a)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem nonempty_iInter {f : ι → Set α} : (⋂ i, f i).Nonempty ↔ ∃ x, ∀ i, x ∈ f i
-- Mathlib/Order/WithBot.lean
theorem strictMono_iff {f : WithTop α → β} :
    StrictMono f ↔ StrictMono (fun (a : α) => f a) ∧ ∀ x : α, f x < f ⊤
-- Mathlib/Algebra/Order/Invertible.lean
@[simp]
theorem invOf_lt_zero [Invertible a] : ⅟ a < 0 ↔ a < 0
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_eq_add_tsum_ite {f : β → ℝ≥0∞} (b : β) :
    ∑' x, f x = f b + ∑' x, ite (x = b) 0 (f x)
-- Mathlib/Computability/Primrec.lean
theorem pred : Primrec Nat.pred
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma floorDiv_le_ceilDiv : b ⌊/⌋ a ≤ b ⌈/⌉ a
-- Mathlib/Topology/Sets/Opens.lean
@[simp, norm_cast]
theorem coe_sup (s t : Opens α) : (↑(s ⊔ t) : Set α) = ↑s ∪ ↑t
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem aefinStronglyMeasurable [Zero β] [TopologicalSpace β] (hf : FinStronglyMeasurable f μ) :
    AEFinStronglyMeasurable f μ
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_nat_mul_iff : Irrational (n * x) ↔ n ≠ 0 ∧ Irrational x
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiableOn.comp (hg : MDifferentiableOn I' I'' g u) (hf : MDifferentiableOn I I' f s)
    (st : s ⊆ f ⁻¹' u) : MDifferentiableOn I I'' (g ∘ f) s
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem norm_mul_mem_unitary (A : E) {U : E} (hU : U ∈ unitary E) : ‖A * U‖ = ‖A‖
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma leadingCoeff_preΨ' {n : ℕ} (h : (n : R) ≠ 0) :
    (W.preΨ' n).leadingCoeff = if Even n then n / 2 else n
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
@[simp]
theorem infEdist_empty : infEdist x ∅ = ∞
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_add : cfcₙ (fun x ↦ f x + g x) a = cfcₙ f a + cfcₙ g a
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk_sum {ι : Type*} (f : ι → R) (s : Finset ι) (b : M) :
    mk (∑ i ∈ s, f i) b = ∑ i ∈ s, mk (f i) b
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem beq_self_left  : ∀(a b : Bool), (a == (a == b)) = b
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem range_familyOfBFamily {o} (f : ∀ a < o, α) : range (familyOfBFamily o f) = brange o f
-- Mathlib/Analysis/Convex/Function.lean
/-- Left translation preserves convexity. -/
theorem ConvexOn.translate_left (hf : ConvexOn 𝕜 s f) (c : E) :
    ConvexOn 𝕜 ((fun z => c + z) ⁻¹' s) (f ∘ fun z => z + c)
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_image_preimage_sigma_mk_eq_self {ι : Type*} {σ : ι → Type*} (s : Set (Sigma σ)) :
    ⋃ i, Sigma.mk i '' (Sigma.mk i ⁻¹' s) = s
-- Mathlib/Order/Filter/Pi.lean
@[simp]
theorem pi_le_pi [∀ i, NeBot (f₁ i)] : pi f₁ ≤ pi f₂ ↔ ∀ i, f₁ i ≤ f₂ i
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_approx_start (x a b : ℝ) (h : |exp x - expNear 0 x a| ≤ |x| ^ 0 / Nat.factorial 0 * b) :
    |exp x - a| ≤ b
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousOn_iff_continuous_restrict {f : α → β} {s : Set α} :
    ContinuousOn f s ↔ Continuous (s.restrict f)
-- Mathlib/Order/WellFoundedSet.lean
protected theorem Finite.partiallyWellOrderedOn (hs : s.Finite) : s.PartiallyWellOrderedOn r
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem himp_bihimp_left : a ⇨ a ⇔ b = a ⇨ b
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_of_sub_nonpos {a b : Int} (h : a - b ≤ 0) : a ≤ b
-- Mathlib/Data/Set/Lattice.lean
theorem sInf_sUnion (s : Set (Set β)) : sInf (⋃₀ s) = ⨅ t ∈ s, sInf t
-- Mathlib/NumberTheory/LSeries/RiemannZeta.lean
/-- The completed Riemann zeta function `Λ(s)` is differentiable away from `s = 0` and `s = 1`. -/
theorem differentiableAt_completedZeta {s : ℂ} (hs : s ≠ 0) (hs' : s ≠ 1) :
    DifferentiableAt ℂ completedRiemannZeta s
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
/-- If `Irreducible (cyclotomic (2 ^ k) K)` (in particular for `K = ℚ`) and `k` is at least `2`,
then the norm of `zeta (2 ^ k) K L - 1` is `2`. -/
theorem norm_zeta_pow_sub_one_two {k : ℕ} (hk : 2 ≤ k)
    [IsCyclotomicExtension {(2 : ℕ+) ^ k} K L] (hirr : Irreducible (cyclotomic (2 ^ k) K)) :
    norm K (zeta ((2 : ℕ+) ^ k) K L - 1) = 2
-- Mathlib/Logic/Function/Basic.lean
theorem sometimes_eq {p : Prop} {α} [Nonempty α] (f : p → α) (a : p) : sometimes f = f a
-- Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean
theorem w : forkMap P R ≫ firstMap P R = forkMap P R ≫ secondMap P R
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[aesop safe 20 (rule_sets := [Measurable])]
protected theorem sup [SemilatticeSup β] [ContinuousSup β] (hf : AEFinStronglyMeasurable f μ)
    (hg : AEFinStronglyMeasurable g μ) : AEFinStronglyMeasurable (f ⊔ g) μ
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem IsPRadical.ker_le [IsPRadical i p] :
    RingHom.ker i ≤ pNilradical K p
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma unmop_whiskerRight {X Y : Cᴹᵒᵖ} (f : X ⟶ Y) (Z : Cᴹᵒᵖ) :
    (f ▷ Z).unmop = unmop Z ◁ f.unmop
-- Mathlib/Data/Nat/Bits.lean
lemma div2_one : div2 1 = 0
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_add_aux {f g : α → ℝ≥0∞} (hf : Measurable f) (hg : Measurable g) :
    ∫⁻ a, f a + g a ∂μ = ∫⁻ a, f a ∂μ + ∫⁻ a, g a ∂μ
-- Mathlib/Order/CompleteLattice.lean
/-- The symmetric case of `iInf_and`, useful for rewriting into an infimum over a conjunction -/
theorem iInf_and' {p q : Prop} {s : p → q → α} :
    ⨅ (h₁ : p) (h₂ : q), s h₁ h₂ = ⨅ h : p ∧ q, s h.1 h.2
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_lt_mul_of_neg_right [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (h : b < a) (hc : c < 0) : a * c < b * c
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@[simp]
theorem map_id : map (QuadraticMap.Isometry.id Q₁) = AlgHom.id R (CliffordAlgebra Q₁)
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem Nat.cauchy_induction_two_mul (seed : ℕ) (hs : P seed.succ)
    (hm : ∀ x, seed < x → P x → P (2 * x)) (n : ℕ) : P n
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
theorem of_reverse [HasInvolutiveReverse V] (X Y : V) (f : X ⟶ Y) :
    (reverse <| (Push.of σ).map f) = (Push.of σ).map (reverse f)
-- Mathlib/Data/Finset/NAry.lean
/-- A common special case of `image₂_congr` -/
theorem image₂_congr' (h : ∀ a b, f a b = f' a b) : image₂ f s t = image₂ f' s t
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_of_le' (hfg : ∀ x, ‖f x‖ ≤ c * ‖g x‖) : IsBigOWith c l f g
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem toWithTop_one' {h : Decidable (1 : PartENat).Dom} : toWithTop 1 = 1
-- Mathlib/Algebra/Homology/Embedding/Basic.lean
/-- The opposite embedding in `Embedding c.symm c'.symm` of `e : Embedding c c'`. -/
@[simps]
def op : Embedding c.symm c'.symm
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma isIso_homologyπ (hf : S.f = 0) [S.HasHomology] :
    IsIso S.homologyπ
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
@[simp] lemma uIoc_of_ge (h : b ≤ a) : Ι a b = Ioc b a
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesOnBall.analyticOn (hf : HasFPowerSeriesOnBall f p x r) :
    AnalyticOn 𝕜 f (EMetric.ball x r)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem blsub_succ_of_mono {o : Ordinal.{u}} {f : ∀ a < succ o, Ordinal.{max u v}}
    (hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) : blsub.{_, v} _ f = succ (f o (lt_succ o))
-- Mathlib/Algebra/Regular/Pow.lean
/-- An element `a` is left-regular if and only if a positive power of `a` is left-regular. -/
theorem IsLeftRegular.pow_iff {n : ℕ} (n0 : 0 < n) : IsLeftRegular (a ^ n) ↔ IsLeftRegular a
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem zipLeft_nil_left : zipLeft ([] : List α) bs = []
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem star_moveRight (x) : star.moveRight x = 0
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
theorem lim_neg (f : CauSeq β abv) : lim (-f) = -lim f
-- Mathlib/Algebra/Polynomial/Derivation.lean
@[simp]
theorem C_smul_derivation_apply (D : Derivation R R[X] A) (a : R) (f : R[X]) :
    C a • D f = a • D f
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability, fun_prop]
theorem Measurable.infDist {f : β → α} (hf : Measurable f) {s : Set α} :
    Measurable fun x => infDist (f x) s
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem ext_iff {x y : 𝕎 R} : x = y ↔ ∀ n, x.coeff n = y.coeff n
-- Mathlib/RingTheory/Ideal/AssociatedPrime.lean
theorem not_isAssociatedPrime_of_subsingleton [Subsingleton M] : ¬IsAssociatedPrime I M
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- Induction principle for invertible matrices based on transvections: if a property is true for
all invertible diagonal matrices, all transvections, and is stable under product of invertible
matrices, then it is true for all invertible matrices. This is the useful way to say that
invertible matrices are generated by invertible diagonal matrices and transvections. -/
theorem diagonal_transvection_induction_of_det_ne_zero (P : Matrix n n 𝕜 → Prop) (M : Matrix n n 𝕜)
    (hMdet : det M ≠ 0) (hdiag : ∀ D : n → 𝕜, det (diagonal D) ≠ 0 → P (diagonal D))
    (htransvec : ∀ t : TransvectionStruct n 𝕜, P t.toMatrix)
    (hmul : ∀ A B, det A ≠ 0 → det B ≠ 0 → P A → P B → P (A * B)) : P M
-- Mathlib/CategoryTheory/Localization/Bousfield.lean
lemma W_eq_inverseImage_isomorphisms :
    W (· ∈ Set.range F.obj) = (MorphismProperty.isomorphisms _).inverseImage G
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma inv_mul_eq_one₀ (ha : a ≠ 0) : a⁻¹ * b = 1 ↔ a = b
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem abs_one_div (a : α) : |1 / a| = 1 / |a|
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem mem_sup_right {S T : StarSubalgebra R A} : ∀ {x : A}, x ∈ T → x ∈ S ⊔ T
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem bddAbove {f : ∀ i, E i} (hf : Memℓp f ∞) : BddAbove (Set.range fun i => ‖f i‖)
-- Mathlib/Data/Real/Sqrt.lean
@[fun_prop]
theorem ContinuousOn.sqrt (h : ContinuousOn f s) : ContinuousOn (fun x => √(f x)) s
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem add_comp [ContinuousAdd M₃] (g₁ g₂ : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) :
    (g₁ + g₂).comp f = g₁.comp f + g₂.comp f
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem append_append (h₁ : Red L₁ L₃) (h₂ : Red L₂ L₄) : Red (L₁ ++ L₂) (L₃ ++ L₄)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lt_wf : @WellFounded Ordinal (· < ·)
-- Mathlib/GroupTheory/Perm/ClosureSwap.lean
/-- If a subgroup is generated by transpositions, then a permutation `f` lies in the subgroup if
  and only if `f` has finite support and `f x` always lies in the same orbit as `x`. -/
theorem mem_closure_isSwap {S : Set (Perm α)} (hS : ∀ f ∈ S, f.IsSwap) {f : Perm α} :
    f ∈ closure S ↔ (fixedBy α f)ᶜ.Finite ∧ ∀ x, f x ∈ orbit (closure S) x
-- Mathlib/Topology/Basic.lean
theorem monotone_closure (X : Type*) [TopologicalSpace X] : Monotone (@closure X _)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp] theorem coe_mk (f h) : ⇑(mk f h) = f
-- .lake/packages/lean4/src/lean/Init/Data/AC.lean
structure Context (α : Sort u) where
  op : α → α → α
  assoc : Associative op
  comm : Option $ PLift $ Commutative op
  idem : Option $ PLift $ IdempotentOp op
  vars : List (Variable op)
  arbitrary : α
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pushoutCoconeOfRightIso_x : (pushoutCoconeOfRightIso f g).pt = Y
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem range_top_iff_surjective (f : F) :
    NonUnitalStarAlgHom.range f = (⊤ : NonUnitalStarSubalgebra R B) ↔ Function.Surjective f
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- (internal implementation) the fact that the proposed limit cone is the limit -/
@[simps]
noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F)
-- Mathlib/Logic/Relation.lean
theorem _root_.Acc.TransGen (h : Acc r a) : Acc (TransGen r) a
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- **Gelfand's formula**: Given an element `a : A` of a complex Banach algebra, the
`spectralRadius` of `a` is the limit of the sequence `‖a ^ n‖₊ ^ (1 / n)`. -/
theorem pow_norm_pow_one_div_tendsto_nhds_spectralRadius (a : A) :
    Tendsto (fun n : ℕ => ENNReal.ofReal (‖a ^ n‖ ^ (1 / n : ℝ))) atTop
      (𝓝 (spectralRadius ℂ a))
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem finsuppProdLEquiv_symm_apply {α β R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    (f : α →₀ β →₀ M) (xy) : (finsuppProdLEquiv R).symm f xy = f xy.1 xy.2
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem colimit.isoColimitCocone_ι_inv {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) (j : J) :
    t.cocone.ι.app j ≫ (colimit.isoColimitCocone t).inv = colimit.ι F j
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_mul_left (m n k : Nat) : gcd (m * n) (m * k) = m * gcd n k
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
/-- `ord ∘ aleph'` enumerates the ordinals that are cardinals. -/
theorem ord_aleph'_eq_enum_card : ord ∘ aleph' = enumOrd { b : Ordinal | b.card.ord = b }
-- Mathlib/Order/WellFoundedSet.lean
/-- Higman's Lemma, which states that for any reflexive, transitive relation `r` which is
  partially well-ordered on a set `s`, the relation `List.SublistForall₂ r` is partially
  well-ordered on the set of lists of elements of `s`. That relation is defined so that
  `List.SublistForall₂ r l₁ l₂` whenever `l₁` related pointwise by `r` to a sublist of `l₂`.  -/
theorem partiallyWellOrderedOn_sublistForall₂ (r : α → α → Prop) [IsRefl α r] [IsTrans α r]
    {s : Set α} (h : s.PartiallyWellOrderedOn r) :
    { l : List α | ∀ x, x ∈ l → x ∈ s }.PartiallyWellOrderedOn (List.SublistForall₂ r)
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem not_dvd_of_degree_lt (hp : Monic p) (h0 : q ≠ 0) (hl : degree q < degree p) : ¬p ∣ q
-- Mathlib/Order/Lattice.lean
theorem le_sup_of_le_right (h : c ≤ b) : c ≤ a ⊔ b
-- Mathlib/Computability/Primrec.lean
theorem sum_inr : Primrec (@Sum.inr α β)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem IsNormal.cof_le {f} (hf : IsNormal f) (a) : cof a ≤ cof (f a)
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem isRight_inl : (inl x : α ⊕ β).isRight = false
-- Mathlib/RingTheory/LocalRing/Basic.lean
/-- A semiring is local if it has a unique maximal ideal. -/
theorem of_unique_max_ideal (h : ∃! I : Ideal R, I.IsMaximal) : LocalRing R
-- Mathlib/Algebra/Star/SelfAdjoint.lean
theorem conjugate' {x : R} (hx : x ∈ skewAdjoint R) (z : R) : star z * x * z ∈ skewAdjoint R
-- Mathlib/Order/Hom/Lattice.lean
theorem Disjoint.map (h : Disjoint a b) : Disjoint (f a) (f b)
-- Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
/-- Special case of the grid-lines lemma `lintegral_mul_prod_lintegral_pow_le`, taking the extremal
exponent `p = (#ι - 1)⁻¹`. -/
theorem lintegral_prod_lintegral_pow_le
    {p : ℝ} (hp : Real.IsConjExponent #ι p)
    {f} (hf : Measurable f) :
    ∫⁻ x, ∏ i, (∫⁻ xᵢ, f (update x i xᵢ) ∂μ i) ^ ((1 : ℝ) / (#ι - 1 : ℝ)) ∂.pi μ
    ≤ (∫⁻ x, f x ∂.pi μ) ^ p
-- Mathlib/Data/Vector/Snoc.lean
@[simp]
theorem mapAccumr₂_nil : mapAccumr₂ f Vector.nil Vector.nil s = (s, Vector.nil)
-- Mathlib/Algebra/Lie/Solvable.lean
theorem le_solvable_ideal_solvable {I J : LieIdeal R L} (h₁ : I ≤ J) (_ : IsSolvable R J) :
    IsSolvable R I
-- Mathlib/Algebra/Homology/ShortComplex/ExactFunctor.lean
/--
For an addivite functor `F : C ⥤ D` between abelian categories, the following are equivalent:
- `F` preserves short exact sequences on the left hand side, i.e. if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact
  then `0 ⟶ F(A) ⟶ F(B) ⟶ F(C)` is exact.
- `F` preserves exact sequences on the left hand side, i.e. if `A ⟶ B ⟶ C` is exact where `A ⟶ B`
  is mono, then `F(A) ⟶ F(B) ⟶ F(C)` is exact and `F(A) ⟶ F(B)` is mono as well.
- `F` preserves kernels.
- `F` preserves finite limits.
-/
lemma preservesFiniteLimits_tfae : List.TFAE
    [
      ∀ (S : ShortComplex C), S.ShortExact → (S.map F).Exact ∧ Mono (F.map S.f),
      ∀ (S : ShortComplex C), S.Exact ∧ Mono S.f → (S.map F).Exact ∧ Mono (F.map S.f),
      ∀ ⦃X Y : C⦄ (f : X ⟶ Y), Nonempty $ PreservesLimit (parallelPair f 0) F,
      Nonempty $ PreservesFiniteLimits F
    ]
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
/--
Given a spanning set of `Γ(X, U)`, the corresponding basic open sets cover `U`.
See `IsAffineOpen.basicOpen_union_eq_self_iff` for the inverse direction for affine open sets.
-/
lemma iSup_basicOpen_of_span_eq_top {X : Scheme} (U) (s : Set Γ(X, U))
    (hs : Ideal.span s = ⊤) : (⨆ i ∈ s, X.basicOpen i) = U
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.rotate_iff [NoZeroSMulDivisors R V] {x y z : P} (h : Wbtw R x y z) :
    Wbtw R z x y ↔ x = y
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
@[simp] lemma ofUpperSet_le_ofUpperSet {a b : WithUpperSet α} :
    ofUpperSet a ≤ ofUpperSet b ↔ b ⤳ a
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem degree_basisDivisor_of_ne (hxy : x ≠ y) : (basisDivisor x y).degree = 1
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem nontrivial_max_triv_of_isNilpotent [Nontrivial M] [IsNilpotent R L M] :
    Nontrivial (maxTrivSubmodule R L M)
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem derivWithin.comp (hh₂ : DifferentiableWithinAt 𝕜' h₂ s' (h x))
    (hh : DifferentiableWithinAt 𝕜 h s x) (hs : MapsTo h s s') (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (h₂ ∘ h) s x = derivWithin h₂ s' (h x) * derivWithin h s x
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem BilinForm.toMatrix_toBilin (M : Matrix n n R₂) :
    BilinForm.toMatrix b (Matrix.toBilin b M) = M
-- Mathlib/Data/Sum/Interval.lean
@[simp]
lemma Ioc_inr_inl : Ioc (inrₗ b) (inlₗ a) = ∅
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_iInter [Nonempty ι] : (↑(⋂ i, t i) : Set α) = ⋂ i, (↑(t i) : Set α)
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[reassoc (attr := simp)]
theorem LaxMonoidalFunctor.μ_natural (F : LaxMonoidalFunctor C D) {X Y X' Y' : C}
    (f : X ⟶ Y) (g : X' ⟶ Y') :
      (F.map f ⊗ F.map g) ≫ F.μ Y Y' = F.μ X X' ≫ F.map (f ⊗ g)
-- Mathlib/Data/Fin/Tuple/Reflection.lean
/-- This can be use to prove
```lean
example {f : α → β} (a₁ a₂ : α) : f ∘ ![a₁, a₂] = ![f a₁, f a₂] :=
  (map_eq _ _).symm
```
-/
@[simp]
theorem map_eq (f : α → β) {m} (v : Fin m → α) : map f v = f ∘ v
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem smoothOn_univ : SmoothOn I I' f univ ↔ Smooth I I' f
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/--
The lower topology is the topology generated by the complements of the left-closed right-infinite
intervals.
-/
class IsLower (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_lowerTopology : t = lower α
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsPrime.multiset_prod_map_le {s : Multiset ι} (f : ι → Ideal R) {P : Ideal R}
    (hp : IsPrime P) : (s.map f).prod ≤ P ↔ ∃ i ∈ s, f i ≤ P
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.mulVecLin_apply [Fintype n] (M : Matrix m n R) (v : n → R) :
    M.mulVecLin v = M *ᵥ v
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
lemma set_prod_ae_eq {s s' : Set α} {t t' : Set β} (hs : s =ᵐ[μ] s') (ht : t =ᵐ[ν] t') :
    (s ×ˢ t : Set (α × β)) =ᵐ[μ.prod ν] (s' ×ˢ t' : Set (α × β))
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
protected lemma «exists» {p : Additive α → Prop} : (∃ a, p a) ↔ ∃ a, p (ofMul a)
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem toBoolRing_inj {a b : α} : toBoolRing a = toBoolRing b ↔ a = b
-- Mathlib/SetTheory/Game/PGame.lean
theorem wf_isOption : WellFounded IsOption
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem NoMinOrder.lowerBounds_univ [NoMinOrder α] : lowerBounds (univ : Set α) = ∅
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Iio_subset_Iic_self : Iio a ⊆ Iic a
-- Mathlib/Logic/Basic.lean
theorem not_exists_mem : (¬∃ x h, P x h) ↔ ∀ x h, ¬P x h
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean
/-- `biprodComparison F X Y` is a split epi. -/
@[simps]
def splitEpiBiprodComparison : SplitEpi (biprodComparison F X Y)
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem newton_seq_succ_dist_weak (n : ℕ) :
    ‖newton_seq (n + 2) - newton_seq (n + 1)‖ < ‖F.eval a‖ / ‖F.derivative.eval a‖
-- Mathlib/Algebra/GradedMulAction.lean
@[simp,nolint simpNF]
theorem SetLike.coe_GSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
    (A : ιA → S) (B : ιB → N) [SetLike.GradedSMul A B] {i : ιA} {j : ιB} (x : A i) (y : B j) :
    (@GradedMonoid.GSMul.smul ιA ιB (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1