ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsRadical.radical_le_iff (hJ : J.IsRadical) : I.radical ≤ J ↔ I ≤ J
-- Mathlib/Order/Closure.lean
theorem sInf_isClosed {c : ClosureOperator α} {S : Set α}
    (H : ∀ x ∈ S, c.IsClosed x) : c.IsClosed (sInf S)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- If a point belongs to an open ball, then there is a strictly smaller radius whose ball also
contains it.

See also `exists_lt_subset_ball`. -/
theorem exists_lt_mem_ball_of_mem_ball (h : x ∈ ball y ε) : ∃ ε' < ε, x ∈ ball y ε'
-- Mathlib/Data/Finset/NoncommProd.lean
@[simp]
theorem noncommFold_empty (h) (a : α) : noncommFold op (0 : Multiset α) h a = a
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp] lemma bddAbove_closure : BddAbove (closure s) ↔ BddAbove s
-- Mathlib/Order/WithBot.lean
theorem some_eq_coe (a : α) : (Option.some a : WithBot α) = (↑a : WithBot α)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[aesop safe 20 (rule_sets := [Measurable])]
protected theorem mul [MonoidWithZero β] [ContinuousMul β] (hf : AEFinStronglyMeasurable f μ)
    (hg : AEFinStronglyMeasurable g μ) : AEFinStronglyMeasurable (f * g) μ
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
@[simp]
theorem toMatrix_self [DecidableEq ι] : e.toMatrix e = 1
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem compl_inter (s t : Finset α) : (s ∩ t)ᶜ = sᶜ ∪ tᶜ
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive (attr := simp)]
theorem iUnion_op_smul_set (s t : Set α) : ⋃ a ∈ t, MulOpposite.op a • s = s * t
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem summable_geometric_of_abs_lt_one {r : ℝ} (h : |r| < 1) : Summable fun n : ℕ ↦ r ^ n
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem coe_eq_zero_iff {x : s} : (x : R) = 0 ↔ x = 0
-- Mathlib/Data/Finset/Sort.lean
@[simp]
theorem length_sort {s : Finset α} : (sort r s).length = s.card
-- Mathlib/Data/Matrix/DMatrix.lean
@[simp, nolint simpNF]
theorem zero_apply [∀ i j, Zero (α i j)] (i j) : (0 : DMatrix m n α) i j = 0
-- Mathlib/Topology/ContinuousOn.lean
theorem eventuallyEq_nhdsWithin_iff {f g : α → β} {s : Set α} {a : α} :
    f =ᶠ[𝓝[s] a] g ↔ ∀ᶠ x in 𝓝 a, x ∈ s → f x = g x
-- Mathlib/Analysis/SpecialFunctions/Gaussian/PoissonSummation.lean
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * x ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s
-- Mathlib/Data/List/Zip.lean
theorem mem_zip_inits_tails {l : List α} {init tail : List α} :
    (init, tail) ∈ zip l.inits l.tails ↔ init ++ tail = l
-- Mathlib/Data/Option/NAry.lean
theorem map_map₂_antidistrib {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g₁ b) (g₂ a)) :
    (map₂ f a b).map g = map₂ f' (b.map g₁) (a.map g₂)
