ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Instances/EReal.lean
theorem continuousAt_add_bot_coe (a : ℝ) :
    ContinuousAt (fun p : EReal × EReal => p.1 + p.2) (⊥, a)
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem independent_of_dfinsupp_lsum_injective (p : ι → Submodule R N)
    (h : Function.Injective (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype)) :
    Independent p
-- Mathlib/Probability/StrongLaw.lean
theorem abs_truncation_le_bound (f : α → ℝ) (A : ℝ) (x : α) : |truncation f A x| ≤ |A|
-- Mathlib/Data/Matrix/Basic.lean
theorem sub_vecMul [Fintype m] (A : Matrix m n α) (x y : m → α) :
    (x - y) ᵥ* A = x ᵥ* A - y ᵥ* A
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem U_add_two : ∀ n, U R (n + 2) = 2 * X * U R (n + 1) - U R n
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_sInf_dom {f : α → β} {u₁ : Set (UniformSpace α)} {u₂ : UniformSpace β}
    {u : UniformSpace α} (h₁ : u ∈ u₁) (hf : UniformContinuous[u, u₂] f) :
    UniformContinuous[sInf u₁, u₂] f
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem mod_mem_iff {S : Ideal R} {x y : R} (hy : y ∈ S) : x % y ∈ S ↔ x ∈ S
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem pow_of_coprime (i : ℕ) (hi : i.Coprime k) : IsPrimitiveRoot (ζ ^ i) k
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem gramSchmidt_def'' (f : ι → E) (n : ι) :
    f n = gramSchmidt 𝕜 f n + ∑ i ∈ Iio n,
      (⟪gramSchmidt 𝕜 f i, f n⟫ / (‖gramSchmidt 𝕜 f i‖ : 𝕜) ^ 2) • gramSchmidt 𝕜 f i
-- Mathlib/CategoryTheory/Localization/Resolution.lean
/-- The functor `(Φ.LeftResolution X₂)ᵒᵖ ⥤ Φ.op.RightResolution (Opposite.op X₂)`. -/
@[simps]
def LeftResolution.opFunctor (X₂ : C₂) [W₁.IsMultiplicative] :
    (Φ.LeftResolution X₂)ᵒᵖ ⥤ Φ.op.RightResolution (Opposite.op X₂)
