ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem le_opNorm_of_le {c : ℝ} {x} (h : ‖x‖ ≤ c) : ‖f x‖ ≤ ‖f‖ * c
-- Mathlib/Algebra/DualQuaternion.lean
@[simp]
theorem snd_re_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :
    (dualNumberEquiv.symm d).re.snd = d.snd.re
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem toBlocks_fromBlocks₂₂ (A : Matrix n l α) (B : Matrix n m α) (C : Matrix o l α)
    (D : Matrix o m α) : (fromBlocks A B C D).toBlocks₂₂ = D
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_dvd (m n : Nat) : (gcd m n ∣ m) ∧ (gcd m n ∣ n)
-- Mathlib/Algebra/Homology/HomologicalComplexLimits.lean
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F
-- Mathlib/RingTheory/AlgebraTower.lean
@[simp]
theorem Basis.smulTower_repr {ι : Type v₁} {ι' : Type w₁}
    (b : Basis ι R S) (c : Basis ι' S A) (x ij) :
    (b.smulTower c).repr x ij = b.repr (c.repr x ij.2) ij.1
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem le_iff (h : π₂.IsPartition) :
    π₁ ≤ π₂ ↔ ∀ J ∈ π₁, ∀ J' ∈ π₂, (J ∩ J' : Set (ι → ℝ)).Nonempty → J ≤ J'
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
theorem toPartialEquiv_coe : (I.toPartialEquiv : H → E) = I
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- For ideals in a Dedekind domain, to divide is to contain. -/
theorem Ideal.dvd_iff_le {I J : Ideal A} : I ∣ J ↔ J ≤ I
-- Mathlib/Data/Set/Finite.lean
theorem Finite.fin_embedding {s : Set α} (h : s.Finite) :
    ∃ (n : ℕ) (f : Fin n ↪ α), range f = s
-- Mathlib/Analysis/Convex/Topology.lean
theorem Convex.openSegment_self_interior_subset_interior {s : Set E} (hs : Convex 𝕜 s) {x y : E}
    (hx : x ∈ s) (hy : y ∈ interior s) : openSegment 𝕜 x y ⊆ interior s
-- Mathlib/Combinatorics/Enumerative/Partition.lean
/-- A composition induces a partition (just convert the list to a multiset). -/
@[simps]
def ofComposition (n : ℕ) (c : Composition n) : Partition n
-- Mathlib/Topology/Algebra/UniformField.lean
theorem hatInv_extends {x : K} (h : x ≠ 0) : hatInv (x : hat K) = ↑(x⁻¹ : K)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem norm_cexp_neg_mul_sq_add_mul_I' (hb : b.re ≠ 0) (c T : ℝ) :
    ‖cexp (-b * (T + c * I) ^ 2)‖ =
      exp (-(b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re)))
-- Mathlib/Computability/Ackermann.lean
theorem ack_strictMono_left (n : ℕ) : StrictMono fun m => ack m n
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_one_add_smoothingFn_pos : ∀ᶠ (n : ℕ) in atTop, 0 < 1 + ε n
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem Metric.uniformity_edist_aux {α} (d : α → α → ℝ≥0) :
    ⨅ ε > (0 : ℝ), 𝓟 { p : α × α | ↑(d p.1 p.2) < ε } =
      ⨅ ε > (0 : ℝ≥0∞), 𝓟 { p : α × α | ↑(d p.1 p.2) < ε }
-- Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean
@[to_additive] lemma prod_eq_one_iff : m.prod = 1 ↔ ∀ x ∈ m, x = (1 : α)
-- Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
/-- Reformulated functional equation with `f` and `g` interchanged. -/
lemma WeakFEPair.h_feq' (P : WeakFEPair E) (x : ℝ) (hx : 0 < x) :
    P.g (1 / x) = (P.ε⁻¹ * ↑(x ^ P.k)) • P.f x
-- Mathlib/Topology/Homotopy/Basic.lean
nonrec theorem prodMk {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(X, Z)} :
    Homotopic f₀ f₁ → Homotopic g₀ g₁ → Homotopic (f₀.prodMk g₀) (f₁.prodMk g₁)
