ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Set/Lattice.lean
theorem biUnion_range {f : ι → α} {g : α → Set β} : ⋃ x ∈ range f, g x = ⋃ y, g (f y)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem toAddSubmonoid_injective :
    Function.Injective (toAddSubmonoid : NonUnitalSubsemiring R → AddSubmonoid R)
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
lemma ofReal_mem_slitPlane {x : ℝ} : ↑x ∈ slitPlane ↔ 0 < x
-- Mathlib/Analysis/Analytic/Basic.lean
/-- For any function `f` from a normed vector space to a Banach space, the set of points `x` such
that `f` is analytic at `x` is open. -/
theorem isOpen_analyticAt : IsOpen { x | AnalyticAt 𝕜 f x }
-- Mathlib/CategoryTheory/Iso.lean
theorem inv_eq_inv (f g : X ≅ Y) : f.inv = g.inv ↔ f.hom = g.hom
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem aestronglyMeasurable'_condexpL1CLM (f : α →₁[μ] F') :
    AEStronglyMeasurable' m (condexpL1CLM F' hm μ f) μ
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem eq_spanSingleton_mul {x : P} {I J : FractionalIdeal S P} :
    I = spanSingleton _ x * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I
-- Mathlib/RingTheory/Localization/NumDen.lean
theorem isInteger_of_isUnit_den {x : K} (h : IsUnit (den A x : A)) : IsInteger A x
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem monotoneOn_rpow_Ici_of_exponent_nonneg {r : ℝ} (hr : 0 ≤ r) :
    MonotoneOn (fun (x : ℝ) => x ^ r) (Set.Ici 0)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
@[simp]
theorem inv_mul_cancel_left_of_invertible (B : Matrix n m α) [Invertible A] : A⁻¹ * (A * B) = B
-- Mathlib/Order/WellFoundedSet.lean
/-- In a linear order, the predicates `Set.IsWF` and `Set.IsPWO` are equivalent. -/
theorem isWF_iff_isPWO : s.IsWF ↔ s.IsPWO
-- Mathlib/Analysis/SpecificLimits/Basic.lean
lemma tendsto_nat_floor_mul_atTop {α : Type _} [LinearOrderedSemifield α] [FloorSemiring α]
    [Archimedean α] (a : α) (ha : 0 < a) : Tendsto (fun (x : ℕ) => ⌊a * x⌋₊) atTop atTop
-- Mathlib/CategoryTheory/Functor/Flat.lean
theorem fac (x : J) : lift F hc s ≫ (F.mapCone c).π.app x = s.π.app x
-- Mathlib/Analysis/Analytic/Polynomial.lean
theorem AnalyticAt.aeval_mvPolynomial (hf : ∀ i, AnalyticAt 𝕜 (f · i) z) (p : MvPolynomial σ A) :
    AnalyticAt 𝕜 (fun x ↦ aeval (f x) p) z
-- Mathlib/Analysis/RCLike/Basic.lean
theorem abs_im_le_norm (z : K) : |im z| ≤ ‖z‖
-- Mathlib/Topology/Filter.lean
@[simp]
theorem specializes_iff_le {l₁ l₂ : Filter α} : l₁ ⤳ l₂ ↔ l₁ ≤ l₂
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_mono' {s : Set α} {f g : α → ℝ≥0∞} (hs : MeasurableSet s)
    (hfg : ∀ x ∈ s, f x ≤ g x) : ∫⁻ x in s, f x ∂μ ≤ ∫⁻ x in s, g x ∂μ
-- Mathlib/Data/Nat/Digits.lean
theorem sub_one_mul_sum_div_pow_eq_sub_sum_digits {p : ℕ}
    (L : List ℕ) {h_nonempty} (h_ne_zero : L.getLast h_nonempty ≠ 0) (h_lt : ∀ l ∈ L, l < p) :
    (p - 1) * ∑ i ∈ range L.length, (ofDigits p L) / p ^ i.succ = (ofDigits p L) - L.sum