-- Mathlib/Data/Int/GCD.lean
theorem gcd_dvd_gcd_of_dvd_left {i k : ℤ} (j : ℤ) (H : i ∣ k) : gcd i j ∣ gcd k j
-- Mathlib/Algebra/Homology/HomologySequence.lean
@[reassoc (attr := simp)]
lemma δ_comp : hS.δ i j hij ≫ HomologicalComplex.homologyMap S.f j = 0
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Strict inequality case of the Rearrangement Inequality**: Pointwise scalar multiplication of
`f` and `g`, which monovary together, is strictly decreased by a permutation if and only if
`f` and `g ∘ σ` do not monovary together. Stated by permuting the entries of `g`. -/
theorem MonovaryOn.sum_mul_comp_perm_lt_sum_mul_iff (hfg : MonovaryOn f g s)
    (hσ : {x | σ x ≠ x} ⊆ s) :
    ∑ i ∈ s, f i • g (σ i) < ∑ i ∈ s, f i • g i ↔ ¬MonovaryOn f (g ∘ σ) s
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_le_sSup (hs : s.Nonempty) : sInf s ≤ sSup s
-- Mathlib/Analysis/Analytic/Inverse.lean
@[simp]
theorem rightInv_coeff_one (p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) :
    p.rightInv i 1 = (continuousMultilinearCurryFin1 𝕜 F E).symm i.symm
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt g₁ g₁' t' (h x))
    (hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
    HasDerivWithinAt (g₁ ∘ h) (h' • g₁') s x
-- Mathlib/Order/Bounded.lean
theorem bounded_le_inter_lt [LinearOrder α] (a : α) :
    Bounded (· ≤ ·) (s ∩ { b | a < b }) ↔ Bounded (· ≤ ·) s
-- Mathlib/RingTheory/Algebraic.lean
theorem transcendental_iff_injective {x : A} :
    Transcendental R x ↔ Function.Injective (Polynomial.aeval x : R[X] →ₐ[R] A)
-- Mathlib/Dynamics/OmegaLimit.lean
/-- An element `y` is in the ω-limit of `x` w.r.t. `f` if the forward
    images of `x` frequently (w.r.t. `f`) falls within an arbitrary
    neighbourhood of `y`. -/
theorem mem_omegaLimit_singleton_iff_map_cluster_point (x : α) (y : β) :
    y ∈ ω f ϕ {x} ↔ MapClusterPt y f fun t ↦ ϕ t x
-- Mathlib/RingTheory/WittVector/Verschiebung.lean
theorem verschiebung_coeff_add_one (x : 𝕎 R) (n : ℕ) :
    (verschiebung x).coeff (n + 1) = x.coeff n
-- Mathlib/Analysis/Normed/Field/UnitBall.lean
@[simp, norm_cast]
theorem coe_zpow_unitSphere [NormedDivisionRing 𝕜] (x : sphere (0 : 𝕜) 1) (n : ℤ) :
    ↑(x ^ n) = (x : 𝕜) ^ n
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
protected theorem HasStrictFDerivAt.continuousAt (hf : HasStrictFDerivAt f f' x) :
    ContinuousAt f x
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
theorem eq_mul_inverse_iff_mul_eq (x y z : M₀) (h : IsUnit z) : x = y * inverse z ↔ x * z = y
-- Mathlib/Data/Int/Cast/Lemmas.lean
theorem eq_intCast' [AddGroupWithOne α] [FunLike F ℤ α] [AddMonoidHomClass F ℤ α]
    (f : F) (h₁ : f 1 = 1) :
    ∀ n : ℤ, f n = n
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem LinearMap.isometryOfOrthonormal_toLinearMap (f : E →ₗ[𝕜] E') {v : Basis ι 𝕜 E}
    (hv : Orthonormal 𝕜 v) (hf : Orthonormal 𝕜 (f ∘ v)) :
    (f.isometryOfOrthonormal hv hf).toLinearMap = f
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem _root_.ENNReal.tsum_const_eq [MeasurableSingletonClass α] (c : ℝ≥0∞) :
    ∑' _ : α, c = c * Measure.count (univ : Set α)
-- Mathlib/RingTheory/PowerSeries/Order.lean
theorem divided_by_X_pow_orderMul {f g : R⟦X⟧} (hf : f ≠ 0) (hg : g ≠ 0) :
    divided_by_X_pow_order hf * divided_by_X_pow_order hg =
      divided_by_X_pow_order (mul_ne_zero hf hg)
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
theorem gcd_dvd_left (a b : R) : gcd a b ∣ a
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[simp]
theorem coe_pointwise_smul (a : α) (S : Submonoid M) : ↑(a • S) = a • (S : Set M)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
protected theorem inter {s' t'} (h : e.IsImage s t) (h' : e.IsImage s' t') :
    e.IsImage (s ∩ s') (t ∩ t')
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem map_neg (f : A' →ₑ+[φ] B') (x : A') : f (-x) = -f x
-- Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean
@[reassoc (attr := simp)]
lemma comp_descHomotopyZeroSucc {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (n : ℕ) (g : I.cocomplex.X (n + 1) ⟶ J.cocomplex.X n)
    (g' : I.cocomplex.X (n + 2) ⟶ J.cocomplex.X (n + 1))
    (w : f.f (n + 1) = I.cocomplex.d (n + 1) (n + 2) ≫ g' + g ≫ J.cocomplex.d n (n + 1)) :
    I.cocomplex.d (n+2) (n+3) ≫ descHomotopyZeroSucc f n g g' w =
      f.f (n + 2) - g' ≫ J.cocomplex.d _ _
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[fun_prop]
theorem ContinuousOn.zpow₀ (hf : ContinuousOn f s) (m : ℤ) (h : ∀ a ∈ s, f a ≠ 0 ∨ 0 ≤ m) :
    ContinuousOn (fun x => f x ^ m) s
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma intCast_mul_intCast_mul (h : Commute a b) (m n : ℤ) : Commute (m * a) (n * b)
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
@[simp]
theorem dimH_union (s t : Set X) : dimH (s ∪ t) = max (dimH s) (dimH t)
-- Mathlib/Data/Fintype/Card.lean
theorem injective_iff_surjective_of_equiv {f : α → β} (e : α ≃ β) : Injective f ↔ Surjective f
-- Mathlib/Probability/Variance.lean
theorem evariance_lt_top_iff_memℒp [IsFiniteMeasure μ] (hX : AEStronglyMeasurable X μ) :
    evariance X μ < ∞ ↔ Memℒp X 2 μ
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem mem_map (x : α) : x ∈ c → f x ∈ Chain.map c f
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem isCompactOperator_iff_image_ball_subset_compact [ContinuousConstSMul 𝕜₂ M₂]
    (f : M₁ →ₛₗ[σ₁₂] M₂) {r : ℝ} (hr : 0 < r) :
    IsCompactOperator f ↔ ∃ K : Set M₂, IsCompact K ∧ f '' Metric.ball 0 r ⊆ K
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem diam_eq_zero_iff : diam s = 0 ↔ s.Subsingleton
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma Cotangent.val_smul'' (r : R) (x : P.Cotangent) : (r • x).val = r • x.val
-- Mathlib/Analysis/InnerProductSpace/Rayleigh.lean
theorem iInf_rayleigh_eq_iInf_rayleigh_sphere {r : ℝ} (hr : 0 < r) :
    ⨅ x : { x : E // x ≠ 0 }, rayleighQuotient T x =
      ⨅ x : sphere (0 : E) r, rayleighQuotient T x
-- Mathlib/GroupTheory/CoprodI.lean
/-- See note [partially-applied ext lemmas]. -/
-- Porting note: higher `ext` priority
@[ext 1100]
theorem ext_hom (f g : CoprodI M →* N) (h : ∀ i, f.comp (of : M i →* _) = g.comp of) : f = g
-- Mathlib/Algebra/Group/WithOne/Basic.lean
@[to_additive (attr := simp)]
theorem lift_coe (x : α) : lift f x = f x
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem IsUniversalColimit.whiskerEquivalence_iff {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} :
    IsUniversalColimit (c.whisker e.functor) ↔ IsUniversalColimit c
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsCoprime.pow_left (H : IsCoprime x y) : IsCoprime (x ^ m) y
-- Mathlib/Algebra/BigOperators/Ring.lean
lemma _root_.Commute.sum_left [NonUnitalNonAssocSemiring α] (s : Finset ι) (f : ι → α) (b : α)
    (h : ∀ i ∈ s, Commute (f i) b) : Commute (∑ i ∈ s, f i) b
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
/-- `⊓` commutes with map. -/
theorem inf_map {X Y : C} (g : Y ⟶ X) [Mono g] (f₁ f₂) :
    (map g).obj (f₁ ⊓ f₂) = (map g).obj f₁ ⊓ (map g).obj f₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem forM_nil' [Monad m] : ([] : List α).forM f = (pure .unit : m PUnit)
-- Mathlib/Data/Stream/Init.lean
theorem tail_eq_drop (s : Stream' α) : tail s = drop 1 s
-- Mathlib/Data/Nat/Defs.lean
/-- See also `Nat.divModEquiv` for a similar statement as an `Equiv`. -/
protected lemma div_mod_unique (h : 0 < b) :
    a / b = d ∧ a % b = c ↔ c + b * d = a ∧ c < b
-- Mathlib/Topology/Constructions.lean
theorem isClosed_sigma_iff {s : Set (Sigma σ)} : IsClosed s ↔ ∀ i, IsClosed (Sigma.mk i ⁻¹' s)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem take_succ {l : List α} {n : Nat} : l.take (n + 1) = l.take n ++ l[n]?.toList
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/Deriv.lean
theorem map_nhds_eq : map f (𝓝 a) = 𝓝 (f a)
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem range_le : Set.range (algebraMap R A) ≤ S
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma LeftHomologyData.exact_iff_epi_f' [S.HasHomology] (h : LeftHomologyData S) :
    S.Exact ↔ Epi h.f'
-- Mathlib/Algebra/Vertex/HVertexOperator.lean
theorem coeff_isPWOsupport (A : HVertexOperator Γ R V W) (v : V) :
    ((of R).symm (A v)).coeff.support.IsPWO
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem toDual_hnot (a : α) : toDual (￢a) = (toDual a)ᶜ
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
/-- A function whose codomain's cardinality is infinite but strictly smaller than its domain's
has a fiber with cardinality strictly great than the codomain.
-/
theorem infinite_pigeonhole_card_lt {β α : Type u} (f : β → α) (w : #α < #β) (w' : ℵ₀ ≤ #α) :
    ∃ a : α, #α < #(f ⁻¹' {a})
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
theorem powers_eq_closure (n : M) : powers n = closure {n}
-- Mathlib/NumberTheory/FunctionField.lean
theorem InftyValuation.map_add_le_max' (x y : RatFunc Fq) :
    inftyValuationDef Fq (x + y) ≤ max (inftyValuationDef Fq x) (inftyValuationDef Fq y)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem symm_bijective : Function.Bijective
    (PartialHomeomorph.symm : PartialHomeomorph X Y → PartialHomeomorph Y X)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem zero_limZero : LimZero (0 : CauSeq β abv)
-- Mathlib/GroupTheory/Coxeter/Basic.lean
theorem wordProd_concat (i : B) (ω : List B) : π (ω.concat i) = π ω * s i
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem exists_norm_lt {r : ℝ} (hr : 0 < r) : ∃ x : α, 0 < ‖x‖ ∧ ‖x‖ < r
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem _root_.LinearMapClass.ker_eq_bot : ker f = ⊥ ↔ Injective f
-- Mathlib/Data/Multiset/Basic.lean
theorem card_nsmul (s : Multiset α) (n : ℕ) : card (n • s) = n * card s
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
@[simp]
theorem isVonNBounded_empty : IsVonNBounded 𝕜 (∅ : Set E)
-- Mathlib/Topology/Basic.lean
theorem Continuous.congr {g : X → Y} (h : Continuous f) (h' : ∀ x, f x = g x) : Continuous g
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp, norm_cast] lemma cast_natCast (n : ℕ) : ((n : ℚ≥0) : α) = n
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem hasSum_integral_measure {ι} {m : MeasurableSpace α} {f : α → G} {μ : ι → Measure α}
    (hf : Integrable f (Measure.sum μ)) :
    HasSum (fun i => ∫ a, f a ∂μ i) (∫ a, f a ∂Measure.sum μ)
-- Mathlib/ModelTheory/Types.lean
theorem formula_mem_typeOf {φ : L.Formula α} :
    Formula.equivSentence φ ∈ T.typeOf v ↔ φ.Realize v
-- Mathlib/Analysis/Normed/Order/Lattice.lean
theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem subNatNat_add_add (m n k : Nat) : subNatNat (m + k) (n + k) = subNatNat m n
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem card_support (h : IsThreeCycle σ) : σ.support.card = 3
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
@[simp]
theorem edgeFinset_sup [Fintype (edgeSet (G₁ ⊔ G₂))] [DecidableEq V] :
    (G₁ ⊔ G₂).edgeFinset = G₁.edgeFinset ∪ G₂.edgeFinset
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem thickening_subset_cthickening_of_le {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
    thickening δ₁ E ⊆ cthickening δ₂ E
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem ι_add_mul_swap (x y : M) : ι R x * ι R y + ι R y * ι R x = 0
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_le_iff_coeff_zero (f : R[X]) (n : WithBot ℕ) :
    degree f ≤ n ↔ ∀ m : ℕ, n < m → coeff f m = 0
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem extend_comp (hf : Injective f) (g : α → γ) (e' : β → γ) : extend f g e' ∘ f = g
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem _root_.Polynomial.toLaurent_X_pow (n : ℕ) : toLaurent (X ^ n : R[X]) = T n
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem sub_mem_Ico_iff_left : a - b ∈ Set.Ico c d ↔ a ∈ Set.Ico (c + b) (d + b)
-- Mathlib/Data/Nat/Fib/Basic.lean
lemma fib_lt_fib {m : ℕ} (hm : 2 ≤ m) : ∀ {n}, fib m < fib n ↔ m < n
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_union_add_inter₀ (s : Set α) (ht : NullMeasurableSet t μ) :
    μ.restrict (s ∪ t) + μ.restrict (s ∩ t) = μ.restrict s + μ.restrict t
-- Mathlib/Order/Disjoint.lean
theorem disjoint_iff_inf_le : Disjoint a b ↔ a ⊓ b ≤ ⊥
-- Mathlib/Data/Finset/Basic.lean
theorem erase_eq_empty_iff (s : Finset α) (a : α) : s.erase a = ∅ ↔ s = ∅ ∨ s = {a}
-- Mathlib/Topology/Algebra/Ring/Ideal.lean
theorem Ideal.closure_eq_of_isClosed (I : Ideal R) (hI : IsClosed (I : Set R)) : I.closure = I
-- Mathlib/Algebra/Lie/Basic.lean
theorem congr_fun {f g : L₁ →ₗ⁅R⁆ L₂} (h : f = g) (x : L₁) : f x = g x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem ExprCnstr.toPoly_norm_eq (c : ExprCnstr) : c.toPoly.norm = c.toNormPoly
-- Mathlib/SetTheory/Game/PGame.lean
theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.of_mul_left_left (H : IsCoprime (x * y) z) : IsCoprime x z
-- Mathlib/MeasureTheory/Function/LpSpace.lean
private theorem lintegral_rpow_tsum_coe_nnnorm_sub_le_tsum {f : ℕ → α → E}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞}
    (h :
      ∀ n,
        (∫⁻ a, (∑ i ∈ Finset.range (n + 1), ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ≤
          (∑' i, B i) ^ p) :
    (∫⁻ a, (∑' i, ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) ≤ ∑' i, B i
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
protected theorem le_inf (f' f g : α →ₘ[μ] β) (hf : f' ≤ f) (hg : f' ≤ g) : f' ≤ f ⊓ g
-- Mathlib/Data/Fin/Basic.lean
lemma succAbove_castSucc_of_lt (p i : Fin n) (h : i < p) : succAbove p.castSucc i = i.castSucc
-- Mathlib/Algebra/Polynomial/EraseLead.lean
@[simp]
theorem eraseLead_X : eraseLead (X : R[X]) = 0
-- Mathlib/Topology/Connected/Basic.lean
theorem IsConnected.nonempty {s : Set α} (h : IsConnected s) : s.Nonempty
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem left_mem_uIcc : a ∈ [[a, b]]
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem appr_spec (n : ℕ) : ∀ x : ℤ_[p], x - appr x n ∈ Ideal.span {(p : ℤ_[p]) ^ n}
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma _root_.MonotoneOn.mapsTo_uIcc (hf : MonotoneOn f (uIcc a b)) :
    MapsTo f (uIcc a b) (uIcc (f a) (f b))
-- Mathlib/Algebra/Lie/Derivation/AdjointAction.lean
/-- If the center of a Lie algebra is trivial, then the adjoint action is injective. -/
lemma injective_ad_of_center_eq_bot (h : LieAlgebra.center R L = ⊥) :
    Function.Injective (ad R L)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem erase_comm [LawfulBEq α] (a b : α) (l : List α) :
    (l.erase a).erase b = (l.erase b).erase a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem ofNat_fmod (m n : Nat) : ↑(m % n) = fmod m n
-- Mathlib/Order/Basic.lean
theorem lt_or_le [LinearOrder α] {a b : α} (h : a ≤ b) (c : α) : a < c ∨ c ≤ b
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem sign_inv (f : Perm α) : sign f⁻¹ = sign f
-- Mathlib/Topology/Instances/EReal.lean
theorem mem_nhds_bot_iff {s : Set EReal} : s ∈ 𝓝 (⊥ : EReal) ↔ ∃ y : ℝ, Iio (y : EReal) ⊆ s
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
theorem isBounded_image (f : C₀(α, β)) (s : Set α) : IsBounded (f '' s)
-- Mathlib/Algebra/Homology/QuasiIso.lean
lemma quasiIso_iff_comp_right (φ : K ⟶ L) (φ' : L ⟶ M) [∀ i, K.HasHomology i]
    [∀ i, L.HasHomology i] [∀ i, M.HasHomology i]
    [hφ' : QuasiIso φ'] :
    QuasiIso (φ ≫ φ') ↔ QuasiIso φ
-- Mathlib/Analysis/ConstantSpeed.lean
theorem HasConstantSpeedOnWith.Icc_Icc {x y z : ℝ} (hfs : HasConstantSpeedOnWith f (Icc x y) l)
    (hft : HasConstantSpeedOnWith f (Icc y z) l) : HasConstantSpeedOnWith f (Icc x z) l
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Submonoid M) :
    ⨆ i, p i = Submonoid.closure (⋃ i, (p i : Set M))
-- Mathlib/Analysis/Complex/Hadamard.lean
lemma norm_le_interpStrip_of_mem_verticalStrip_zero (z : ℂ)
    (hd : DiffContOnCl ℂ f (verticalStrip 0 1))
    (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) (hz : z ∈ verticalStrip 0 1) :
    ‖f z‖ ≤ ‖interpStrip f z‖
-- Mathlib/GroupTheory/GroupAction/Group.lean
theorem smul_eq_zero_iff_eq (a : α) {x : β} : a • x = 0 ↔ x = 0
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem coeff_zero_C (a) : coeff 0 (C a : MvPolynomial σ R) = a
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
theorem mul_card_image_le_card_of_maps_to {f : α → β} {s : Finset α} {t : Finset β}
    (Hf : ∀ a ∈ s, f a ∈ t) (n : ℕ) (hn : ∀ a ∈ t, n ≤ (s.filter fun x ↦ f x = a).card) :
    n * t.card ≤ s.card
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
@[simp]
theorem coe_smul_adicCompletionIntegers (r : R) (x : v.adicCompletionIntegers K) :
    (↑(r • x) : v.adicCompletion K) = r • (x : v.adicCompletion K)
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem map_comp (p q : R[X]) : map f (p.comp q) = (map f p).comp (map f q)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_add_of_sub_right_lt {a b c : Int} (h : a - c < b) : a < b + c
-- Mathlib/Computability/TMToPartrec.lean
/-- The set `codeSupp c k` is a finite set that witnesses the effective finiteness of the `tr`
Turing machine. Starting from the initial state `trNormal c k`, forward simulation uses only
states in `codeSupp c k`, so this is a finite state machine. Even though the underlying type of
state labels `Λ'` is infinite, for a given partial recursive function `c` and continuation `k`,
only finitely many states are accessed, corresponding roughly to subterms of `c`. -/
theorem tr_supports (c k) : @TM2.Supports _ _ _ _ ⟨trNormal c k⟩ tr (codeSupp c k)
-- Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
@[simp]
theorem toDirectSum_ofDirectSum (x : ⨁ n, ⨂[R]^n M) :
    TensorAlgebra.toDirectSum (ofDirectSum x) = x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem Sublist.eq_of_length_le (s : l₁ <+ l₂) (h : length l₂ ≤ length l₁) : l₁ = l₂
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_pos_iff : 0 < a.toReal ↔ 0 < a ∧ a < ∞
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem consCases_cons {P : (∀ i : Fin n.succ, α i) → Sort v} (h : ∀ x₀ x, P (Fin.cons x₀ x))
    (x₀ : α 0) (x : ∀ i : Fin n, α i.succ) : @consCases _ _ _ h (cons x₀ x) = h x₀ x
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem not_true_eq_false : (¬ True) = False
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : Subgroup G} {x : G} :
    x ∈ a • S ↔ a⁻¹ • x ∈ S
-- Mathlib/RingTheory/Localization/Integral.lean
lemma isAlgebraic_of_isLocalization {R} [CommRing R] (M : Submonoid R) (S) [CommRing S]
    [Nontrivial R] [Algebra R S] [IsLocalization M S] : Algebra.IsAlgebraic R S
-- Mathlib/LinearAlgebra/Pi.lean
theorem pi_ext_iff : f = g ↔ ∀ i x, f (Pi.single i x) = g (Pi.single i x)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma op_tensorUnit : op (𝟙_ C) = 𝟙_ Cᵒᵖ
-- Mathlib/Analysis/Convex/Topology.lean
theorem Convex.openSegment_closure_interior_subset_interior {s : Set E} (hs : Convex 𝕜 s) {x y : E}
    (hx : x ∈ closure s) (hy : y ∈ interior s) : openSegment 𝕜 x y ⊆ interior s
-- Mathlib/Data/List/Basic.lean
@[deprecated bind_pure_eq_map (since := "2024-03-24")]
theorem bind_ret_eq_map (f : α → β) (l : List α) : l.bind (List.ret ∘ f) = map f l
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
theorem mul_left_cancel_iff : a * b = a * c ↔ b = c
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem dual_Iic : Iic (toDual a) = ofDual ⁻¹' Ici a
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_smul [SMul S R] [SMul S M] (s : S) (x : tsze R M) : (s • x).fst = s • x.fst
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem sup_ndunion (s₁ s₂ : Multiset α) : (ndunion s₁ s₂).sup = s₁.sup ⊔ s₂.sup
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability, fun_prop]
theorem Measurable.norm {f : β → α} (hf : Measurable f) : Measurable fun a => norm (f a)
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
@[simp]
theorem intCast_real_norm (x : ℤ[i]) : (x.norm : ℝ) = Complex.normSq (x : ℂ)
-- Mathlib/ModelTheory/Types.lean
@[simp]
theorem compl_setOf_mem {φ : L[[α]].Sentence} :
    { p : T.CompleteType α | φ ∈ p }ᶜ = { p : T.CompleteType α | φ.not ∈ p }
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_mul (a m n : Nat) : a ^ (m * n) = (a ^ m) ^ n
-- Mathlib/CategoryTheory/Bicategory/Kan/Adjunction.lean
theorem isRightAdjoint_TFAE (u : b ⟶ a) :
    List.TFAE [
      IsRightAdjoint u,
      HasAbsLeftKanLift u (𝟙 a),
      ∃ _ : HasLeftKanLift u (𝟙 a), LanLift.CommuteWith u (𝟙 a) u]
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem lcm_zero : (0 : Multiset α).lcm = 1
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Ico_of_ge (hb : b ≤ c) : c ∉ Ico a b
-- Mathlib/Data/NNRat/Defs.lean
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_lt_coe : (p : ℚ) < q ↔ p < q
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem differentiable_inner : Differentiable ℝ fun p : E × E => ⟪p.1, p.2⟫
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem Fix.ind_aux (a : q.P.A) (f : q.P.B a → q.P.W) :
    Fix.mk (abs ⟨a, fun x => ⟦f x⟧⟩) = ⟦⟨a, f⟩⟧
-- Mathlib/Data/Matroid/Restrict.lean
@[simp] protected theorem Matroidᵣ.lt_iff {M M' : Matroidᵣ α} :
    M < M' ↔ (M : Matroid α) <r (M' : Matroid α)
-- Mathlib/FieldTheory/Adjoin.lean
theorem coe_algebraMap_over_bot :
    (algebraMap (⊥ : IntermediateField F E) F : (⊥ : IntermediateField F E) → F) =
      IntermediateField.botEquiv F E
-- Mathlib/CategoryTheory/Comma/Arrow.lean
@[simp]
theorem id_right (f : Arrow T) : CommaMorphism.right (𝟙 f) = 𝟙 f.right
-- Mathlib/GroupTheory/Perm/Basic.lean
@[to_additive existing (attr := simp) zpow_addRight]
lemma zpow_mulRight : ∀ n : ℤ, Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)
-- Mathlib/Order/GaloisConnection.lean
/-- Makes a Galois connection from an order-preserving bijection. -/
theorem OrderIso.to_galoisConnection [Preorder α] [Preorder β] (oi : α ≃o β) :
    GaloisConnection oi oi.symm
-- Mathlib/Topology/Basic.lean
theorem frontier_eq_inter_compl_interior :
    frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem map_range (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
    (map f g).range = (includeLeft.comp f).range ⊔ (includeRight.comp g).range
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem copy_eq (S : Subsemiring R) (s : Set R) (hs : s = ↑S) : S.copy s hs = S
-- Mathlib/Data/Multiset/Basic.lean
theorem eq_of_le_of_card_le {s t : Multiset α} (h : s ≤ t) : card t ≤ card s → s = t