-- Mathlib/Data/Nat/Nth.lean
theorem le_nth_count' {n : ℕ} (hpn : ∃ k, p k ∧ n ≤ k) : n ≤ nth p (count p n)
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp)]
theorem ofLex_inv [Inv α] (a : Lex α) : ofLex a⁻¹ = (ofLex a)⁻¹
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem reparam_id (γ : Path x y) : γ.reparam id continuous_id rfl rfl = γ
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem sub (hφ : IsHomogeneous φ n) (hψ : IsHomogeneous ψ n) : IsHomogeneous (φ - ψ) n
-- Mathlib/CategoryTheory/Sites/CoverPreserving.lean
/-- The composition of two cover-preserving functors is cover-preserving. -/
theorem CoverPreserving.comp {F} (hF : CoverPreserving J K F) {G} (hG : CoverPreserving K L G) :
    CoverPreserving J L (F ⋙ G)
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasFDerivWithinAt.norm_sq {f : G → F} {f' : G →L[ℝ] F} (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (‖f ·‖ ^ 2) (2 • (innerSL ℝ (f x)).comp f') s x
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
/-- Linear upper bound for `f (x + n)` on unit interval -/
theorem f_add_nat_le (hf_conv : ConvexOn ℝ (Ioi 0) f)
    (hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y) (hn : n ≠ 0) (hx : 0 < x) (hx' : x ≤ 1) :
    f (n + x) ≤ f n + x * log n
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem IsGLB.ciInf_eq [Nonempty ι] {f : ι → α} (H : IsGLB (range f) a) : ⨅ i, f i = a
-- Mathlib/Algebra/Lie/Weights/Chain.lean
lemma chainTopCoeff_add_one :
    letI := Classical.propDecidable
    chainTopCoeff α β + 1 =
      Nat.find (eventually_weightSpace_smul_add_eq_bot M α β hα).exists
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem _root_.Polynomial.toLaurent_C_mul_eq (r : R) (f : R[X]) :
    toLaurent (Polynomial.C r * f) = C r * toLaurent f
-- Mathlib/Data/PNat/Prime.lean
@[symm]
theorem Coprime.symm {m n : ℕ+} : m.Coprime n → n.Coprime m
-- Mathlib/RingTheory/Perfection.lean
theorem map_eq_map (φ : R →+* S) : map p (of p R) (of p S) φ = Perfection.map p φ
-- Mathlib/LinearAlgebra/Dual.lean
lemma eq_of_ker_eq_of_apply_eq {f g : Module.Dual K V₁} (x : V₁)
    (h : LinearMap.ker f = LinearMap.ker g) (h' : f x = g x) (hx : f x ≠ 0) :
    f = g
-- Mathlib/Data/Sum/Interval.lean
@[simp]
theorem Ioo_inr_inl : Ioo (inr b₁) (inl a₂) = ∅
-- Mathlib/Data/Multiset/Sum.lean
@[simp]
theorem card_disjSum : Multiset.card (s.disjSum t) = Multiset.card s + Multiset.card t
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem id_comp (f : PseudoEpimorphism α β) : (PseudoEpimorphism.id β).comp f = f
-- Mathlib/Order/LiminfLimsup.lean
/-- A bounded function `u` is in particular eventually bounded. -/
theorem isBoundedUnder_of {f : Filter β} {u : β → α} : (∃ b, ∀ x, r (u x) b) → f.IsBoundedUnder r u
-- Mathlib/Data/Countable/Basic.lean
protected lemma Function.Embedding.uncountable [Uncountable α] (f : α ↪ β) : Uncountable β
-- Mathlib/Analysis/Matrix.lean
@[simp] lemma linfty_opNNNorm_toMatrix (f : (n → α) →L[α] (m → α)) :
    ‖LinearMap.toMatrix' (↑f : (n → α) →ₗ[α] (m → α))‖₊ = ‖f‖₊
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain_support_of_injective [DecidableEq β] {f : α → β} (hf : Function.Injective f)
    (s : α →₀ M) : (mapDomain f s).support = Finset.image f s.support
-- .lake/packages/lean4/src/lean/Init/WF.lean
theorem wf (f : α → β) (h : WellFounded r) : WellFounded (InvImage r f)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂_C (a) : (C a).eval₂ f g = f a
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem count_support_eq_one [DecidableEq V] {u v w : V} {p : G.Path u v}
    (hw : w ∈ (p : G.Walk u v).support) : (p : G.Walk u v).support.count w = 1
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem getElem_range' {n m step} (i) (H : i < (range' n m step).length) :
    (range' n m step)[i] = n + step * i
-- Mathlib/Order/Basic.lean
@[to_additive ite_pos]
lemma one_lt_ite [LT α] (ha : 1 < a) (hb : 1 < b) : 1 < ite p a b
-- Mathlib/Order/IsWellOrderLimitElement.lean
lemma IsWellOrderLimitElement.neq_succ (a : α) (ha : a < wellOrderSucc a)
    [IsWellOrderLimitElement (wellOrderSucc a)] : False
-- Mathlib/LinearAlgebra/Matrix/ToLinearEquiv.lean
theorem nondegenerate_iff_det_ne_zero {A : Type*} [DecidableEq n] [CommRing A] [IsDomain A]
    {M : Matrix n n A} : Nondegenerate M ↔ M.det ≠ 0
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
@[simp]
theorem antidiagonal_zero : antidiagonal (0 : A) = {(0, 0)}
-- Mathlib/Data/Set/Lattice.lean
theorem union_iUnion [Nonempty ι] (s : Set β) (t : ι → Set β) : (s ∪ ⋃ i, t i) = ⋃ i, s ∪ t i
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma lintegral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ x, ENNReal.ofReal (density κ ν a x s) ∂(ν a) = κ a (univ ×ˢ s)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- `MultilinearMap.domDomCongr` as a `LinearEquiv`. -/
@[simps apply symm_apply]
def domDomCongrLinearEquiv {ι₁ ι₂} (σ : ι₁ ≃ ι₂) :
    MultilinearMap R (fun _ : ι₁ => M₂) M₃ ≃ₗ[S] MultilinearMap R (fun _ : ι₂ => M₂) M₃
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem add_left_cancel {n m k : Nat} : n + m = n + k → m = k
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalExtr.congr {f g : α → β} {a : α} (h : IsLocalExtr f a) (heq : f =ᶠ[𝓝 a] g) :
    IsLocalExtr g a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem add_add_add_comm (a b c d : Nat) : (a + b) + (c + d) = (a + c) + (b + d)
-- Mathlib/Order/Interval/Set/Image.lean
@[simp] lemma preimage_subtype_val_Ico (a b : {x // p x}) : (↑) ⁻¹' (Ico a.1 b) = Ico a b
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
theorem coe_decompose_mul_of_left_mem_of_not_le (a_mem : a ∈ 𝒜 i) (h : ¬i ≤ n) :
    (decompose 𝒜 (a * b) n : A) = 0
-- Mathlib/Order/RelSeries.lean
@[simp] lemma snoc_castSucc (s : RelSeries r) (a : α) (connect : r s.last a)
    (i : Fin (s.length + 1)) : snoc s a connect (Fin.castSucc i) = s i
-- Mathlib/RingTheory/FiniteType.lean
/-- If `R[M]` is of finite type, then there is a `G : Finset M` such that its
image generates, as algebra, `R[M]`. -/
theorem exists_finset_adjoin_eq_top [h : FiniteType R R[M]] :
    ∃ G : Finset M, Algebra.adjoin R (of' R M '' G) = ⊤
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem mk_surjective : Function.Surjective (mk g)
-- Mathlib/Data/ZMod/IntUnitsPower.lean
@[simp] lemma toMul_uzpow (u : Additive ℤˣ) (r : R) :
  Additive.toMul (r • u) = Additive.toMul u ^ r
-- Mathlib/Data/Fin/Basic.lean
protected theorem add_zero [NeZero n] (k : Fin n) : k + 0 = k
-- Mathlib/Topology/Order/OrderClosed.lean
nonrec theorem ContinuousAt.eventually_lt {x₀ : β} (hf : ContinuousAt f x₀) (hg : ContinuousAt g x₀)
    (hfg : f x₀ < g x₀) : ∀ᶠ x in 𝓝 x₀, f x < g x
-- Mathlib/Logic/Basic.lean
theorem Or.imp3 {d e c f : Prop} (had : a → d) (hbe : b → e) (hcf : c → f) :
    a ∨ b ∨ c → d ∨ e ∨ f
-- Mathlib/CategoryTheory/Opposites.lean
/-- The natural isomorphism between functors `G ≅ F` induced by a natural isomorphism
between the opposite functors `F.op ≅ G.op`. -/
@[simps]
protected def removeOp (α : F.op ≅ G.op) : G ≅ F
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem countable_cover_nhds_interior [LindelofSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, interior (U x) = univ
-- Mathlib/Algebra/AddTorsor.lean
/-- `x` is the only fixed point of `pointReflection x`. This lemma requires
`x + x = y + y ↔ x = y`. There is no typeclass to use here, so we add it as an explicit argument. -/
theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (2 • · : G → G)) :
    pointReflection x y = y ↔ y = x
-- Mathlib/Analysis/Seminorm.lean
theorem le_def {p q : Seminorm 𝕜 E} : p ≤ q ↔ ∀ x, p x ≤ q x
-- Mathlib/Algebra/Lie/Submodule.lean
theorem mem_sup (x : M) : x ∈ N ⊔ N' ↔ ∃ y ∈ N, ∃ z ∈ N', y + z = x
-- Mathlib/Topology/Algebra/Ring/Ideal.lean
@[simp]
theorem Ideal.coe_closure (I : Ideal R) : (I.closure : Set R) = closure I
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem mul_univ_of_one_mem (hs : (1 : α) ∈ s) : s * univ = univ
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_congr' {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (hl : f₁ =ᶠ[l₁] f₂) :
    Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iio_union_Ici_of_le (h : a ≤ b) : Iio b ∪ Ici a = univ
-- Mathlib/Computability/Language.lean
@[simp]
lemma reverse_reverse (l : Language α) : l.reverse.reverse = l
-- Mathlib/Data/Multiset/Fold.lean
theorem fold_add (b₁ b₂ : α) (s₁ s₂ : Multiset α) :
    (s₁ + s₂).fold op (b₁ * b₂) = s₁.fold op b₁ * s₂.fold op b₂
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] protected theorem zero_add (a : Int) : 0 + a = a
-- Mathlib/LinearAlgebra/PerfectPairing.lean
@[simp] lemma flip_flip (h : IsReflexive R N := isReflexive_of_equiv_dual_of_isReflexive e) :
    e.flip.flip = e
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_ne_top_of_nonneg {x : ℝ≥0∞} {y : ℝ} (hy0 : 0 ≤ y) (h : x ≠ ⊤) : x ^ y ≠ ⊤
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- The angle ∡ABB at a point. -/
@[simp]
theorem oangle_self_right (p₁ p₂ : P) : ∡ p₁ p₂ p₂ = 0
-- Mathlib/LinearAlgebra/Dual.lean
theorem range_dualMap_eq_dualAnnihilator_ker_of_surjective (f : M →ₗ[R] M')
    (hf : Function.Surjective f) : LinearMap.range f.dualMap = f.ker.dualAnnihilator
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
@[simp]
theorem Basis.ofRankEqZero_apply [Module.Free K V] {ι : Type*} [IsEmpty ι]
    (hV : Module.rank K V = 0) (i : ι) : Basis.ofRankEqZero hV i = 0
-- Mathlib/Topology/Order/Bornology.lean
lemma isBounded_iff_bddBelow_bddAbove : IsBounded s ↔ BddBelow s ∧ BddAbove s
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem measurePreserving_div_left (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : MeasurePreserving (fun t => g / t) μ μ
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp)]
theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem EuclideanSpace.ball_zero_eq {n : Type*} [Fintype n] (r : ℝ) (hr : 0 ≤ r) :
    Metric.ball (0 : EuclideanSpace ℝ n) r = {x | ∑ i, x i ^ 2 < r ^ 2}
-- Mathlib/Data/Matrix/Block.lean
theorem fromBlocks_smul [SMul R α] (x : R) (A : Matrix n l α) (B : Matrix n m α) (C : Matrix o l α)
    (D : Matrix o m α) : x • fromBlocks A B C D = fromBlocks (x • A) (x • B) (x • C) (x • D)
-- Mathlib/Algebra/Lie/Abelian.lean
@[simp]
theorem coe_linearMap_maxTrivLinearMapEquivLieModuleHom_symm (f : M →ₗ⁅R,L⁆ N) :
    (maxTrivLinearMapEquivLieModuleHom.symm f : M →ₗ[R] N) = (f : M →ₗ[R] N)
-- .lake/packages/lean4/src/lean/Init/Data/String/Extra.lean
theorem Iterator.sizeOf_next_lt_of_hasNext (i : String.Iterator) (h : i.hasNext) : sizeOf i.next < sizeOf i
-- Mathlib/Data/Finset/Image.lean
@[mono]
theorem fin_mono {n} : Monotone (Finset.fin n)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem algebraMap_apply (h : IsAdjoinRoot S f) (x : R) :
    algebraMap R S x = h.map (Polynomial.C x)
-- Mathlib/Data/Nat/GCD/Basic.lean
/-- If `k:ℕ` divides coprime `a` and `b` then `k = 1` -/
theorem eq_one_of_dvd_coprimes {a b k : ℕ} (h_ab_coprime : Coprime a b) (hka : k ∣ a)
    (hkb : k ∣ b) : k = 1
-- Mathlib/Algebra/Category/Grp/EquivalenceGroupAddGroup.lean
/-- The functor `Group ⥤ AddGroup` by sending `X ↦ additive X` and `f ↦ f`.
-/
@[simps]
def toAddGrp : Grp ⥤ AddGrp
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem mk_add_moveRight_inl {xl xr yl yr} {xL xR yL yR} {i} :
    (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inl i) =
      (mk xl xr xL xR).moveRight i + mk yl yr yL yR
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem trinomial_natDegree (hkm : k < m) (hmn : m < n) (hw : w ≠ 0) :
    (trinomial k m n u v w).natDegree = n
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[congr]
theorem dite_congr {_ : Decidable b} [Decidable c]
    {x : b → α} {u : c → α} {y : ¬b → α} {v : ¬c → α}
    (h₁ : b = c)
    (h₂ : (h : c)  → x (h₁.mpr_prop h) = u h)
    (h₃ : (h : ¬c) → y (h₁.mpr_not h)  = v h) :
    dite b x y = dite c u v
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_upperClosure : x ∈ upperClosure s ↔ ∃ a ∈ s, a ≤ x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Swapping the two vectors passed to `oangle` negates the angle. -/
theorem oangle_rev (x y : V) : o.oangle y x = -o.oangle x y
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem HasFDerivAt.log (hf : HasFDerivAt f f' x) (hx : f x ≠ 0) :
    HasFDerivAt (fun x => log (f x)) ((f x)⁻¹ • f') x
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma LSeriesHasSum_congr {f g : ℕ → ℂ} (s a : ℂ) (h : ∀ {n}, n ≠ 0 → f n = g n) :
    LSeriesHasSum f s a ↔ LSeriesHasSum g s a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_pos (h : 0 < a) : 0 < a^n
-- Mathlib/Data/Ordmap/Ordset.lean
theorem empty_iff {s : Ordset α} : s = ∅ ↔ s.1.empty
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
@[simp]
lemma exact_op_iff : S.op.Exact ↔ S.Exact
-- Mathlib/Data/Holor.lean
theorem cprankMax_1 [Monoid α] [AddMonoid α] {x : Holor α ds} (h : CPRankMax1 x) :
    CPRankMax 1 x
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive]
theorem MeasurableSet.inv {s : Set G} (hs : MeasurableSet s) : MeasurableSet s⁻¹
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem degree_mul_comm (hp : p.Monic) (q : R[X]) : (p * q).degree = (q * p).degree
-- Mathlib/Data/Fin/Basic.lean
lemma succAbove_of_succ_le (p : Fin (n + 1)) (i : Fin n) (h : succ i ≤ p) :
    p.succAbove i = castSucc i
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_lt_cos_of_nonneg_of_le_pi {x y : ℝ} (hx₁ : 0 ≤ x) (hy₂ : y ≤ π) (hxy : x < y) :
    cos y < cos x
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem HasGradientAt.congr_of_eventuallyEq (h : HasGradientAt f f' x) (h₁ : f₁ =ᶠ[𝓝 x] f) :
    HasGradientAt f₁ f' x
-- Mathlib/CategoryTheory/GradedObject/Monoidal.lean
@[reassoc (attr := simp)]
lemma ι_tensorHom {X₁ X₂ Y₁ Y₂ : GradedObject I C} (f : X₁ ⟶ X₂) (g : Y₁ ⟶ Y₂)
    [HasTensor X₁ Y₁] [HasTensor X₂ Y₂] (i₁ i₂ i₁₂ : I) (h : i₁ + i₂ = i₁₂) :
    ιTensorObj X₁ Y₁ i₁ i₂ i₁₂ h ≫ tensorHom f g i₁₂ =
      (f i₁ ⊗ g i₂) ≫ ιTensorObj X₂ Y₂ i₁ i₂ i₁₂ h
-- Mathlib/Algebra/Order/Group/PosPart.lean
/-- See also `leOnePart_le_one`. -/
@[to_additive "See also `negPart_nonpos`."]
lemma leOnePart_le_one' : a⁻ᵐ ≤ 1 ↔ a⁻¹ ≤ 1
-- Mathlib/ModelTheory/Satisfiability.lean
theorem exists_model_card_eq (h : ∃ M : ModelType.{u, v, max u v} T, Infinite M) (κ : Cardinal.{w})
    (h1 : ℵ₀ ≤ κ) (h2 : Cardinal.lift.{w} L.card ≤ Cardinal.lift.{max u v} κ) :
    ∃ N : ModelType.{u, v, w} T, #N = κ
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem inseparable_iff_ker_uniformity {x y : α} : Inseparable x y ↔ (x, y) ∈ (𝓤 α).ker
-- Mathlib/Analysis/Calculus/Rademacher.lean
/-- *Rademacher's theorem*: a function between finite-dimensional real vector spaces which is
Lipschitz on a set is differentiable almost everywere in this set. -/
theorem ae_differentiableWithinAt {f : E → F} (hf : LipschitzOnWith C f s)
    (hs : MeasurableSet s) :
    ∀ᵐ x ∂(μ.restrict s), DifferentiableWithinAt ℝ f s x
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
theorem norm_compMeasurePreserving (g : Lp E p μb) (hf : MeasurePreserving f μ μb) :
    ‖compMeasurePreserving f hf g‖ = ‖g‖
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem toSubalgebra_inj {S U : StarSubalgebra R A} : S.toSubalgebra = U.toSubalgebra ↔ S = U
-- Mathlib/Combinatorics/Colex.lean
/-- Being a nonempty initial segment of colex is equivalent to being an `initSeg`. -/
lemma isInitSeg_iff_exists_initSeg :
    IsInitSeg 𝒜 r ∧ 𝒜.Nonempty ↔ ∃ s : Finset α, s.card = r ∧ 𝒜 = initSeg s
-- Mathlib/Data/Set/Finite.lean
theorem Finite.iSup_biInf_of_monotone {ι ι' α : Type*} [Preorder ι'] [Nonempty ι']
    [IsDirected ι' (· ≤ ·)] [Order.Frame α] {s : Set ι} (hs : s.Finite) {f : ι → ι' → α}
    (hf : ∀ i ∈ s, Monotone (f i)) : ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem toMeasure_apply_of_finite (hs : s.Finite) : p.toMeasure s = ∑' x, s.indicator p x
-- Mathlib/Data/Option/NAry.lean
/-- If `a` is a left identity for a binary operation `f`, then `some a` is a left identity for
`Option.map₂ f`. -/
lemma map₂_left_identity {f : α → β → β} {a : α} (h : ∀ b, f a b = b) (o : Option β) :
    map₂ f (some a) o = o
-- Mathlib/Data/Nat/Defs.lean
@[simp]
protected theorem not_two_dvd_bit1 (n : ℕ) : ¬2 ∣ 2 * n + 1
-- Mathlib/Order/LiminfLimsup.lean
theorem isBounded_le_of_top [Preorder α] [OrderTop α] {f : Filter α} : f.IsBounded (· ≤ ·)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp 1001]
theorem constantCoeff_smul {R : Type*} [SMulZeroClass R S₁] (a : R) (f : MvPolynomial σ S₁) :
    constantCoeff (a • f) = a • constantCoeff f
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- A left homology data for a short complex `S` in the opposite category
induces a right homology data for `S.unop`. -/
@[simps]
def unop {S : ShortComplex Cᵒᵖ} (h : S.LeftHomologyData) : S.unop.RightHomologyData
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- If three points are not collinear, the second and third are different. -/
theorem ne₂₃_of_not_collinear {p₁ p₂ p₃ : P} (h : ¬Collinear k ({p₁, p₂, p₃} : Set P)) :
    p₂ ≠ p₃
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
@[simp] theorem if_false {_ : Decidable False} (t e : α) : ite False t e = e
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma summable_jacobiTheta₂_term_fderiv_iff (z τ : ℂ) :
    Summable (jacobiTheta₂_term_fderiv · z τ) ↔ 0 < im τ
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
theorem AEMeasurable.ae_eq_of_forall_setLIntegral_eq {f g : α → ℝ≥0∞} (hf : AEMeasurable f μ)
    (hg : AEMeasurable g μ) (hfi : ∫⁻ x, f x ∂μ ≠ ∞) (hgi : ∫⁻ x, g x ∂μ ≠ ∞)
    (hfg : ∀ ⦃s⦄, MeasurableSet s → μ s < ∞ → ∫⁻ x in s, f x ∂μ = ∫⁻ x in s, g x ∂μ) :
    f =ᵐ[μ] g
-- Mathlib/Data/Vector/Defs.lean
/-- The tail of a vector obtained by prepending is the vector prepended. to -/
theorem tail_cons (a : α) : ∀ v : Vector α n, tail (cons a v) = v
-- Mathlib/Order/Sublattice.lean
@[simp, norm_cast] lemma coe_iInf (f : ι → Sublattice α) : ⨅ i, f i = ⋂ i, (f i : Set α)
-- Mathlib/Topology/FiberBundle/Basic.lean
/-- For a fiber bundle `E` over `B` constructed using the `FiberPrebundle` mechanism,
continuity of a function `TotalSpace F E → X` on an open set `s` can be checked by precomposing at
each point with the pretrivialization used for the construction at that point. -/
theorem continuousOn_of_comp_right {X : Type*} [TopologicalSpace X] {f : TotalSpace F E → X}
    {s : Set B} (hs : IsOpen s) (hf : ∀ b ∈ s,
      ContinuousOn (f ∘ (a.pretrivializationAt b).toPartialEquiv.symm)
        ((s ∩ (a.pretrivializationAt b).baseSet) ×ˢ (Set.univ : Set F))) :
    @ContinuousOn _ _ a.totalSpaceTopology _ f (π F E ⁻¹' s)
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem mk_eq_inl_mul_inr (g : G) (n : N) : (⟨n, g⟩ : N ⋊[φ] G) = inl n * inr g
-- Mathlib/Topology/Basic.lean
theorem clusterPt_iff_lift'_closure' {F : Filter X} :
    ClusterPt x F ↔ (F.lift' closure ⊓ pure x).NeBot
-- Mathlib/Logic/Basic.lean
@[simp] theorem exists_or_eq_left' (y : α) (p : α → Prop) : ∃ x : α, y = x ∨ p x
-- Mathlib/Algebra/Order/Field/Basic.lean
/-- In a linear ordered field, for positive `a` and `b` we have `a⁻¹ ≤ b ↔ b⁻¹ ≤ a`.
See also `inv_le_of_inv_le` for a one-sided implication with one fewer assumption. -/
theorem inv_le (ha : 0 < a) (hb : 0 < b) : a⁻¹ ≤ b ↔ b⁻¹ ≤ a
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Compare.lean
/--
Proof that the equality of a compare function corresponds
to propositional equality with respect to a given function.
-/
class EqOfCmpWrt (α : Type u) {β : Type v} (f : α → β) (cmp : α → α → Ordering) where
  eq_of_cmp_wrt {a a' : α} : cmp a a' = .eq → f a = f a'
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
/-- The identity is 1-Lipschitz. -/
protected theorem id : LipschitzWith 1 (@id α)
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
@[to_additive]
nonrec theorem SmoothWithinAt.div {f g : M → G} {s : Set M} {x₀ : M}
    (hf : SmoothWithinAt I' I f s x₀) (hg : SmoothWithinAt I' I g s x₀) :
    SmoothWithinAt I' I (fun x => f x / g x) s x₀
-- Mathlib/RingTheory/Nakayama.lean
/-- **Nakayama's Lemma** - A slightly more general version of (2) in
[Stacks 00DV](https://stacks.math.columbia.edu/tag/00DV).
See also `eq_bot_of_le_smul_of_le_jacobson_bot` for the special case when `J = ⊥`.  -/
theorem eq_smul_of_le_smul_of_le_jacobson {I J : Ideal R} {N : Submodule R M} (hN : N.FG)
    (hIN : N ≤ I • N) (hIjac : I ≤ jacobson J) : N = J • N
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp] theorem of_add (x y : HahnSeries Γ V) : of R (x + y) = of R x + of R y
-- Mathlib/MeasureTheory/Measure/Regular.lean
protected theorem smul [WeaklyRegular μ] {x : ℝ≥0∞} (hx : x ≠ ∞) : (x • μ).WeaklyRegular
-- Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean
@[simp]
theorem liftFOne_zero_comm {Y Z : C} (f : Y ⟶ Z) (P : ProjectiveResolution Y)
    (Q : ProjectiveResolution Z) :
    liftFOne f P Q ≫ Q.complex.d 1 0 = P.complex.d 1 0 ≫ liftFZero f P Q
-- Mathlib/Data/List/Indexes.lean
@[simp]
theorem length_mapIdx (l : List α) (f : ℕ → α → β) : (l.mapIdx f).length = l.length