-- Mathlib/LinearAlgebra/Basis.lean
/-- Let `b` be an `S`-basis of `M`. Then `m : M` lies in the `R`-module spanned by `b` iff all the
coordinates of `m` on the basis `b` are in `R` (see `Basis.mem_span` for the case `R = S`). -/
theorem Basis.mem_span_iff_repr_mem (m : M) :
    m ∈ span R (Set.range b) ↔ ∀ i, b.repr m i ∈ Set.range (algebraMap R S)
-- Mathlib/Algebra/Lie/TensorProduct.lean
@[simp]
theorem coe_linearMap_map (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) :
    (map f g : M ⊗[R] N →ₗ[R] P ⊗[R] Q) = TensorProduct.map (f : M →ₗ[R] P) (g : N →ₗ[R] Q)
-- Mathlib/ModelTheory/Substructures.lean
theorem le_comap_map {f : M →[L] N} : S ≤ (S.map f).comap f
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq_setToL1S (f : α →₁ₛ[μ] E) : integral f = setToL1S (weightedSMul μ) f
-- Mathlib/Order/Filter/Partial.lean
theorem tendsto_iff_ptendsto_univ (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ PTendsto (PFun.res f Set.univ) l₁ l₂
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem closure_eq_inter_uniformity {t : Set (α × α)} : closure t = ⋂ d ∈ 𝓤 α, d ○ (t ○ d)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem dotProduct_diagonal' (i : m) : (v ⬝ᵥ fun j => diagonal w j i) = v i * w i
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma equation_some (X Y : R) : W'.Equation ![X, Y, 1] ↔ W'.toAffine.Equation X Y
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem apply_symm_apply (x : P₂) : e (e.symm x) = x
-- Mathlib/Data/NNReal/Basic.lean
@[simp] lemma toNNReal_abs (x : ℝ) : |x|.toNNReal = nnabs x
-- Mathlib/Order/Lattice.lean
@[simp] lemma sup_eq_inf : a ⊔ b = a ⊓ b ↔ a = b
-- Mathlib/GroupTheory/Perm/Fin.lean
theorem isThreeCycle_cycleRange_two {n : ℕ} : IsThreeCycle (cycleRange 2 : Perm (Fin (n + 3)))
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem encode_of_not_none_mem [DecidableEq α] (s : Sym (Option α) n.succ) (h : ¬none ∈ s) :
    encode s =
      Sum.inr
        (s.attach.map fun o =>
          o.1.get <| Option.ne_none_iff_isSome.1 <| ne_of_mem_of_not_mem o.2 h)
-- Mathlib/Topology/Instances/Matrix.lean
theorem HasSum.matrix_diag {f : X → Matrix n n R} {a : Matrix n n R} (hf : HasSum f a) :
    HasSum (fun x => diag (f x)) (diag a)
-- Mathlib/Topology/DenseEmbedding.lean
protected theorem continuous (di : DenseInducing i) : Continuous i
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- To give an isomorphism between cocones, it suffices to give an
  isomorphism between their vertices which commutes with the cocone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Bicone F} (φ : c.pt ≅ c'.pt)
    (wι : ∀ j, c.ι j ≫ φ.hom = c'.ι j := by aesop_cat)
    (wπ : ∀ j, φ.hom ≫ c'.π j = c.π j := by aesop_cat) : c ≅ c'
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem dvd_of_mem_factors' {a : α} {p : Associates α} {hp : Irreducible p} {hz : a ≠ 0}
    (h_mem : Subtype.mk p hp ∈ factors' a) : p ∣ Associates.mk a
-- Mathlib/Data/Multiset/Powerset.lean
theorem powersetCard_le_powerset (n : ℕ) (s : Multiset α) : powersetCard n s ≤ powerset s
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem not_isUnit_X_pow_sub_one (R : Type*) [CommRing R] [Nontrivial R] (n : ℕ) :
    ¬IsUnit (X ^ n - 1 : R[X])
-- Mathlib/Order/Filter/SmallSets.lean
theorem hasBasis_smallSets (l : Filter α) :
    HasBasis l.smallSets (fun t : Set α => t ∈ l) powerset
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem prod_eq_iff_eq (ht : t.Nonempty) : s ×ˢ t = s₁ ×ˢ t ↔ s = s₁
-- Mathlib/Topology/Sober.lean
theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [QuasiSober β] :
    QuasiSober α
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
/-- A (multiplicative) Lie group is a group and a smooth manifold at the same time in which
the multiplication and inverse operations are smooth. -/
@[to_additive]
class LieGroup {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Group G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothMul I G : Prop where
  /-- Inversion is smooth in a Lie group. -/
  smooth_inv : Smooth I I fun a : G => a⁻¹
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem dirac_bind {m : Measure α} : bind m dirac = m
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem hasMFDerivWithinAt_id (s : Set M) (x : M) :
    HasMFDerivWithinAt I I (@id M) s x (ContinuousLinearMap.id 𝕜 (TangentSpace I x))
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = s
-- Mathlib/Data/DFinsupp/Lex.lean
/-- The less-or-equal relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLE : @DecidableRel (Lex (Π₀ i, α i)) (· ≤ ·)
-- Mathlib/Data/Semiquot.lean
@[simp]
theorem bind_def {β} : ((· >>= ·) : Semiquot α → (α → Semiquot β) → Semiquot β) = bind
-- Mathlib/Order/JordanHolder.lean
theorem eq_snoc_eraseLast {s : CompositionSeries X} (h : 0 < s.length) :
    s = snoc (eraseLast s) s.last (isMaximal_eraseLast_last h)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_congr_measure_of_integrable {μ' : Measure α} (c' : ℝ≥0∞) (hc' : c' ≠ ∞)
    (hμ'_le : μ' ≤ c' • μ) (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ' T C') (f : α → E) (hfμ : Integrable f μ) :
    setToFun μ T hT f = setToFun μ' T hT' f
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem gluedLift_p1 : gluedLift 𝒰 f g s ≫ p1 𝒰 f g = s.fst
-- Mathlib/Data/Rat/Lemmas.lean
theorem mul_num_den' (q r : ℚ) :
    (q * r).num * q.den * r.den = q.num * r.num * (q * r).den
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem eq_iff_eq_of_div_eq_div (H : a / b = c / d) : a = b ↔ c = d
-- Mathlib/Data/Finset/Sym.lean
theorem sym2_eq_image : s.sym2 = (s ×ˢ s).image Sym2.mk
-- Mathlib/Topology/Bases.lean
/-- If `β` is a second-countable space, then its induced topology via
`f` on `α` is also second-countable. -/
theorem secondCountableTopology_induced (β) [t : TopologicalSpace β] [SecondCountableTopology β]
    (f : α → β) : @SecondCountableTopology α (t.induced f)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
/-- Simplifies a normal form from `get!` -/
@[simp] theorem getD_get?_setD (a : Array α) (i : Nat) (v d : α) :
  Option.getD (setD a i v)[i]? d = if i < a.size then v else d
-- Mathlib/Data/List/Range.lean
theorem pairwise_lt_range (n : ℕ) : Pairwise (· < ·) (range n)
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp]
theorem mul_eq_right₀ (hb : b ≠ 0) : a * b = b ↔ a = 1
-- Mathlib/Logic/Equiv/Option.lean
theorem removeNone_aux_inv (x : α) : removeNone_aux e.symm (removeNone_aux e x) = x
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodySumFun_add_le (x y : E K) :
    convexBodySumFun (x + y) ≤ convexBodySumFun x + convexBodySumFun y
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem coe_mapRingHom (f : R →+* S) : ⇑(mapRingHom f) = map f
-- Mathlib/FieldTheory/Minpoly/Field.lean
theorem dvd_map_of_isScalarTower (A K : Type*) {R : Type*} [CommRing A] [Field K] [CommRing R]
    [Algebra A K] [Algebra A R] [Algebra K R] [IsScalarTower A K R] (x : R) :
    minpoly K x ∣ (minpoly A x).map (algebraMap A K)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_snd_prod : g' =O[l] fun x => (f' x, g' x)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_eq_empty_iff : Ico a b = ∅ ↔ ¬a < b
-- Mathlib/Combinatorics/Colex.lean
@[simp] lemma ofColex_top [Fintype α] : ofColex (⊤ : Colex α) = univ
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast] lemma coe_add (x y : ℝ≥0) : (↑(x + y) : ℝ≥0∞) = x + y
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem measure_zero_iff_ae_nmem {s : Set α} : μ s = 0 ↔ ∀ᵐ a ∂μ, a ∉ s
-- Mathlib/Analysis/Complex/Convex.lean
/-- The slit plane is star-shaped at a positive real number. -/
lemma starConvex_ofReal_slitPlane {x : ℝ} (hx : 0 < x) : StarConvex ℝ ↑x slitPlane
-- Mathlib/Algebra/Polynomial/Reverse.lean
theorem coeff_reverse (f : R[X]) (n : ℕ) : f.reverse.coeff n = f.coeff (revAt f.natDegree n)
-- Mathlib/CategoryTheory/Adhesive.lean
theorem IsPushout.IsVanKampen.mono_of_mono_left [Mono f] {H : IsPushout f g h i}
    (H' : H.IsVanKampen) : Mono i
-- Mathlib/MeasureTheory/Function/Jacobian.lean
theorem lintegral_abs_det_fderiv_le_addHaar_image_aux2 (hs : MeasurableSet s) (h's : μ s ≠ ∞)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hf : InjOn f s) :
    (∫⁻ x in s, ENNReal.ofReal |(f' x).det| ∂μ) ≤ μ (f '' s)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
theorem mul_ι_mul_ι_of_isOrtho (x : CliffordAlgebra Q) {a b : M} (h : Q.IsOrtho a b) :
    x * ι Q a * ι Q b = -(x * ι Q b * ι Q a)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem refl_trans (e : P₁ ≃ᵃ[k] P₂) : (refl k P₁).trans e = e
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem cospan_right {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).obj WalkingCospan.right = Y
-- Mathlib/Algebra/Field/Subfield.lean
/-- Product of a multiset of elements in a subfield is in the subfield. -/
protected theorem multiset_prod_mem (m : Multiset K) : (∀ a ∈ m, a ∈ s) → m.prod ∈ s
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Fractions.lean
lemma exists_leftFraction₂ [W.HasLeftCalculusOfFractions] :
    ∃ (ψ : W.LeftFraction₂ X Y), φ.f ≫ ψ.s = φ.s ≫ ψ.f ∧
      φ.f' ≫ ψ.s = φ.s ≫ ψ.f'
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean
@[simp]
theorem map_id_c_app (F : J ⥤ PresheafedSpace.{_, _, v} C) (j) (U) :
    (F.map (𝟙 j)).c.app U =
      (Pushforward.id (F.obj j).presheaf).inv.app U ≫
        (pushforwardEq (by simp) (F.obj j).presheaf).hom.app U
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
theorem norm_symm_pos [RingHomIsometric σ₁₂] [Nontrivial E] (e : E ≃SL[σ₁₂] F) :
    0 < ‖(e.symm : F →SL[σ₂₁] E)‖
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.exists_pos (h : IsBigOWith c l f g') :
    ∃ c' > 0, IsBigOWith c' l f g'
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Eta rule for costructured arrows. Prefer `CostructuredArrow.eta` for rewriting, as equality of
    objects tends to cause problems. -/
theorem eq_mk (f : CostructuredArrow S T) : f = mk f.hom
-- Mathlib/Data/Nat/Digits.lean
theorem sub_one_mul_sum_log_div_pow_eq_sub_sum_digits {p : ℕ} (n : ℕ) :
    (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
@[simp]
theorem constantCoeff_inv (φ : MvPowerSeries σ k) :
    constantCoeff σ k φ⁻¹ = (constantCoeff σ k φ)⁻¹
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle as a ratio of sides. -/
theorem tan_angle_add_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) :
    Real.tan (angle x (x + y)) = ‖y‖ / ‖x‖
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
/-- Given a linear map `f : N → P`, `f ⊗ M` is injective if and only if `M ⊗ f` is injective. -/
theorem lTensor_inj_iff_rTensor_inj :
    Function.Injective (lTensor M f) ↔ Function.Injective (rTensor M f)
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem le_hausdorffMeasure_image (hf : AntilipschitzWith K f) (hd : 0 ≤ d) (s : Set X) :
    μH[d] s ≤ (K : ℝ≥0∞) ^ d * μH[d] (f '' s)
-- Mathlib/Topology/VectorBundle/Basic.lean
protected theorem linear [AddCommMonoid F] [Module R F] [∀ x, AddCommMonoid (E x)]
    [∀ x, Module R (E x)] [e.IsLinear R] {b : B} (hb : b ∈ e.baseSet) :
    IsLinearMap R fun y : E b => (e ⟨b, y⟩).2
-- Mathlib/NumberTheory/LSeries/Linearity.lean
@[simp]
lemma LSeries_neg (f : ℕ → ℂ) (s : ℂ) : LSeries (-f) s = -LSeries f s
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : NonUnitalCommRing R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/Data/Set/Function.lean
theorem EqOn.comp_left (h : s.EqOn f₁ f₂) : s.EqOn (g ∘ f₁) (g ∘ f₂)
-- Mathlib/Data/Real/ConjExponents.lean
protected lemma Real.IsConjExponent.toNNReal {p q : ℝ} (hpq : p.IsConjExponent q) :
    p.toNNReal.IsConjExponent q.toNNReal
-- Mathlib/Data/Real/Sqrt.lean
lemma sqrt_lt_sqrt : sqrt x < sqrt y ↔ x < y
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive]
theorem prod_pair (a b : α) : ({a, b} : Multiset α).prod = a * b
-- Mathlib/RingTheory/LocalRing/RingHom/Basic.lean
@[simp (high)]
theorem map_mem_nonunits_iff (f : R →+* S) [IsLocalRingHom f] (a) :
    f a ∈ nonunits S ↔ a ∈ nonunits R
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extend_coe_symm : ⇑(f.extend I).symm = f.symm ∘ I.symm
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
@[simp]
lemma ofTensorProductEquivOfFiniteNoetherian_apply [Module.Finite R M]
    (x : AdicCompletion I R ⊗[R] M) :
    ofTensorProductEquivOfFiniteNoetherian I M x = ofTensorProduct I M x
-- Mathlib/ModelTheory/Substructures.lean
/-- Substructure closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure L s ≤ closure L t`. -/
theorem closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure L s ≤ closure L t
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_toReal_eq {f : α → ℝ≥0∞} (hf : ∀ a, f a ≠ ∞) :
    (∑' a, f a).toReal = ∑' a, (f a).toReal
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem isReflection_simple (i : B) : cs.IsReflection (s i)
-- Mathlib/Order/Bounds/Basic.lean
theorem bddAbove_def : BddAbove s ↔ ∃ x, ∀ y ∈ s, y ≤ x
-- Mathlib/RingTheory/Norm/Basic.lean
lemma norm_eq_of_ringEquiv {A B C : Type*} [CommRing A] [CommRing B] [Ring C]
    [Algebra A C] [Algebra B C] (e : A ≃+* B) (he : (algebraMap B C).comp e = algebraMap A C)
    (x : C) :
    e (Algebra.norm A x) = Algebra.norm B x
-- Mathlib/Data/Multiset/Fold.lean
theorem fold_eq_foldr (b : α) (s : Multiset α) :
    fold op b s = foldr op (left_comm _ hc.comm ha.assoc) b s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arcsin_projIcc (x : ℝ) :
    arcsin (projIcc (-1) 1 (neg_le_self zero_le_one) x) = arcsin x
-- Mathlib/Data/Nat/Defs.lean
lemma one_lt_pow' (n m : ℕ) : 1 < (m + 2) ^ (n + 1)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem strictMonoOn_logb : StrictMonoOn (logb b) (Set.Ioi 0)
-- Mathlib/Data/Set/Image.lean
theorem preimage_subtype_coe_eq_compl {s u v : Set α} (hsuv : s ⊆ u ∪ v)
    (H : s ∩ (u ∩ v) = ∅) : ((↑) : s → α) ⁻¹' u = ((↑) ⁻¹' v)ᶜ
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepFun.neg_right {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'} [Neg β']
    [MeasurableNeg β'] (hfg : IndepFun f g μ) :
    IndepFun f (-g) μ
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_nonneg : 0 ≤ ⌊a⌋ ↔ 0 ≤ a
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
/-- The canonical map from the adic completion of the product to the product of the
adic completions. -/
@[simps!]
def pi : AdicCompletion I (∀ j, M j) →ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j)
-- Mathlib/RingTheory/Ideal/Colon.lean
@[simp]
theorem _root_.Ideal.mem_colon_singleton {I : Ideal R} {x r : R} :
    r ∈ I.colon (Ideal.span {x}) ↔ r * x ∈ I
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_localTriv_target (p : B × F) :
    p ∈ (Z.localTriv i).target ↔ p.1 ∈ (Z.localTriv i).baseSet
-- Mathlib/Data/Nat/Cast/Synonym.lean
@[simp]
theorem ofDual_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (ofDual (no_index (OfNat.ofNat n : αᵒᵈ))) = OfNat.ofNat n
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem comap_comap (s : NonUnitalSubring T) (g : S →ₙ+* T) (f : R →ₙ+* S) :
    (s.comap g).comap f = s.comap (g.comp f)
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
@[refl] theorem Subperm.refl (l : List α) : l <+~ l
-- Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean
theorem contMDiffOn_chart_symm : ContMDiffOn I I n (chartAt H x).symm (chartAt H x).target
-- Mathlib/Analysis/Normed/Group/Quotient.lean
/-- An alternative definition of the norm on the quotient group: the norm of `((x : M) : M ⧸ S)` is
equal to the distance from `x` to `S`. -/
theorem QuotientAddGroup.norm_mk {S : AddSubgroup M} (x : M) :
    ‖(x : M ⧸ S)‖ = infDist x S
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
/-- The complex hyperbolic cosine function is everywhere differentiable, with the derivative
`sinh x`. -/
theorem hasDerivAt_cosh (x : ℂ) : HasDerivAt cosh (sinh x) x
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- Relation `fun f g ↦ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)` is reflexive. -/
theorem tendsto_diag_uniformity (f : β → α) (l : Filter β) :
    Tendsto (fun x => (f x, f x)) l (𝓤 α)
-- Mathlib/Topology/Compactness/Compact.lean
protected theorem ClosedEmbedding.compactSpace [h : CompactSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : CompactSpace X
-- Mathlib/Order/Estimator.lean
/--
If `Estimator.improveUntil a p e` returns `some e'`, then `bound a e'` satisfies `p`.
Otherwise, that value `a` must not satisfy `p`.
-/
theorem Estimator.improveUntil_spec
    (a : Thunk α) (p : α → Bool) [Estimator a ε] [WellFoundedGT (range (bound a : ε → α))] (e : ε) :
    match Estimator.improveUntil a p e with
    | .error _ => ¬ p a.get
    | .ok e' => p (bound a e')
-- Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean
theorem contDiff_clm_apply_iff {n : ℕ∞} {f : E → F →L[𝕜] G} [FiniteDimensional 𝕜 F] :
    ContDiff 𝕜 n f ↔ ∀ y, ContDiff 𝕜 n fun x => f x y
-- Mathlib/Analysis/Seminorm.lean
theorem closedBall_mono {p : Seminorm 𝕜 E} {r₁ r₂ : ℝ} (h : r₁ ≤ r₂) :
    p.closedBall x r₁ ⊆ p.closedBall x r₂
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem eq_one_of_mul_eq_self_left {a b : Int} (Hpos : a ≠ 0) (H : b * a = a) : b = 1
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Compare.lean
@[simp] theorem cmp_iff_eq [LawfulCmpEq α cmp] : cmp a a' = .eq ↔ a = a'
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem fst_apply {s : Set α} (hs : MeasurableSet s) : ρ.fst s = ρ (Prod.fst ⁻¹' s)
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem Antitone.Ioi (hf : Antitone f) : Monotone fun x => Ioi (f x)
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
theorem hasUnitMulPowIrreducibleFactorization :
    HasUnitMulPowIrreducibleFactorization k⟦X⟧
-- Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean
@[simp]
theorem mk_sub_mk [Sub α] {x y : α} (hx : 0 ≤ x) (hy : 0 ≤ y) :
    (⟨x, hx⟩ : { x : α // 0 ≤ x }) - ⟨y, hy⟩ = toNonneg (x - y)
-- Mathlib/Order/WithBot.lean
@[simp, deprecated bot_le "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem none_le {a : WithBot α} : @LE.le (WithBot α) _ none a
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eval_nodal_derivative_eval_node_eq [DecidableEq ι] {i : ι} (hi : i ∈ s) :
    eval (v i) (derivative (nodal s v)) = eval (v i) (nodal (s.erase i) v)
-- Mathlib/Topology/Connected/Basic.lean
theorem isPreconnected_range [TopologicalSpace β] [PreconnectedSpace α] {f : α → β}
    (h : Continuous f) : IsPreconnected (range f)
-- Mathlib/Topology/TietzeExtension.lean
/-- **Tietze extension theorem** for `TietzeExtension` spaces, a version for a closed set. Let
`s` be a closed set in a normal topological space `X`. Let `f` be a continuous function
on `s` with values in a `TietzeExtension` space `Y`. Then there exists a continuous function
`g : C(X, Y)` such that `g.restrict s = f`. -/
theorem ContinuousMap.exists_restrict_eq (f : C(s, Y)) : ∃ (g : C(X, Y)), g.restrict s = f
-- Mathlib/RingTheory/Derivation/Basic.lean
protected theorem map_sub : D (a - b) = D a - D b
-- Mathlib/Data/Nat/Factorization/PrimePow.lean
theorem isPrimePow_iff_minFac_pow_factorization_eq {n : ℕ} (hn : n ≠ 1) :
    IsPrimePow n ↔ n.minFac ^ n.factorization n.minFac = n
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kronecker_ofNat [Semiring α] [DecidableEq n] (A : Matrix l m α) (b : ℕ) [b.AtLeastTwo] :
    A ⊗ₖ (no_index (OfNat.ofNat b) : Matrix n n α) =
      blockDiagonal fun _ => A <• (OfNat.ofNat b : α)
-- Mathlib/GroupTheory/Coset.lean
/-- The natural embedding `H ⧸ (⨅ i, f i).subgroupOf H ↪ Π i, H ⧸ (f i).subgroupOf H`. -/
@[to_additive (attr := simps) "The natural embedding
 `H ⧸ (⨅ i, f i).addSubgroupOf H) ↪ Π i, H ⧸ (f i).addSubgroupOf H`."]
def quotientiInfSubgroupOfEmbedding {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α) :
    H ⧸ (⨅ i, f i).subgroupOf H ↪ ∀ i, H ⧸ (f i).subgroupOf H
-- Mathlib/Analysis/Convex/Cone/Proper.lean
/-- This is a relative version of
`ConvexCone.hyperplane_separation_of_nonempty_of_isClosed_of_nmem`, which we recover by setting
`f` to be the identity map. This is also a geometric interpretation of the Farkas' lemma
stated using proper cones. -/
theorem hyperplane_separation (K : ProperCone ℝ E) {f : E →L[ℝ] F} {b : F} :
    b ∈ K.map f ↔ ∀ y : F, adjoint f y ∈ K.dual → 0 ≤ ⟪y, b⟫_ℝ