-- Mathlib/Probability/ConditionalProbability.lean
@[simp]
theorem cond_empty : μ[|∅] = 0
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem compSL_apply (f : F →SL[σ₂₃] G) (g : E →SL[σ₁₂] F) : compSL E F G σ₁₂ σ₂₃ f g = f.comp g
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If a function `f` tends to infinity along a filter, then `f` divided by a positive
constant also tends to infinity. -/
theorem Tendsto.atTop_div_const (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x / r) l atTop
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp, norm_cast]
theorem zero_apply (i) : (0 : CauSeq β abv) i = 0
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
lemma apply_toDual_symm_apply {B : BilinForm K V} {hB : B.Nondegenerate}
    (f : Module.Dual K V) (v : V) :
    B ((B.toDual hB).symm f) v = f v
-- Mathlib/Data/Finset/NatAntidiagonal.lean
/-- The antidiagonal of `0` is the list `[(0, 0)]` -/
@[simp]
theorem antidiagonal_zero : antidiagonal 0 = {(0, 0)}
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem choice_mem_aux (h : ∅ ∉ x) (y : ZFSet.{u}) (yx : y ∈ x) :
    (Classical.epsilon fun z : ZFSet.{u} => z ∈ y) ∈ y
-- Mathlib/Topology/Order/LawsonTopology.lean
lemma singleton_isClosed (a : α) : IsClosed ({a} : Set α)
-- Mathlib/CategoryTheory/Shift/ShiftedHom.lean
lemma comp_map {a : M} (f : ShiftedHom X Y a) (F : C ⥤ D) [F.CommShift M]
    (G : D ⥤ E) [G.CommShift M] : f.map (F ⋙ G) = (f.map F).map G
