ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Logic/Equiv/Set.lean
/-- If `f` is an injective function, then `s` is equivalent to `f '' s`. -/
@[simps! apply]
protected noncomputable def image {α β} (f : α → β) (s : Set α) (H : Injective f) : s ≃ f '' s
-- Mathlib/Order/Interval/Set/Image.lean
theorem image_subtype_val_Ioo_subset (a b : {x // p x}) :
    Subtype.val '' Ioo a b ⊆ Ioo a.val b.val
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measure_Ico_lt_top : μ (Ico a b) < ∞
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
lemma chromaticNumber_eq_biInf {G : SimpleGraph V} :
    G.chromaticNumber = ⨅ n ∈ setOf G.Colorable, (n : ℕ∞)
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_const_mul_Ioi_zero {k : Type*} [LinearOrderedField k] {x : k} (hx : 0 < x) :
    (fun y => x * y) '' Ioi (0 : k) = Ioi 0
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
lemma exactAt_iff' (hi : c.prev j = i) (hk : c.next j = k) :
    K.ExactAt j ↔ (K.sc' i j k).Exact
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lift_type_lt {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
    lift.{max v w} (type r) < lift.{max u w} (type s) ↔ Nonempty (r ≺i s)
-- Mathlib/Algebra/Order/Hom/Basic.lean
/-- `SubadditiveHomClass F α β` states that `F` is a type of subadditive morphisms. -/
class SubadditiveHomClass (F α β : Type*) [Add α] [Add β] [LE β] [FunLike F α β] : Prop where
  /-- the image of a sum is less or equal than the sum of the images. -/
  map_add_le_add (f : F) : ∀ a b, f (a + b) ≤ f a + f b
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- Linearly disjoint is symmetric in a commutative ring. -/
theorem LinearDisjoint.symm (H : M.LinearDisjoint N) : N.LinearDisjoint M
-- Mathlib/Algebra/Group/Units.lean
@[to_additive] lemma IsUnit.mul : IsUnit a → IsUnit b → IsUnit (a * b)
-- Mathlib/Algebra/Module/PointwisePi.lean
@[to_additive]
theorem smul_univ_pi [∀ i, SMul K (R i)] (r : K) (t : ∀ i, Set (R i)) :
    r • pi (univ : Set ι) t = pi (univ : Set ι) (r • t)
-- Mathlib/Topology/Constructions.lean
/-- Postcomposing `f` with `Prod.fst` is continuous -/
@[fun_prop]
theorem Continuous.fst {f : X → Y × Z} (hf : Continuous f) : Continuous fun x : X => (f x).1
-- Mathlib/Data/Nat/ModEq.lean
/-- To cancel a common factor `c` from a `ModEq` we must divide the modulus `m` by `gcd m c` -/
lemma cancel_right_div_gcd (hm : 0 < m) (h : a * c ≡ b * c [MOD m]) : a ≡ b [MOD m / gcd m c]
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_le [LinearOrderedSemiring α] {m n : PosNum} : (m : α) ≤ n ↔ m ≤ n
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
/-- The orbit of `a` under a subgroup containing the stabilizer of `a` is a block -/
theorem IsBlock.of_orbit {H : Subgroup G} {a : X} (hH : stabilizer G a ≤ H) :
    IsBlock G (MulAction.orbit H a)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem ofRelIsoLT_toRelIsoLT {α β} [PartialOrder α] [PartialOrder β] (e : α ≃o β) :
    ofRelIsoLT (toRelIsoLT e) = e
-- Mathlib/Algebra/BigOperators/Finsupp.lean
lemma sum_cons' [AddCommMonoid M] [AddCommMonoid N] (n : ℕ) (σ : Fin n →₀ M) (i : M)
    (f : Fin (n+1) → M → N) (h : ∀ x, f x 0 = 0) :
    (sum (Finsupp.cons i σ) f) = f 0 i + sum σ (Fin.tail f)
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
/-- `J` commutes with any positively-oriented isometric automorphism. -/
theorem linearIsometryEquiv_comp_rightAngleRotation (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) (x : E) : φ (J x) = J (φ x)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem restrict_toMeasurable_of_cover {s : Set α} {v : ℕ → Set α} (hv : s ⊆ ⋃ n, v n)
    (h'v : ∀ n, μ (s ∩ v n) ≠ ∞) : μ.restrict (toMeasurable μ s) = μ.restrict s
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[elab_as_elim]
theorem inductionOn₃ {p : Cardinal → Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
    (c₃ : Cardinal) (h : ∀ α β γ, p #α #β #γ) : p c₁ c₂ c₃
-- Mathlib/Data/List/Forall2.lean
theorem _root_.Relator.RightUnique.forall₂ (hr : RightUnique R) : RightUnique (Forall₂ R)
-- Mathlib/Data/Nat/Defs.lean
lemma mul_div_eq_iff_dvd {n d : ℕ} : d * (n / d) = n ↔ d ∣ n
-- Mathlib/Topology/Basic.lean
/-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of `s`:
it contains an open set containing `s`. -/
theorem exists_open_set_nhds {U : Set X} (h : ∀ x ∈ s, U ∈ 𝓝 x) :
    ∃ V : Set X, s ⊆ V ∧ IsOpen V ∧ V ⊆ U
-- Mathlib/Probability/Distributions/Gaussian.lean
/-- The gaussian pdf is measurable. -/
lemma measurable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) : Measurable (gaussianPDFReal μ v)
-- Mathlib/Topology/Sheaves/Stalks.lean
/-- Let `F` and `G` be sheaves valued in a concrete category, whose forgetful functor reflects
isomorphisms, preserves limits and filtered colimits. Then a morphism `f : F ⟶ G` is an
isomorphism if and only if all of its stalk maps are isomorphisms.
-/
theorem isIso_iff_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G) :
    IsIso f ↔ ∀ x : X, IsIso ((stalkFunctor C x).map f.1)
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem dot_neg_left (xs ys : IntList) : dot (-xs) ys = -dot xs ys
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem sub_eq_zero {a b : Int} : a - b = 0 ↔ a = b
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_congr_subtype (f : β → α) {P Q : β → Prop} (h : ∀ x, P x ↔ Q x) :
    ∏' x : {x // P x}, f x = ∏' x : {x // Q x}, f x
-- Mathlib/Topology/Separation.lean
theorem t1Space_iff_disjoint_pure_nhds : T1Space X ↔ ∀ ⦃x y : X⦄, x ≠ y → Disjoint (pure x) (𝓝 y)
-- Mathlib/CategoryTheory/Adjunction/Over.lean
/-- When `C` has pushouts, a morphism `f : X ⟶ Y` induces a functor `Under X ⥤ Under Y`,
by pushing a morphism forward along `f`. -/
@[simps]
def pushout {X Y : C} (f : X ⟶ Y) : Under X ⥤ Under Y
-- Mathlib/Order/GaloisConnection.lean
theorem monotone_intro (hu : Monotone u) (hl : Monotone l) (hul : ∀ a, a ≤ u (l a))
    (hlu : ∀ a, l (u a) ≤ a) : GaloisConnection l u
-- Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean
/-- The ring of Witt Vectors of a perfect field of positive characteristic is a DVR.
-/
theorem discreteValuationRing : DiscreteValuationRing (𝕎 k)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- `Finsupp.single 0` as a `RingHom` -/
@[simps]
def singleZeroRingHom [Semiring k] [AddMonoid G] : k →+* k[G]
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem empty_eq_zero : (∅ : Multiset α) = 0
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
theorem sections_eq_nil_of_isEmpty : ∀ {L}, L.any isEmpty → @sections α L = []
-- Mathlib/GroupTheory/FreeGroup/NielsenSchreier.lean
@[simp]
theorem treeHom_root : treeHom T (root' T) = 𝟙 _
-- Mathlib/Order/WithBot.lean
theorem not_top_le_coe (a : α) : ¬(⊤ : WithTop α) ≤ ↑a
-- Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean
@[simp]
theorem iUnion_coe_splitCenterBox (I : Box ι) : ⋃ s, (I.splitCenterBox s : Set (ι → ℝ)) = I
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem vanishingIdeal_iUnion {γ : Sort*} (t : γ → Set (ProjectiveSpectrum 𝒜)) :
    vanishingIdeal (⋃ i, t i) = ⨅ i, vanishingIdeal (t i)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem minimum?_eq_none_iff {xs : List α} [Min α] : xs.minimum? = none ↔ xs = []
-- Mathlib/Order/Grade.lean
protected theorem IsMin.grade (h : IsMin a) : IsMin (grade 𝕆 a)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem continuousAt_gaussian_integral (b : ℂ) (hb : 0 < re b) :
    ContinuousAt (fun c : ℂ => ∫ x : ℝ, cexp (-c * (x : ℂ) ^ 2)) b
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_top' : a * ∞ = if a = 0 then 0 else ∞
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem toHomeomorph_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} : f.toHomeomorph = g.toHomeomorph ↔ f = g
-- Mathlib/Order/Defs.lean
theorem lt_or_gt_of_ne {a b : α} (h : a ≠ b) : a < b ∨ a > b
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
/-- Characterization of multiplicative inverse -/
theorem inv_spec [Nonempty N] {i} {p : Ω^ N X x} :
    ((⟦p⟧)⁻¹ : HomotopyGroup N X x) = ⟦symmAt i p⟧
-- Mathlib/RingTheory/Generators.lean
lemma algebraMap_surjective : Function.Surjective (algebraMap P.Ring S)
-- Mathlib/Algebra/Algebra/Opposite.lean
@[simp] lemma toRingEquiv_toOpposite : (toOpposite R A : A ≃+* Aᵐᵒᵖ) = RingEquiv.toOpposite A
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem map_id_id : Sum.map (@id α) (@id β) = id
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : NonUnitalNonAssocRing R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/Data/Int/GCD.lean
@[simp]
theorem gcd_self (i : ℤ) : gcd i i = natAbs i
-- Mathlib/RingTheory/Finiteness.lean
theorem of_surjective (f : A →ₐ[R] B) (hf : Surjective f) : f.Finite
-- Mathlib/ModelTheory/ElementaryMaps.lean
/-- The **Tarski-Vaught test** for elementarity of an embedding. -/
theorem isElementary_of_exists (f : M ↪[L] N)
    (htv :
      ∀ (n : ℕ) (φ : L.BoundedFormula Empty (n + 1)) (x : Fin n → M) (a : N),
        φ.Realize default (Fin.snoc (f ∘ x) a : _ → N) →
          ∃ b : M, φ.Realize default (Fin.snoc (f ∘ x) (f b) : _ → N)) :
    ∀ {n} (φ : L.Formula (Fin n)) (x : Fin n → M), φ.Realize (f ∘ x) ↔ φ.Realize x
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_union_Ici' (h₁ : c ≤ b) : Ico a b ∪ Ici c = Ici (min a c)
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
lemma DilationEquiv.smulTorsor_preimage_ball {c : P} {k : 𝕜} (hk : k ≠ 0) :
    smulTorsor c hk ⁻¹' (Metric.ball c ‖k‖) = Metric.ball (0 : E) 1
-- Mathlib/RingTheory/Smooth/StandardSmooth.lean
/--
An `R`-algebra `S` is called standard smooth of relative dimension `n`, if there exists
a submersive presentation of dimension `n`.
-/
class IsStandardSmoothOfRelativeDimension : Prop where
  out : ∃ P : SubmersivePresentation.{t, w} R S, P.dimension = n
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem natCast_imK (n : ℕ) : (n : ℍ[R,c₁,c₂]).imK = 0
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem lintegral_rnDeriv_lt_top (μ ν : Measure α) [IsFiniteMeasure μ] :
    ∫⁻ x, μ.rnDeriv ν x ∂ν < ∞
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem unsym_sub [Sub α] (a b : αˢʸᵐ) : unsym (a - b) = unsym a - unsym b
-- Mathlib/Data/Quot.lean
theorem Quotient.mk_out [Setoid α] (a : α) : ⟦a⟧.out ≈ a
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem subtypeDomain_apply {a : Subtype p} {v : α →₀ M} : (subtypeDomain p v) a = v a.val
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem pointed_iff_not_blunt (S : ConvexCone 𝕜 E) : S.Pointed ↔ ¬S.Blunt
-- Mathlib/Analysis/SpecialFunctions/CompareExp.lean
/-- If `l : Filter ℂ` is an "exponential comparison filter", then for any complex `a₁`, `a₂` and any
integer `b₁ < b₂`, we have
`(fun z ↦ z ^ a₁ * exp (b₁ * z)) =o[l] (fun z ↦ z ^ a₂ * exp (b₂ * z))`. -/
theorem isLittleO_zpow_mul_exp {b₁ b₂ : ℝ} (hl : IsExpCmpFilter l) (hb : b₁ < b₂) (m n : ℤ) :
    (fun z => z ^ m * exp (b₁ * z)) =o[l] fun z => z ^ n * exp (b₂ * z)
-- Mathlib/CategoryTheory/CommSq.lean
@[reassoc (attr := simp)]
theorem fac_right [hsq : HasLift sq] : sq.lift ≫ p = g
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
/-- While equal, the former has a convenient definitional reduction. -/
theorem homogeneousSubmodule_eq_finsupp_supported [CommSemiring R] (n : ℕ) :
    homogeneousSubmodule σ R n = Finsupp.supported _ R { d | d.degree = n }
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
lemma restrictScalars_zero : (0 : M →ₗ[S] N).restrictScalars R = 0
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove that
theorem mem_carrier (x : K) : x ∈ A.carrier ↔ x ∈ A
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- A typeclass indicating that the right (aka `MulOpposite`) and left actions by `M` on `α` are
equal, that is that `M` acts centrally on `α`. This can be thought of as a version of commutativity
for `•`. -/
@[to_additive]
class IsCentralScalar (M α : Type*) [SMul M α] [SMul Mᵐᵒᵖ α] : Prop where
  /-- The right and left actions of `M` on `α` are equal. -/
  op_smul_eq_smul : ∀ (m : M) (a : α), MulOpposite.op m • a = m • a
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_injective : Injective (Iic : α → Set α)
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- A single function is uniformly integrable in the probability sense. -/
theorem uniformIntegrable_subsingleton [Subsingleton ι] (hp_one : 1 ≤ p) (hp_top : p ≠ ∞)
    (hf : ∀ i, Memℒp (f i) p μ) : UniformIntegrable f p μ
-- Mathlib/Data/Real/Sqrt.lean
/-- **Cauchy-Schwarz inequality** for finsets using square roots in `ℝ`. -/
lemma sum_sqrt_mul_sqrt_le (s : Finset ι) (hf : ∀ i, 0 ≤ f i) (hg : ∀ i, 0 ≤ g i) :
    ∑ i ∈ s, √(f i) * √(g i) ≤ √(∑ i ∈ s, f i) * √(∑ i ∈ s, g i)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem neg_mul_comm (a b : Int) : -a * b = a * -b
-- Mathlib/Data/Complex/Module.lean
/-- The natural `LinearEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdLm : ℂ ≃ₗ[ℝ] ℝ × ℝ
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
/-- In an infinite-dimensional normed space, there exists a sequence of points which are all
bounded by `R` and at distance at least `1`. For a version not assuming `c` and `R`, see
`exists_seq_norm_le_one_le_norm_sub`. -/
theorem exists_seq_norm_le_one_le_norm_sub' {c : 𝕜} (hc : 1 < ‖c‖) {R : ℝ} (hR : ‖c‖ < R)
    (h : ¬FiniteDimensional 𝕜 E) :
    ∃ f : ℕ → E, (∀ n, ‖f n‖ ≤ R) ∧ Pairwise fun m n => 1 ≤ ‖f m - f n‖
-- Mathlib/Algebra/Lie/Submodule.lean
theorem Submodule.exists_lieSubmodule_coe_eq_iff (p : Submodule R M) :
    (∃ N : LieSubmodule R L M, ↑N = p) ↔ ∀ (x : L) (m : M), m ∈ p → ⁅x, m⁆ ∈ p
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If `‖pₙ‖ rⁿ = O(1)`, as `n → ∞`, then the radius of `p` is at least `r`. -/
theorem le_radius_of_isBigO (h : (fun n => ‖p n‖ * (r : ℝ) ^ n) =O[atTop] fun _ => (1 : ℝ)) :
    ↑r ≤ p.radius
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
    a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b'
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
/-- As well as being linear, `ι Q` squares to the quadratic form -/
@[simp]
theorem ι_sq_scalar (m : M) : ι Q m * ι Q m = algebraMap R _ (Q m)
-- Mathlib/Algebra/Order/Kleene.lean
@[simp]
theorem kstar_idem (a : α) : a∗∗ = a∗
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem mem_comap (S : NonUnitalStarSubalgebra R B) (f : F) (x : A) : x ∈ comap f S ↔ f x ∈ S
-- Mathlib/Algebra/SMulWithZero.lean
/-- Scalar multiplication as a monoid homomorphism with zero. -/
@[simps]
def smulMonoidWithZeroHom {α β : Type*} [MonoidWithZero α] [MulZeroOneClass β]
    [MulActionWithZero α β] [IsScalarTower α β β] [SMulCommClass α β β] : α × β →*₀ β
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- If `x : R` is multiplicative for `f`, then it is multiplicative for
  `seminormFromConst' hf1 hc hpm`. -/
theorem seminormFromConst_isMul_of_isMul {x : R} (hx : ∀ y : R, f (x * y) = f x * f y) (y : R) :
    seminormFromConst' hf1 hc hpm (x * y) =
      seminormFromConst' hf1 hc hpm x * seminormFromConst' hf1 hc hpm y
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem disjoint_nhdsSet_cobounded {s : Set α} (hs : IsCompact s) : Disjoint (𝓝ˢ s) (cobounded α)
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem Squarefree.gcd_left {a : α} (b : α) (ha : Squarefree a) : Squarefree (gcd a b)
-- Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean
theorem recF_eq {α : TypeVec n} {β : Type u} (g : F (α.append1 β) → β) (a : q.P.A)
    (f' : q.P.drop.B a ⟹ α) (f : q.P.last.B a → q.P.W α) :
    recF g (q.P.wMk a f' f) = g (abs ⟨a, splitFun f' (recF g ∘ f)⟩)
-- Mathlib/Order/SuccPred/Basic.lean
theorem Icc_pred_right_of_not_isMin (ha : ¬IsMin b) : Icc a (pred b) = Ico a b
-- Mathlib/Data/Real/Archimedean.lean
theorem of_near (f : ℕ → ℚ) (x : ℝ) (h : ∀ ε > 0, ∃ i, ∀ j ≥ i, |(f j : ℝ) - x| < ε) :
    ∃ h', Real.mk ⟨f, h'⟩ = x
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem comp_assoc (f : TopHom γ δ) (g : TopHom β γ) (h : TopHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp high]
theorem toFinsupp_X_pow (n : ℕ) : (X ^ n).toFinsupp = Finsupp.single n (1 : R)
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem finite_Iic : (Iic b).Finite
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
theorem ext_iff {A B : CostructuredArrow S T} (f g : A ⟶ B) : f = g ↔ f.left = g.left
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Simproc.lean
theorem add_le_add_ge (a c : Nat) {b d : Nat} (h : b ≥ d) : (a + b ≤ c + d) = (a + (b - d) ≤ c)
-- Mathlib/Control/Monad/Cont.lean
theorem run_withContT (f : (β → m r) → α → m r) (x : ContT r m α) :
    run (withContT f x) = run x ∘ f
-- Mathlib/NumberTheory/LSeries/Basic.lean
@[simp]
theorem LSeriesSummable_zero {s : ℂ} : LSeriesSummable 0 s
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp 1001] -- Porting note: increase `simp` priority so left-hand side doesn't simplify
theorem truncate_one_one {a b : X} (γ : Path a b) :
    γ.truncate 1 1 = (Path.refl b).cast (by rw [min_self, γ.extend_one]) γ.extend_one
-- Mathlib/CategoryTheory/Shift/Induced.lean
@[simp]
lemma zero_hom_app_obj (X : C) :
    (zero F s i).hom.app (F.obj X) =
      (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X)
-- Mathlib/Algebra/Homology/Opposite.lean
theorem imageToKernel_op {X Y Z : V} (f : X ⟶ Y) (g : Y ⟶ Z) (w : f ≫ g = 0) :
    imageToKernel g.op f.op (by rw [← op_comp, w, op_zero]) =
      (imageSubobjectIso _ ≪≫ (imageOpOp _).symm).hom ≫
        (cokernel.desc f (factorThruImage g)
              (by rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp])).op ≫
          (kernelSubobjectIso _ ≪≫ kernelOpOp _).inv
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unitary.lean
lemma mem_unitary_of_spectrum_subset_circle {u : A}
    [IsStarNormal u] (hu : spectrum ℂ u ⊆ circle) : u ∈ unitary A
-- Mathlib/Data/Multiset/Bind.lean
theorem bind_map_comm (m : Multiset α) (n : Multiset β) {f : α → β → γ} :
    ((bind m) fun a => n.map fun b => f a b) = (bind n) fun b => m.map fun a => f a b
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- A measure `μ` is inner regular if, for any measurable set `s`, then
`μ(s) = sup {μ(K) | K ⊆ s compact}`. -/
class InnerRegular (μ : Measure α) : Prop where
  protected innerRegular : InnerRegularWRT μ IsCompact (fun s ↦ MeasurableSet s)
-- Mathlib/RingTheory/Norm/Defs.lean
theorem norm_eq_matrix_det [Fintype ι] [DecidableEq ι] (b : Basis ι R S) (s : S) :
    norm R s = Matrix.det (Algebra.leftMulMatrix b s)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem ofReal_eq_one {z : ℝ} : (z : ℂ) = 1 ↔ z = 1
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
@[simp]
theorem toZ_of_eq : toZ i0 i0 = 0
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem false_xor : ∀ (x : Bool), xor false x = x
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- An injective family `v : ι → E` is orthonormal if and only if `Subtype.val : (range v) → E` is
orthonormal. -/
theorem orthonormal_subtype_range {v : ι → E} (hv : Function.Injective v) :
    Orthonormal 𝕜 (Subtype.val : Set.range v → E) ↔ Orthonormal 𝕜 v
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
/-- See Note [no_index around OfNat.ofNat] -/
lemma cpow_mul_ofNat (x y : ℂ) (n : ℕ) [n.AtLeastTwo] :
    x ^ (y * no_index (OfNat.ofNat n)) = (x ^ y) ^ (OfNat.ofNat n : ℕ)
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem Nontrivial.infsep_of_fintype [DecidableEq α] [Fintype s] (hs : s.Nontrivial) :
    s.infsep = s.offDiag.toFinset.inf' (by simpa) (uncurry dist)
-- Mathlib/Logic/Small/Group.lean
@[to_additive existing (attr := simp)]
lemma equivShrink_symm_inv [Inv α] [Small α] (x : Shrink α) :
    (equivShrink α).symm x⁻¹ = ((equivShrink α).symm x)⁻¹
-- Mathlib/Topology/ContinuousFunction/Basic.lean
/-- Deprecated. Use `DFunLike.congr_fun` instead. -/
protected theorem congr_fun {f g : C(α, β)} (H : f = g) (x : α) : f x = g x
-- Mathlib/Order/MinMax.lean
theorem Max.left_comm (a b c : α) : max a (max b c) = max b (max a c)
-- Mathlib/Algebra/Tropical/Basic.lean
theorem untrop_eq_iff_eq_trop {x} {y : R} : untrop x = y ↔ x = trop y
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem measurable_coeFn [MeasurableSpace β] [BorelSpace β] (f : α →₁[μ] β) : Measurable f
-- Mathlib/Data/Real/Cardinality.lean
/-- The cardinality of the interval (-∞, a). -/
theorem mk_Iio_real (a : ℝ) : #(Iio a) = 𝔠
-- Mathlib/Order/Closure.lean
@[simp]
theorem closure_iSup_closure (f : ι → α) : c (⨆ i, c (f i)) = c (⨆ i, f i)
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem bot_lt_top : (⊥ : α) < ⊤
-- Mathlib/MeasureTheory/Function/LpSpace.lean
protected theorem dist_edist (f g : Lp E p μ) : dist f g = (edist f g).toReal
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem pi_div_two_eq_arcsin {x} : π / 2 = arcsin x ↔ 1 ≤ x
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
private lemma inf_aux : a ∈ upperClosure s → (s.filter (· ≤ a)).Nonempty
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp] theorem rTensor_zpow (f : M ≃ₗ[R] M) (n : ℤ) : f.rTensor N ^ n = (f ^ n).rTensor N
-- Mathlib/Data/Set/Image.lean
@[simp]
lemma preimage_symmDiff {f : α → β} (s t : Set β) : f ⁻¹' (s ∆ t) = (f ⁻¹' s) ∆ (f ⁻¹' t)
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem continuousAt_fract [OrderClosedTopology α] [TopologicalAddGroup α]
    {x : α} (h : x ≠ ⌊x⌋) : ContinuousAt fract x
-- Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean
theorem commute_map_mul_map_of_isOrtho_of_mem_evenOdd_zero_left
    {i₂ : ZMod 2} (hm₁ : m₁ ∈ evenOdd Q₁ 0) (hm₂ : m₂ ∈ evenOdd Q₂ i₂) :
    Commute (map f₁ m₁) (map f₂ m₂)
-- Mathlib/FieldTheory/IsAlgClosed/Classification.lean
theorem cardinal_le_max_transcendence_basis (hv : IsTranscendenceBasis R v) :
    #K ≤ max (max #R #ι) ℵ₀
-- Mathlib/Topology/MetricSpace/Infsep.lean
@[simp]
theorem einfsep_empty : (∅ : Set α).einfsep = ∞
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Function.Bijective.cauchySeq_comp_iff {f : ℕ → ℕ} (hf : Bijective f) (u : ℕ → α) :
    CauchySeq (u ∘ f) ↔ CauchySeq u
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_iInf (f : ι → UpperSet α) : (↑(⨅ i, f i) : Set α) = ⋃ i, f i
-- Mathlib/RingTheory/Fintype.lean
lemma Finset.univ_of_card_le_three (h : Fintype.card R ≤ 3) :
    (univ : Finset R) = {0, 1, -1}
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_map {T : Type*} [Semiring T] {I : Ideal R} (f : R →+* S) (g : S →+* T) :
    (I.map f).map g = I.map (g.comp f)
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem degrees_X' (n : σ) : degrees (X n : MvPolynomial σ R) ≤ {n}
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
lemma toFinset_Iic (a : α) [Fintype (Iic a)] : (Iic a).toFinset = Finset.Iic a
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
/-- Auxiliary lemma used in the proof of `setIntegral_condexpL1CLM`. -/
theorem setIntegral_condexpL1CLM_of_measure_ne_top (f : α →₁[μ] F') (hs : MeasurableSet[m] s)
    (hμs : μ s ≠ ∞) : ∫ x in s, condexpL1CLM F' hm μ f x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Algebra/DirectSum/Decomposition.lean
theorem degree_eq_of_mem_mem {x : M} {i j : ι} (hxi : x ∈ ℳ i) (hxj : x ∈ ℳ j) (hx : x ≠ 0) :
    i = j
-- Mathlib/Deprecated/Group.lean
/-- A multiplicative bijection between two monoids is a monoid hom
  (deprecated -- use `MulEquiv.toMonoidHom`). -/
@[to_additive
      "An additive bijection between two additive monoids is an additive
      monoid hom (deprecated). "]
theorem isMonoidHom (h : M ≃* N) : IsMonoidHom h
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- See also `Finset.prod_ite_eq'`. -/
@[to_additive "See also `Finset.sum_ite_eq'`."]
lemma prod_ite_eq' (i : ι) (f : ι → α) : ∏ j, (if j = i then f j else 1) = f i
-- Mathlib/Data/Int/Order/Units.lean
theorem isUnit_sq {a : ℤ} (ha : IsUnit a) : a ^ 2 = 1
-- Mathlib/Data/Set/Basic.lean
theorem ssubset_iff_insert {s t : Set α} : s ⊂ t ↔ ∃ a ∉ s, insert a s ⊆ t
-- Mathlib/GroupTheory/Perm/Support.lean
theorem card_support_prod_list_of_pairwise_disjoint {l : List (Perm α)} (h : l.Pairwise Disjoint) :
    l.prod.support.card = (l.map (Finset.card ∘ support)).sum