ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem toString : ∀ {it}, ValidFor l r it → it.1 = ⟨l.reverseAux r⟩
-- Mathlib/Topology/Constructions.lean
theorem isOpen_sigma_fst_preimage (s : Set ι) : IsOpen (Sigma.fst ⁻¹' s : Set (Σ a, σ a))
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem eq_top_iff {S : NonUnitalStarSubalgebra R A} : S = ⊤ ↔ ∀ x : A, x ∈ S
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem ae_le_set : s ≤ᵐ[μ] t ↔ μ (s \ t) = 0
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_image :
    ∀ {γ} {f : β → γ} {g : γ → α} {t : Set β}, ⨅ c ∈ f '' t, g c = ⨅ b ∈ t, g (f b)
-- Mathlib/Data/Finset/Sups.lean
@[simp]
theorem infs_empty : s ⊼ ∅ = ∅
-- Mathlib/Data/Finset/Basic.lean
@[gcongr]
theorem union_subset_union (hsu : s ⊆ u) (htv : t ⊆ v) : s ∪ t ⊆ u ∪ v
-- Mathlib/Data/Option/Basic.lean
theorem pmap_bind {α β γ} {x : Option α} {g : α → Option β} {p : β → Prop} {f : ∀ b, p b → γ} (H)
    (H' : ∀ (a : α), ∀ b ∈ g a, b ∈ x >>= g) :
    pmap f (x >>= g) H = x >>= fun a ↦ pmap f (g a) fun b h ↦ H _ (H' a _ h)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem negSucc_not_nonneg (n : Nat) : 0 ≤ -[n+1] ↔ False
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive]
theorem measure_eq_tsum' (h : IsFundamentalDomain G s μ) (t : Set α) :
    μ t = ∑' g : G, μ (t ∩ g • s)
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- The infimum of a set of congruence relations is the same as the infimum of the set's image
    under the map to the underlying equivalence relation. -/
@[to_additive "The infimum of a set of additive congruence relations is the same as the infimum of
the set's image under the map to the underlying equivalence relation."]
theorem sInf_toSetoid (S : Set (Con M)) : (sInf S).toSetoid = sInf (toSetoid '' S)
-- Mathlib/Order/Lattice.lean
@[simp]
theorem inf_apply [∀ i, Inf (α' i)] (f g : ∀ i, α' i) (i : ι) : (f ⊓ g) i = f i ⊓ g i
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Ioo_bot : (some : α → WithBot α) ⁻¹' Ioo ⊥ a = Iio a
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma congr (h_eq : Set.EqOn f g U) (hu : IsOpen U) : MeromorphicOn g U
-- Mathlib/Data/Finset/NAry.lean
theorem biUnion_image_right : (t.biUnion fun b => s.image fun a => f a b) = image₂ f s t
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If a function `f` tends to negative infinity along a filter, then `f` multiplied by
a positive constant (on the right) also tends to negative infinity. -/
theorem Tendsto.atBot_mul_const (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atBot
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive indicator_compl]
theorem mulIndicator_compl' (s : Set α) (f : α → G) :
    mulIndicator sᶜ f = f / mulIndicator s f
-- Mathlib/Data/Set/Basic.lean
theorem subset_left_of_subset_union (h : s ⊆ t ∪ u) (hac : Disjoint s u) : s ⊆ t
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem MapsTo.restrict_surjective_iff (h : MapsTo f s t) :
    Surjective (MapsTo.restrict _ _ _ h) ↔ SurjOn f s t
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma div_mul_cancel_left₀ (ha : a ≠ 0) (b : G₀) : a / (a * b) = b⁻¹
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Fractions.lean
/-- This structure contains the data of two left fractions for
`W : MorphismProperty C` that have the same "denominator". -/
structure LeftFraction₂ (X Y : C) where
  /-- the auxiliary object of left fractions -/
  {Y' : C}
  /-- the numerator of the first left fraction -/
  f : X ⟶ Y'
  /-- the numerator of the second left fraction -/
  f' : X ⟶ Y'
  /-- the denominator of the left fractions -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp, fun_prop]
theorem DifferentiableAt.sub (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    DifferentiableAt 𝕜 (fun y => f y - g y) x
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem inv_mul_le_one_iff : a⁻¹ * b ≤ 1 ↔ b ≤ a
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[simp]
lemma Scheme.ofRestrict_appIso (U) :
    (X.ofRestrict h).appIso U = Iso.refl _
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
@[reassoc (attr := simp)]
lemma map_comp_map_s (φ : W.LeftFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    φ.map L hL ≫ L.map φ.s = L.map φ.f
-- Mathlib/Data/ENNReal/Basic.lean
theorem coe_mono : Monotone ofNNReal
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_bot : Iio (⊥ : α) = ∅
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem id_comp : (id : E₂ →ₗᵢ[R₂] E₂).comp f = f
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem mem_range {f : G →* N} {y : N} : y ∈ f.range ↔ ∃ x, f x = y
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
/-- A component of a transposed form of the inverse conjugation definition. -/
theorem conjugateEquiv_counit_symm (α : R₁ ⟶ R₂) (d : D) :
    L₂.map (α.app _) ≫ adj₂.counit.app d =
      ((conjugateEquiv adj₁ adj₂).symm α).app _ ≫ adj₁.counit.app d
-- Mathlib/Algebra/Polynomial/EraseLead.lean
@[simp]
theorem eraseLead_coeff_natDegree : f.eraseLead.coeff f.natDegree = 0
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- Product of modules is commutative up to continuous linear isomorphism. -/
@[simps! apply toLinearEquiv]
def prodComm [Module R₁ M₂] : (M₁ × M₂) ≃L[R₁] M₂ × M₁
-- Mathlib/GroupTheory/Commensurable.lean
@[trans]
theorem trans {H K L : Subgroup G} (hhk : Commensurable H K) (hkl : Commensurable K L) :
    Commensurable H L
-- Mathlib/Data/Set/Sups.lean
theorem inf_mem_infs : a ∈ s → b ∈ t → a ⊓ b ∈ s ⊼ t
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem range_castSucc {n : ℕ} : Set.range (castSucc : Fin n → Fin n.succ) =
    ({ i | (i : ℕ) < n } : Set (Fin n.succ))
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocMod_eq_toIocMod : toIocMod hp a b = toIocMod hp a c ↔ ∃ n : ℤ, c - b = n • p
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive]
theorem op_sInf (S : Set (Subgroup G)) : (sInf S).op = sInf (.unop ⁻¹' S)
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
theorem differentiableOn_inv : DifferentiableOn 𝕜 (fun x : 𝕜 => x⁻¹) { x | x ≠ 0 }
-- Mathlib/Order/WellFoundedSet.lean
theorem IsWF.min_mem (hs : IsWF s) (hn : s.Nonempty) : hs.min hn ∈ s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem coe_neg (x : ℝ) : ↑(-x : ℝ) = -(↑x : Angle)
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem T_add_two : ∀ n, T R (n + 2) = 2 * X * T R (n + 1) - T R n
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean
theorem monoidalClosed_pre_app {M N : ModuleCat.{u} R} (P : ModuleCat.{u} R) (f : N ⟶ M) :
    (MonoidalClosed.pre f).app P = LinearMap.lcomp R _ f
-- Mathlib/Algebra/Group/Units/Hom.lean
@[to_additive (attr := simp)]
theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
    ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1
-- Mathlib/Data/Num/Lemmas.lean
theorem size_to_nat : ∀ n, (size n : ℕ) = Nat.size n
-- Mathlib/Algebra/Lie/Abelian.lean
@[simp]
theorem maxTrivEquiv_of_equiv_symm_eq_symm (e : M ≃ₗ⁅R,L⁆ N) :
    (maxTrivEquiv e).symm = maxTrivEquiv e.symm
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem neighborSet_fst_subgraphOfAdj {v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet v = {w}
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsUpperSet.top_mem (hs : IsUpperSet s) : ⊤ ∈ s ↔ s.Nonempty
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_union (a : α) (s t : Set α) : 𝓝[s ∪ t] a = 𝓝[s] a ⊔ 𝓝[t] a
-- Mathlib/Order/RelSeries.lean
lemma longestOf_len_unique [FiniteDimensionalOrder α] (p : LTSeries α)
    (is_longest : ∀ (q : LTSeries α), q.length ≤ p.length) :
    p.length = (LTSeries.longestOf α).length
-- Mathlib/Topology/Sequences.lean
theorem Inducing.frechetUrysohnSpace [FrechetUrysohnSpace Y] {f : X → Y} (hf : Inducing f) :
    FrechetUrysohnSpace X
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc (attr := simp)]
theorem coprodComparison_inr : coprod.inr ≫ coprodComparison F A B = F.map coprod.inr
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem toList_singleton (a : α) : ({a} : Multiset α).toList = [a]
-- Mathlib/ModelTheory/Definability.lean
@[simp]
theorem mem_compl : x ∈ sᶜ ↔ ¬x ∈ s
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- We'd like to state this as `L.headI * L.tail.prod = L.prod`, but because `L.headI` relies on an
inhabited instance to return a garbage value on the empty list, this is not possible.
Instead, we write the statement in terms of `(L.get? 0).getD 1`.
-/
@[to_additive "We'd like to state this as `L.headI + L.tail.sum = L.sum`, but because `L.headI`
  relies on an inhabited instance to return a garbage value on the empty list, this is not possible.
  Instead, we write the statement in terms of `(L.get? 0).getD 0`."]
theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.prod = l.prod
-- Mathlib/Order/Interval/Multiset.lean
theorem Ico_filter_le_of_right_le [DecidablePred (b ≤ ·)] :
    ((Ico a b).filter fun x => b ≤ x) = ∅
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem map_sup (f : F) (S T : NonUnitalStarSubalgebra R A) :
    ((S ⊔ T).map f : NonUnitalStarSubalgebra R B) = S.map f ⊔ T.map f
-- Mathlib/Data/FunLike/Equiv.lean
@[simp]
theorem comp_bijective (f : α → β) (e : F) : Function.Bijective (e ∘ f) ↔ Function.Bijective f
-- Mathlib/Data/Int/Log.lean
@[mono]
theorem clog_mono_right {b : ℕ} {r₁ r₂ : R} (h₀ : 0 < r₁) (h : r₁ ≤ r₂) :
    clog b r₁ ≤ clog b r₂
-- Mathlib/Data/Finset/Order.lean
theorem Finset.exists_le [Nonempty α] [Preorder α] [IsDirected α (· ≤ ·)] (s : Finset α) :
    ∃ M, ∀ i ∈ s, i ≤ M
-- Mathlib/Topology/Category/UniformSpace.lean
@[simp]
theorem extensionHom_val {X : UniformSpaceCat} {Y : CpltSepUniformSpace}
    (f : X ⟶ (forget₂ _ _).obj Y) (x) : (extensionHom f) x = Completion.extension f x
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_union_right (hab : a < b) : Ioo a b ∪ {b} = Ioc a b
-- Mathlib/Algebra/Homology/TotalComplex.lean
lemma hasTotal_of_iso [K.HasTotal c₁₂] : L.HasTotal c₁₂
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_inv_lt_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ < y ↔ y ^ z < x
-- Mathlib/CategoryTheory/Category/Quiv.lean
/-- The forgetful functor from categories to quivers. -/
@[simps]
def forget : Cat.{v, u} ⥤ Quiv.{v, u}
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.congr (h : f₁ =o[l] g₁) (hf : ∀ x, f₁ x = f₂ x) (hg : ∀ x, g₁ x = g₂ x) :
    f₂ =o[l] g₂
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem mem_Ioi : x ∈ Ioi a ↔ a < x
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp, nolint simpNF)]
theorem Pi.π_comp_eqToHom {J : Type*} (f : J → C) [HasProduct f] {j j' : J} (w : j = j') :
    Pi.π f j ≫ eqToHom (by simp [w]) = Pi.π f j'
-- Mathlib/GroupTheory/HNNExtension.lean
theorem of_mul_inv_t (a : A) :
    (of (a : G) : HNNExtension G A B φ) * t⁻¹ = t⁻¹ * of (φ a : G)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_comm : (fun x => f₁ x - f₂ x) =O[l] g ↔ (fun x => f₂ x - f₁ x) =O[l] g
-- Mathlib/Algebra/Module/Projective.lean
/-- A module which satisfies the universal property is projective: If all surjections of
`R`-modules `(P →₀ R) →ₗ[R] P` have `R`-linear left inverse maps, then `P` is
projective. -/
theorem Projective.of_lifting_property'' {R : Type u} [Semiring R] {P : Type v} [AddCommMonoid P]
    [Module R P] (huniv : ∀ (f : (P →₀ R) →ₗ[R] P), Function.Surjective f →
      ∃ h : P →ₗ[R] (P →₀ R), f.comp h = .id) :
    Projective R P
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem coe_neg : ⇑(-f) = -f
-- Mathlib/Order/RelIso/Basic.lean
/-- `Sum.inr` as a relation embedding into `Sum.Lex r s`. -/
@[simps]
def sumLexInr (r : α → α → Prop) (s : β → β → Prop) : s ↪r Sum.Lex r s
-- Mathlib/Combinatorics/Additive/Energy.lean
@[to_additive] lemma mulEnergy_eq_sum_sq [Fintype α] (s t : Finset α) :
    Eₘ[s, t] = ∑ a, ((s ×ˢ t).filter fun (x, y) ↦ x * y = a).card ^ 2
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[simp]
theorem kernelZeroIsoSource_inv :
    kernelZeroIsoSource.inv = kernel.lift (0 : X ⟶ Y) (𝟙 X) (by simp)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem coeff_apply (h : IsAdjoinRootMonic S f) (z : S) (i : ℕ) :
    h.coeff z i = if hi : i < natDegree f then h.basis.repr z ⟨i, hi⟩ else 0
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
@[simp]
theorem rat_add_iff : LiouvilleWith p (r + x) ↔ LiouvilleWith p x
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem hasSum_conj {f : α → 𝕜} {x : 𝕜} : HasSum (fun x => conj (f x)) x ↔ HasSum f (conj x)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem pow_add_one' {m n : Nat} : m ^ (n + 1) = m * m ^ n
-- Mathlib/Algebra/Order/Group/Action.lean
theorem smul_mono_right [SMul M α] [Preorder α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) : Monotone (HSMul.hSMul m : α → α)
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem candidates_triangle (fA : f ∈ candidates X Y) : f (x, z) ≤ f (x, y) + f (y, z)
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive uniformContinuous_norm]
theorem uniformContinuous_norm' : UniformContinuous (norm : E → ℝ)
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem isLittleO_pow_pow_of_abs_lt_left {r₁ r₂ : ℝ} (h : |r₁| < |r₂|) :
    (fun n : ℕ ↦ r₁ ^ n) =o[atTop] fun n ↦ r₂ ^ n
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem const_neg (x : β) : const (-x) = -const x
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
@[simp]
theorem toComplex_eq_zero {x : ℤ[i]} : (x : ℂ) = 0 ↔ x = 0
-- Mathlib/RingTheory/Bialgebra/Hom.lean
@[simp]
theorem comp_toCoalgHom (φ₁ : B →ₐc[R] C) (φ₂ : A →ₐc[R] B) :
    φ₁.comp φ₂ = (φ₁ : B →ₗc[R] C).comp (φ₂ : A →ₗc[R] B)
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem takeWhile_eq_nil_iff : takeWhile p l = [] ↔ ∀ hl : 0 < l.length, ¬p (l.nthLe 0 hl)
-- Mathlib/Topology/Algebra/Order/Field.lean
theorem nhdsWithin_pos_comap_mul_left {x : 𝕜} (hx : 0 < x) :
    comap (x * ·) (𝓝[>] 0) = 𝓝[>] 0
-- Mathlib/RingTheory/Multiplicity.lean
theorem unit_left (a : α) (u : αˣ) : multiplicity (u : α) a = ⊤
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem qsmul_eq_C_mul (a : ℚ) (f : R[X]) : a • f = Polynomial.C (a : R) * f
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
@[simp]
theorem dimH_image (e : X ≃ᵢ Y) (s : Set X) : dimH (e '' s) = dimH s
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem not_equiv_zero_const_of_nonzero {q : ℚ} (hq : q ≠ 0) : ¬const (padicNorm p) q ≈ 0
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
/-- The function `(b * exp x + c) / (x ^ n)` tends to `+∞` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is positive. -/
theorem tendsto_mul_exp_add_div_pow_atTop (b c : ℝ) (n : ℕ) (hb : 0 < b) :
    Tendsto (fun x => (b * exp x + c) / x ^ n) atTop atTop
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem unsym_add [Add α] (a b : αˢʸᵐ) : unsym (a + b) = unsym a + unsym b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
@[simp]
lemma smul_eq (P : Fin 3 → R) {u : R} (hu : IsUnit u) : (⟦u • P⟧ : PointClass R) = ⟦P⟧
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem map_map (g : F →ₗ[𝕜] G) (f : E →ₗ[𝕜] F) (S : ConvexCone 𝕜 E) :
    (S.map f).map g = S.map (g.comp f)
-- Mathlib/Analysis/Convex/Star.lean
/-- Alternative definition of star-convexity, using division. -/
theorem starConvex_iff_div : StarConvex 𝕜 x s ↔ ∀ ⦃y⦄, y ∈ s →
    ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s
-- Mathlib/NumberTheory/Divisors.lean
@[simp]
theorem swap_mem_divisorsAntidiagonal_aux {x : ℕ × ℕ} :
    x.snd * x.fst = n ∧ ¬n = 0 ↔ x ∈ divisorsAntidiagonal n
-- Mathlib/Data/Nat/Digits.lean
theorem eleven_dvd_of_palindrome (p : (digits 10 n).Palindrome) (h : Even (digits 10 n).length) :
    11 ∣ n
-- Mathlib/Combinatorics/Quiver/Basic.lean
/-- Composition of morphisms between quivers. -/
@[simps]
def comp {U : Type*} [Quiver U] {V : Type*} [Quiver V] {W : Type*} [Quiver W]
    (F : Prefunctor U V) (G : Prefunctor V W) : Prefunctor U W
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem derivFamily_lt_ord {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c) (hι : #ι < c)
    (hc' : c ≠ ℵ₀) (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) {a} :
    a < c.ord → derivFamily.{u, u} f a < c.ord
-- Mathlib/RingTheory/Ideal/MinimalPrime.lean
theorem prime_unique_of_minimal (J : Ideal (Localization I.primeCompl)) [J.IsPrime] :
    J = LocalRing.maximalIdeal (Localization I.primeCompl)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem diff_sublist : ∀ l₁ l₂ : List α, l₁.diff l₂ <+ l₁
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma coreflection_image_eq :
    P.coreflection i '' (range P.coroot) = range P.coroot
-- Mathlib/Analysis/SpecialFunctions/Bernstein.lean
/-- The Bernstein approximations
```
∑ k : Fin (n+1), f (k/n : ℝ) * n.choose k * x^k * (1-x)^(n-k)
```
for a continuous function `f : C([0,1], ℝ)` converge uniformly to `f` as `n` tends to infinity.

This is the proof given in [Richard Beals' *Analysis, an introduction*][beals-analysis], §7D,
and reproduced on wikipedia.
-/
theorem bernsteinApproximation_uniform (f : C(I, ℝ)) :
    Tendsto (fun n : ℕ => bernsteinApproximation n f) atTop (𝓝 f)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_union_Ioo' (h₁ : c < b) (h₂ : a < d) : Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
-- Mathlib/Data/PNat/Interval.lean
theorem Ico_eq_finset_subtype : Ico a b = (Ico (a : ℕ) b).subtype fun n : ℕ => 0 < n
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
lemma withDensity_inv_same₀ {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) (hf_ne_top : ∀ᵐ x ∂μ, f x ≠ ∞) :
    (μ.withDensity f).withDensity (fun x ↦ (f x)⁻¹) = μ
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
/-- Same as `Monotone.covariant_of_const`, but with the constant on the other side of
the operator.  E.g., `∀ (m : ℕ), Monotone f → Monotone (fun n ↦ f (n + m))`. -/
theorem Monotone.covariant_of_const' {μ : N → N → N} [CovariantClass N N (swap μ) (· ≤ ·)]
    (hf : Monotone f) (m : N) : Monotone (f <| μ · m)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_finset_union : a • (s₁ ∪ s₂) = a • s₁ ∪ a • s₂
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_balance' {P l x r} : @All α P (balance' l x r) ↔ All P l ∧ P x ∧ All P r
-- Mathlib/Logic/Relator.lean
protected lemma symm (hr : ∀ (a : α) (b : β), r₁₂ a b → r₂₁ b a) :
    RightTotal r₁₂ → LeftTotal r₂₁
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eq_interpolate_of_eval_eq {f : F[X]} (hvs : Set.InjOn v s) (degree_f_lt : f.degree < s.card)
    (eval_f : ∀ i ∈ s, f.eval (v i) = r i) : f = interpolate s v r
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasStrictDerivAt.const_mul (c : 𝔸) (hd : HasStrictDerivAt d d' x) :
    HasStrictDerivAt (fun y => c * d y) (c * d') x
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Adding a point in the affine span of a set does not change whether that set is coplanar. -/
theorem coplanar_insert_iff_of_mem_affineSpan {s : Set P} {p : P} (h : p ∈ affineSpan k s) :
    Coplanar k (insert p s) ↔ Coplanar k s
-- Mathlib/Data/Finmap.lean
theorem mem_lookup_union_middle {a} {b : β a} {s₁ s₂ s₃ : Finmap β} :
    b ∈ lookup a (s₁ ∪ s₃) → a ∉ s₂ → b ∈ lookup a (s₁ ∪ s₂ ∪ s₃)
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_lie (f : M →ₗ⁅R,L⁆ N) (x : L) (m : M) : f ⁅x, m⁆ = ⁅x, f m⁆
-- Mathlib/Algebra/Order/AddGroupWithTop.lean
@[simp]
theorem top_sub {a : WithTop α} : (⊤ : WithTop α) - a = ⊤
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem Filter.Tendsto.zpow {α} {l : Filter α} {f : α → G} {x : G} (hf : Tendsto f l (𝓝 x))
    (z : ℤ) : Tendsto (fun x => f x ^ z) l (𝓝 (x ^ z))
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma GrowsPolynomially.of_isTheta {f g : ℝ → ℝ} (hg : GrowsPolynomially g) (hf : f =Θ[atTop] g)
    (hf' : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially f
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem lpMeasSubgroup_coe {m _ : MeasurableSpace α} {μ : Measure α} {f : lpMeasSubgroup F m p μ} :
    (f : _ → _) = (f : Lp F p μ)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsPrime.multiset_prod_mem_iff_exists_mem {I : Ideal R} (hI : I.IsPrime) (s : Multiset R) :
    s.prod ∈ I ↔ ∃ p ∈ s, p ∈ I
-- Mathlib/CategoryTheory/Bicategory/Free.lean
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C
-- Mathlib/Algebra/Polynomial/Coeff.lean
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem intCast_inj {m n : ℤ} {R : Type*} [Ring R] [CharZero R] : (↑m : R[X]) = ↑n ↔ m = n
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
theorem mul_inverse_cancel_right (x y : M₀) (h : IsUnit x) : y * x * inverse x = y
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp, norm_cast]
theorem coe_Ioi (a : α) : (Ioi a : Set α) = Set.Ioi a
-- Mathlib/Algebra/GroupWithZero/Action/Defs.lean
lemma smul_eq_zero_of_right (a : M) {b : A} (h : b = 0) : a • b = 0
-- Mathlib/MeasureTheory/PiSystem.lean
theorem piiUnionInter_mono_left {π π' : ι → Set (Set α)} (h_le : ∀ i, π i ⊆ π' i) (S : Set ι) :
    piiUnionInter π S ⊆ piiUnionInter π' S
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem reverse_isTrail_iff {u v : V} (p : G.Walk u v) : p.reverse.IsTrail ↔ p.IsTrail
-- Mathlib/Algebra/Category/Grp/Basic.lean
@[to_additive (attr := simp)] theorem MonoidHom.comp_id_commGrp
    {G : CommGrp.{u}} {H : Type u} [CommGroup H] (f : G →* H) : f.comp (𝟙 G) = f
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem dual_Ioo : Ioo (toDual a) (toDual b) = ofDual ⁻¹' Ioo b a
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem filter_le_le_eq_Icc [DecidablePred fun j => a ≤ j ∧ j ≤ b] :
    (univ.filter fun j => a ≤ j ∧ j ≤ b) = Icc a b
-- Mathlib/Probability/Density.lean
theorem map_eq_setLIntegral_pdf {m : MeasurableSpace Ω} (X : Ω → E) (ℙ : Measure Ω)
    (μ : Measure E := by volume_tac) [hX : HasPDF X ℙ μ] {s : Set E}
    (hs : MeasurableSet s) : map X ℙ s = ∫⁻ x in s, pdf X ℙ μ x ∂μ
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
theorem id_pow (n : ℕ) : (id : M →ₗ[R] M) ^ n = id
-- Mathlib/Data/List/Range.lean
@[simp]
theorem getElem_finRange {n : ℕ} {i : ℕ} (h) :
    (finRange n)[i] = ⟨i, length_finRange n ▸ h⟩
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_lt_log_iff (hx : 0 < x) (hy : 0 < y) : log x < log y ↔ x < y
-- Mathlib/Data/Vector3.lean
@[simp]
theorem append_add :
    ∀ {m} (v : Vector3 α m) {n} (w : Vector3 α n) (i : Fin2 n), (v +-+ w) (add i m) = w i
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem singletonMonoidHom_apply (a : α) : singletonMonoidHom a = {a}
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_finset_inter_subset : a • (s₁ ∩ s₂) ⊆ a • s₁ ∩ a • s₂
-- Mathlib/Data/Complex/Module.lean
@[simp]
lemma imaginaryPart_ofReal (r : ℝ) : ℑ (r : ℂ) = 0
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[simp]
theorem isLimitForkOfKernelFork_lift {c : KernelFork (f - g)} (i : IsLimit c) (s : Fork f g) :
    (isLimitForkOfKernelFork i).lift s = i.lift (kernelForkOfFork s)
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
/-- The map that sends an L¹-function `f : α × β → E` to `∫∫f` is continuous. -/
theorem continuous_integral_integral :
    Continuous fun f : α × β →₁[μ.prod ν] E => ∫ x, ∫ y, f (x, y) ∂ν ∂μ
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
protected theorem coe_toBasis_repr (b : OrthonormalBasis ι 𝕜 E) :
    b.toBasis.equivFun = b.repr.toLinearEquiv
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem max_assoc : ∀ (a b c : Nat), max (max a b) c = max a (max b c)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_update_of_mem [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) (b : β) :
    ∏ x ∈ s, Function.update f i b x = b * ∏ x ∈ s \ singleton i, f x