-- Mathlib/SetTheory/Surreal/Basic.lean
/-- A small set of surreals is bounded above. -/
lemma bddAbove_of_small (s : Set Surreal.{u}) [Small.{u} s] : BddAbove s
-- Mathlib/Data/ZMod/Basic.lean
theorem val_add {n : ℕ} [NeZero n] (a b : ZMod n) : (a + b).val = (a.val + b.val) % n
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem dist_t₀_le (t : Icc v.tMin v.tMax) : dist t v.t₀ ≤ v.tDist
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
lemma rightShift_v (a n' : ℤ) (hn' : n' + a = n) (p q : ℤ) (hpq : p + n' = q)
    (p' : ℤ) (hp' : p + n = p') :
    (γ.rightShift a n' hn').v p q hpq = γ.v p p' hp' ≫
      (L.shiftFunctorObjXIso a q p' (by rw [← hp', ← hpq, ← hn', add_assoc])).inv
-- Mathlib/Computability/Partrec.lean
theorem rfind_spec {p : ℕ →. Bool} {n : ℕ} (h : n ∈ rfind p) : true ∈ p n
-- Mathlib/Algebra/BigOperators/Ring.lean
lemma sum_range_succ_mul_sum_range_succ (m n : ℕ) (f g : ℕ → α) :
    (∑ i ∈ range (m + 1), f i) * ∑ i ∈ range (n + 1), g i =
      (∑ i ∈ range m, f i) * ∑ i ∈ range n, g i +
        f m * ∑ i ∈ range n, g i + (∑ i ∈ range m, f i) * g n + f m * g n
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem dotProduct_smul [SMulCommClass R α α] (x : R) (v w : m → α) :
    v ⬝ᵥ x • w = x • (v ⬝ᵥ w)
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_or_odd' (n : ℕ) : ∃ k, n = 2 * k ∨ n = 2 * k + 1
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_le_mul_of_nonpos_right [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (h : b ≤ a) (hc : c ≤ 0) : a * c ≤ b * c
-- Mathlib/Data/Part.lean
@[simp]
theorem mem_bind_iff {f : Part α} {g : α → Part β} {b} : b ∈ f.bind g ↔ ∃ a ∈ f, b ∈ g a
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem wbtw_one_zero_iff {x : R} : Wbtw R 1 x 0 ↔ x ∈ Set.Icc (0 : R) 1
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_finsupp_sum (since := "2024-06-26")]
protected theorem map_finsupp_sum {α : Type*} [Zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A) :
    φ (f.sum g) = f.sum fun i a => φ (g i a)
-- Mathlib/Topology/Semicontinuous.lean
theorem Continuous.upperSemicontinuous {f : α → γ} (h : Continuous f) : UpperSemicontinuous f
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem map_reverse (f : α → β) (l : List α) : l.reverse.map f = (l.map f).reverse
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
/-- Shows that
$\sum_{k = 0}^{n - 1} (e^{X})^k = \sum_{p = 0}^{\infty} \sum_{k = 0}^{n - 1} \frac{k^p}{p!}X^p$. -/
theorem exp_pow_sum [Algebra ℚ A] (n : ℕ) :
    ((Finset.range n).sum fun k => exp A ^ k) =
      PowerSeries.mk fun p => (Finset.range n).sum
        fun k => (k ^ p : A) * algebraMap ℚ A p.factorial⁻¹
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem Fin.circulant_isSymm_iff : ∀ {n} {v : Fin n → α}, (circulant v).IsSymm ↔ ∀ i, v (-i) = v i
-- Mathlib/Data/PEquiv.lean
@[simp]
theorem refl_trans (f : α ≃. β) : (PEquiv.refl α).trans f = f
-- Mathlib/Order/Filter/NAry.lean
/-- Symmetric statement to `Filter.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {n : γ → δ} {m' : β' → α → δ} {n' : β → β'}
    (h_antidistrib : ∀ a b, n (m a b) = m' (n' b) a) : (map₂ m f g).map n = map₂ m' (g.map n') f
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem ContinuousMultilinearMap.fin0_apply_norm (f : G[×0]→L[𝕜] G') {x : Fin 0 → G} :
    ‖f x‖ = ‖f‖
-- Mathlib/Data/Sum/Basic.lean
theorem Injective.sum_map {f : α → β} {g : α' → β'} (hf : Injective f) (hg : Injective g) :
    Injective (Sum.map f g)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem utf8ByteSize.go_eq : utf8ByteSize.go = utf8Len
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The L-series of a Dirichlet character converges absolutely at `s` if `re s > 1`. -/
lemma LSeriesSummable_of_one_lt_re {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :
    LSeriesSummable ↗χ s
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[simp, reassoc]
lemma comp_hom₁ {X Y Z : Triangle C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).hom₁ = f.hom₁ ≫ g.hom₁
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_le_iff {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] : type r ≤ type s ↔ Nonempty (r ≼i s)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
@[simp]
theorem rotationAux_apply (θ : Real.Angle) (x : V) :
    o.rotationAux θ x = Real.Angle.cos θ • x + Real.Angle.sin θ • J x
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
theorem _root_.MeasurableEmbedding.stronglyMeasurable_extend {f : α → β} {g : α → γ} {g' : γ → β}
    {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} [TopologicalSpace β]
    (hg : MeasurableEmbedding g) (hf : StronglyMeasurable f) (hg' : StronglyMeasurable g') :
    StronglyMeasurable (Function.extend g f g')
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
theorem one_apply (x : M) : (1 : Module.End R M) x = x
-- Mathlib/Topology/Order.lean
theorem generateFrom_union_isOpen (a b : TopologicalSpace α) :
    generateFrom ({ s | IsOpen[a] s } ∪ { s | IsOpen[b] s }) = a ⊓ b
-- Mathlib/Data/Finset/Basic.lean
protected lemma Nontrivial.erase_nonempty (hs : s.Nontrivial) : (s.erase a).Nonempty
-- Mathlib/Algebra/Order/Sub/Canonical.lean
/-- See `add_tsub_le_assoc` for an inequality. -/
theorem add_tsub_assoc_of_le (h : c ≤ b) (a : α) : a + b - c = a + (b - c)
-- Mathlib/Data/Quot.lean
theorem ind {β : Trunc α → Prop} : (∀ a : α, β (mk a)) → ∀ q : Trunc α, β q
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The Law of Quadratic Reciprocity for the Jacobi symbol: if `a` and `b` are natural numbers
with `a` odd and `b % 4 = 1`, then `J(a | b) = J(b | a)`. -/
theorem quadratic_reciprocity_one_mod_four' {a b : ℕ} (ha : Odd a) (hb : b % 4 = 1) :
    J(a | b) = J(b | a)
-- Mathlib/Topology/Algebra/Valued/ValuedField.lean
theorem closure_coe_completion_v_lt {γ : Γ₀ˣ} :
    closure ((↑) '' { x : K | v x < (γ : Γ₀) }) =
    { x : hat K | extensionValuation x < (γ : Γ₀) }
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Bool.beq_to_eq (a b : Bool) :
  (a == b) = (a = b)
-- Mathlib/Order/LiminfLimsup.lean
theorem blimsup_eq_limsup_subtype {f : Filter β} {u : β → α} {p : β → Prop} :
    blimsup u f p = limsup (u ∘ ((↑) : { x | p x } → β)) (comap (↑) f)
-- Mathlib/RingTheory/Generators.lean
lemma Cotangent.map_comp (f : Hom P P') (g : Hom P' P'') :
    Cotangent.map (g.comp f) = (map g).restrictScalars S ∘ₗ map f
-- Mathlib/Topology/Category/LightProfinite/Limits.lean
@[reassoc]
lemma pullback.condition : pullback.fst f g ≫ f = pullback.snd f g ≫ g
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumArrowEquivProdArrow_symm_apply_inl (f : α → γ) (g : β → γ) (a : α) :
    ((sumArrowEquivProdArrow α β γ).symm (f, g)) (inl a) = f a
-- Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean
/-- The composition of two based functors. -/
@[simps]
def comp {𝒵 : BasedCategory.{v₄, u₄} 𝒮} (F : 𝒳 ⥤ᵇ 𝒴) (G : 𝒴 ⥤ᵇ 𝒵) : 𝒳 ⥤ᵇ 𝒵
-- Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean
theorem monotone (hS : S ≤ S') : K⟮S,n⟯ ≤ K⟮S',n⟯
-- Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean
@[simp]
theorem lanLiftCompIsoWhisker_inv_right :
    (lanLiftCompIsoWhisker f g h).inv.right = (isKan f g h).desc (lanLiftLeftLift f (h ≫ g))
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem ofNat_natAbs (a : Int) : (a.natAbs : Int) = if 0 ≤ a then a else -a
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Subperm.erase {l₁ l₂ : List α} (a : α) (h : l₁ <+~ l₂) : l₁.erase a <+~ l₂.erase a
-- Mathlib/Data/List/MinMax.lean
theorem mem_argmax_iff :
    m ∈ argmax f l ↔
      m ∈ l ∧ (∀ a ∈ l, f a ≤ f m) ∧ ∀ a ∈ l, f m ≤ f a → l.indexOf m ≤ l.indexOf a
-- Mathlib/Order/LiminfLimsup.lean
theorem not_isBoundedUnder_of_tendsto_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    [l.NeBot] (hf : Tendsto f l atBot) : ¬IsBoundedUnder (· ≥ ·) l f
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_comp_neg : (∫ x in a..b, f (-x)) = ∫ x in -b..-a, f x
-- Mathlib/Analysis/Calculus/ContDiff/RCLike.lean
/-- If `f` has a formal Taylor series `p` up to order `1` on `{x} ∪ s`, where `s` is a convex set,
then `f` is Lipschitz in a neighborhood of `x` within `s`. -/
theorem HasFTaylorSeriesUpToOn.exists_lipschitzOnWith {E F : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] {f : E → F}
    {p : E → FormalMultilinearSeries ℝ E F} {s : Set E} {x : E}
    (hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)) (hs : Convex ℝ s) :
    ∃ K, ∃ t ∈ 𝓝[s] x, LipschitzOnWith K f t
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[simp]
theorem range_zmultiplesHom (a : A) : (zmultiplesHom A a).range = zmultiples a
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The inner product between a multiple of a `π / 2` rotation of a vector and that vector is
zero. -/
@[simp]
theorem inner_smul_rotation_pi_div_two_left (x : V) (r : ℝ) :
    ⟪r • o.rotation (π / 2 : ℝ) x, x⟫ = 0
-- Mathlib/Topology/Inseparable.lean
theorem preimage_mk_closure : mk ⁻¹' closure t = closure (mk ⁻¹' t)
-- Mathlib/Data/List/EditDistance/Defs.lean
theorem suffixLevenshtein_eq_tails_map (xs ys) :
    (suffixLevenshtein C xs ys).1 = xs.tails.map fun xs' => levenshtein C xs' ys
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem ListBlank.map_cons {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) (a : Γ) : (l.cons a).map f = (l.map f).cons (f a)
-- Mathlib/Order/Interval/Finset/Fin.lean
theorem uIcc_eq_finset_subtype : uIcc a b = (uIcc (a : ℕ) b).fin n
-- Mathlib/Order/Grade.lean
@[simp]
theorem grade_lt_grade_iff : grade 𝕆 a < grade 𝕆 b ↔ a < b
-- Mathlib/Probability/Process/Stopping.lean
theorem memℒp_stoppedProcess [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Memℒp (u n) p μ) (n : ι) : Memℒp (stoppedProcess u τ n) p μ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_iff_le_not_le {a b : Int} : a < b ↔ a ≤ b ∧ ¬b ≤ a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem zero_rpow_le_one (x : ℝ) : (0 : ℝ) ^ x ≤ 1
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
/-- Given a category `C` equipped with a Grothendieck topology `J` and a concrete category `A`,
this property holds if a morphism in `Cᵒᵖ ⥤ A` satisfies `J.W` (i.e. becomes an iso after
sheafification) iff it is both locally injective and locally surjective. -/
class WEqualsLocallyBijective : Prop where
  iff {X Y : Cᵒᵖ ⥤ A} (f : X ⟶ Y) :
    J.W f ↔ Presheaf.IsLocallyInjective J f ∧ Presheaf.IsLocallySurjective J f
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem sdiff_inter_self_right (s t : Finset α) : s \ (t ∩ s) = s \ t
-- Mathlib/Analysis/Fourier/FourierTransform.lean
lemma fourierIntegral_eq' (f : V → E) (w : V) :
    𝓕 f w = ∫ v, Complex.exp ((↑(-2 * π * ⟪v, w⟫) * Complex.I)) • f v
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem congToClass_empty : congToClass ∅ = ∅
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem integral_condCDF (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (x : ℝ) :
    ∫ a, condCDF ρ a x ∂ρ.fst = (ρ (univ ×ˢ Iic x)).toReal
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem sup'_singleton {b : β} : ({b} : Finset β).sup' (singleton_nonempty _) f = f b
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
private lemma adic_exact : Function.Exact (map I (LinearMap.ker f).subtype) (map I f)
-- Mathlib/Analysis/Convex/Jensen.lean
/-- Convex **Jensen's inequality**, `Finset.sum` version. -/
theorem ConvexOn.map_sum_le (hf : ConvexOn 𝕜 s f) (h₀ : ∀ i ∈ t, 0 ≤ w i) (h₁ : ∑ i ∈ t, w i = 1)
    (hmem : ∀ i ∈ t, p i ∈ s) : f (∑ i ∈ t, w i • p i) ≤ ∑ i ∈ t, w i • f (p i)
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- Along a mono that is not an iso, the cardinality of the fiber strictly increases. -/
lemma lt_card_fiber_of_mono_of_notIso {X Y : C} (f : X ⟶ Y) [Mono f]
    (h : ¬ IsIso f) : Nat.card (F.obj X) < Nat.card (F.obj Y)
-- .lake/packages/lean4/src/lean/Init/WF.lean
theorem accessible {z : α} (ac : Acc r z) : Acc (TC r) z
-- Mathlib/Logic/Function/Iterate.lean
@[simp]
theorem iterate_id (n : ℕ) : (id : α → α)^[n] = id
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivQuotOfLE_symm_comp_mkₐ (h : I ≤ J) :
    AlgHom.comp (↑(quotQuotEquivQuotOfLEₐ R h).symm) (Quotient.mkₐ R J) = quotQuotMkₐ R I J
-- Mathlib/GroupTheory/Perm/Basic.lean
lemma BijOn.perm_zpow (hf : BijOn f s s) : ∀ n : ℤ, BijOn (f ^ n) s s
-- Mathlib/Topology/Instances/ENNReal.lean
/-- For a bounded set `s : Set ℝ`, its `EMetric.diam` is equal to `sSup s - sInf s` reinterpreted as
`ℝ≥0∞`. -/
theorem ediam_eq {s : Set ℝ} (h : Bornology.IsBounded s) :
    EMetric.diam s = ENNReal.ofReal (sSup s - sInf s)
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem lift_unique (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (l : M' →ₗ[R] M'') (hl : l.comp f = g) : lift S f g h = l
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasStrictFDerivAt.const_rpow (hf : HasStrictFDerivAt f f' x) (hc : 0 < c) :
    HasStrictFDerivAt (fun x => c ^ f x) ((c ^ f x * Real.log c) • f') x
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem dist_vadd_vadd_le (v v' : V) (p p' : P) :
    dist (v +ᵥ p) (v' +ᵥ p') ≤ dist v v' + dist p p'
-- Mathlib/Topology/Homeomorph.lean
theorem image_symm (h : X ≃ₜ Y) : image h.symm = preimage h
-- Mathlib/Order/Irreducible.lean
theorem SupIrred.finset_sup_eq (ha : SupIrred a) (h : s.sup f = a) : ∃ i ∈ s, f i = a
-- Mathlib/Topology/Order/Lattice.lean
lemma Continuous.finset_sup' (hne : s.Nonempty) (hs : ∀ i ∈ s, Continuous (f i)) :
    Continuous (s.sup' hne f)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem imp_intro {α β : Prop} (h : α) : β → α
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Rearrangement Inequality**: Pointwise multiplication of `f` and `g` is maximized when `f` and
`g` monovary together. Stated by permuting the entries of `f`. -/
theorem Monovary.sum_comp_perm_mul_le_sum_mul (hfg : Monovary f g) :
    ∑ i, f (σ i) * g i ≤ ∑ i, f i * g i
-- Mathlib/Data/Set/Sups.lean
@[simp]
theorem mem_infs : c ∈ s ⊼ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊓ b = c
-- Mathlib/Order/WellFounded.lean
protected theorem lt_sup {r : α → α → Prop} (wf : WellFounded r) {s : Set α} (h : Bounded r s) {x}
    (hx : x ∈ s) : r x (wf.sup s h)
-- Mathlib/RingTheory/Nilpotent/Defs.lean
theorem isReduced_of_injective [MonoidWithZero R] [MonoidWithZero S] {F : Type*}
    [FunLike F R S] [MonoidWithZeroHomClass F R S]
    (f : F) (hf : Function.Injective f) [IsReduced S] :
    IsReduced R
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffWithinAt.div [CompleteSpace 𝕜] {f g : E → 𝕜} {n} (hf : ContDiffWithinAt 𝕜 n f s x)
    (hg : ContDiffWithinAt 𝕜 n g s x) (hx : g x ≠ 0) :
    ContDiffWithinAt 𝕜 n (fun x => f x / g x) s x
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
theorem hasEqualizer_of_common_retraction [HasCoreflexiveEqualizers C] {A B : C} {f g : A ⟶ B}
    (r : B ⟶ A) (fr : f ≫ r = 𝟙 _) (gr : g ≫ r = 𝟙 _) : HasEqualizer f g
-- Mathlib/FieldTheory/NormalClosure.lean
theorem normalClosure_eq_iSup_adjoin [Algebra K L] [IsScalarTower F K L] [Normal F L] :
    normalClosure F K L = ⨆ x : K, adjoin F ((minpoly F x).rootSet L)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem div_eq_zero_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.div b = 0
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem Fin.circulant_injective : ∀ n, Injective fun v : Fin n → α => circulant v
-- Mathlib/Logic/Equiv/Defs.lean
theorem right_inv' (e : α ≃ β) : Function.RightInverse e.symm e
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem zero_mkRat (n) : mkRat 0 n = 0
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem repeat_apply {α : Type*} (a : Fin n → α) (i : Fin (m * n)) :
    Fin.repeat m a i = a i.modNat
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem mk_smul (c : R) (p q : K[X]) : RatFunc.mk (c • p) q = c • RatFunc.mk p q
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sigmaUncurry_single [∀ i j, Zero (δ i j)] [DecidableEq ι] [∀ i, DecidableEq (α i)]
    (i) (j : α i) (x : δ i j) :
    sigmaUncurry (single i (single j x : Π₀ j : α i, δ i j)) = single ⟨i, j⟩ (by exact x)
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_sInf (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ∞) :
    (sInf s).toReal = sInf (ENNReal.toReal '' s)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem hasStrictFDerivAt_list_prod' [Fintype ι] {l : List ι} {x : ι → 𝔸} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ (l.map x).prod)
      (∑ i : Fin l.length, ((l.take i).map x).prod •
        smulRight (proj (l.get i)) ((l.drop (.succ i)).map x).prod) x
-- Mathlib/Data/Seq/Computation.lean
theorem has_bind_eq_bind {β} (c : Computation α) (f : α → Computation β) : c >>= f = bind c f
-- Mathlib/Analysis/Convex/Side.lean
theorem isPreconnected_setOf_sSameSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.SSameSide x y }
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.toMatrix₂_comp (B : M₁ →ₗ[R] M₂ →ₗ[R] R) (f : M₁' →ₗ[R] M₁) :
    LinearMap.toMatrix₂ b₁' b₂ (B.comp f) =
      (toMatrix b₁' b₁ f)ᵀ * LinearMap.toMatrix₂ b₁ b₂ B
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
theorem multicofork_ι_app_right' (b) :
    colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.right b) = π I b
-- Mathlib/Algebra/ModEq.lean
@[simp]
theorem add_modEq_left : a + b ≡ a [PMOD p] ↔ b ≡ 0 [PMOD p]
-- Mathlib/Data/Nat/Size.lean
@[simp]
theorem size_zero : size 0 = 0
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem iUnion_def : π.iUnion = ⋃ J ∈ π, ↑J
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The fundamental property of the adjoint. -/
theorem adjoint_inner_right (A : E →L[𝕜] F) (x : E) (y : F) : ⟪x, (A†) y⟫ = ⟪A x, y⟫
-- Mathlib/Data/DFinsupp/Interval.lean
@[simp]
theorem card_pi (f : Π₀ i, Finset (α i)) : f.pi.card = f.prod fun i => (f i).card
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma Icc_subset_uIcc : Icc a b ⊆ [[a, b]]
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma baseChange_addX (x₁ x₂ L : A) :
    (W.baseChange B).toAffine.addX (f x₁) (f x₂) (f L) =
      f ((W.baseChange A).toAffine.addX x₁ x₂ L)
-- Mathlib/Data/Sym/Sym2.lean
@[simp]
theorem other_spec' [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z) : s(a, Mem.other' h) = z
-- Mathlib/Combinatorics/Schnirelmann.lean
lemma schnirelmannDensity_setOf_modeq_one {m : ℕ} :
    schnirelmannDensity {n | n ≡ 1 [MOD m]} = (m⁻¹ : ℝ)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_le_of_map_zero (x : ℝ) : f x ≤ f 0 + ⌈x⌉
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem zero_re : (0 : ℍ[R]).re = 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem ext_inner_left {x y : E} (h : ∀ v, ⟪v, x⟫ = ⟪v, y⟫) : x = y
-- Mathlib/Data/List/Infix.lean
theorem prefix_take_iff {x y : List α} {n : ℕ} : x <+: y.take n ↔ x <+: y ∧ x.length ≤ n
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.eq_bot : Disjoint a b → a ⊓ b = ⊥
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem Quotient.mkₐ_eq_mk (I : Ideal A) : ⇑(Quotient.mkₐ R₁ I) = Quotient.mk I
-- Mathlib/Data/Finsupp/Multiset.lean
@[simp]
theorem coe_orderIsoMultiset_symm [DecidableEq ι] :
    ⇑(@orderIsoMultiset ι).symm = Multiset.toFinsupp
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp] lemma ceilDiv_apply (f : ι →₀ β) (a : α) (i : ι) : (f ⌈/⌉ a) i = f i ⌈/⌉ a
-- Mathlib/Topology/UnitInterval.lean
theorem mul_le_right {x y : I} : x * y ≤ y
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem Countable.exists_cycleOn (hs : s.Countable) :
    ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s
-- Mathlib/Order/WithBot.lean
@[simp, deprecated le_top "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem le_none {a : WithTop α} : @LE.le (WithTop α) _ a none