ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
/-- If a space of linear maps from `E` to `F` is complete, and `E` is nontrivial, then `F` is
complete. -/
lemma completeSpace_of_completeSpace_continuousLinearMap [CompleteSpace (E →L[𝕜] F)] :
    CompleteSpace F
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
lemma cfcHom_eq_restrict (f : C(S, R)) (halg : UniformEmbedding (algebraMap R S))
    {a : A} (hpa : p a) (hqa : q a) (h : SpectrumRestricts a f) [CompactSpace (spectrum S a)] :
    cfcHom hpa = h.starAlgHom (cfcHom hqa)
-- Mathlib/SetTheory/Cardinal/Finite.lean
theorem card_eq_two_iff : Nat.card α = 2 ↔ ∃ x y : α, x ≠ y ∧ {x, y} = @Set.univ α
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem equiv_comp_equiv_eq_id :
    (equiv i j p).trans (equiv j i p) = RingEquiv.refl L
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma card_truncatedInf_union_add_card_truncatedInf_sups (𝒜 ℬ : Finset (Finset α)) (s : Finset α) :
    (truncatedInf (𝒜 ∪ ℬ) s).card + (truncatedInf (𝒜 ⊻ ℬ) s).card =
      (truncatedInf 𝒜 s).card + (truncatedInf ℬ s).card
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma pairwiseDisjoint_diffFinset (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
    PairwiseDisjoint (hC.diffFinset hs ht : Set (Set α)) id
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem isRightInversion_inv_iff {w t : W} :
    cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t
-- Mathlib/Analysis/Complex/Basic.lean
theorem summable_conj {f : α → ℂ} : (Summable fun x => conj (f x)) ↔ Summable f
-- Mathlib/Data/Int/Cast/Lemmas.lean
theorem eq_intCast' (f : ℤ →+* α) : f = Int.castRingHom α
-- Mathlib/GroupTheory/PGroup.lean
/-- The cardinality of the `center` of a `p`-group is `p ^ k` where `k` is positive. -/
theorem card_center_eq_prime_pow (hn : 0 < n) :
    ∃ k > 0, Nat.card (center G) = p ^ k
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_ker (f : G →* M) {x : G} : x ∈ f.ker ↔ f x = 1
-- Mathlib/GroupTheory/SpecificGroups/Quaternion.lean
/-- If `0 < n`, then `a 1` has order `2 * n`.
-/
@[simp]
theorem orderOf_a_one : orderOf (a 1 : QuaternionGroup n) = 2 * n
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem map_surjective [Nonempty γ] [Nonempty δ] {f : α → γ} {g : β → δ} :
    Surjective (map f g) ↔ Surjective f ∧ Surjective g
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem HasCompactSupport.iteratedFDeriv (hf : HasCompactSupport f) (n : ℕ) :
    HasCompactSupport (iteratedFDeriv 𝕜 n f)
-- Mathlib/Analysis/SumIntegralComparisons.lean
theorem MonotoneOn.integral_le_sum (hf : MonotoneOn f (Icc x₀ (x₀ + a))) :
    (∫ x in x₀..x₀ + a, f x) ≤ ∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ))
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
@[simp]
theorem circulant_zero (α n) [Zero α] [Sub n] : circulant 0 = (0 : Matrix n n α)
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_eq_cases : √x = y ↔ y * y = x ∧ 0 ≤ y ∨ x < 0 ∧ y = 0
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
/-- The **spectral mapping theorem** for the non-unital continuous functional calculus. -/
lemma cfcₙ_map_quasispectrum : σₙ R (cfcₙ f a) = f '' σₙ R a
-- Mathlib/Order/CompactlyGenerated/Basic.lean
/-- See [Theorem 6.6][calugareanu]. -/
theorem complementedLattice_of_sSup_atoms_eq_top (h : sSup { a : α | IsAtom a } = ⊤) :
    ComplementedLattice α
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- Commutativity of an additive subgroup -/
structure _root_.AddSubgroup.IsCommutative (H : AddSubgroup A) : Prop where
  /-- `+` is commutative on `H` -/
  is_comm : Std.Commutative (α := H) (· + ·)
-- Mathlib/Tactic/Ring/RingNF.lean
theorem add_assoc_rev (a b c : R) : a + (b + c) = a + b + c
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem ne_zero_of_coe_le_degree (hdeg : ↑n ≤ p.degree) : p ≠ 0
-- Mathlib/Order/Bounds/Basic.lean
theorem isGreatest_Ioc (h : a < b) : IsGreatest (Ioc a b) b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_baseChange [Algebra F K] [IsScalarTower R F K] [Algebra F L] [IsScalarTower R F L]
    (f : K →ₐ[F] L) (P : W⟮F⟯) : map W f (baseChange W F K P) = baseChange W F L P
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma congr_φH {γ₁ γ₂ : RightHomologyMapData φ h₁ h₂} (eq : γ₁ = γ₂) : γ₁.φH = γ₂.φH
-- Mathlib/Data/Finset/Lattice.lean
/-- Intersection of an indexed family of sets `s : ι → Set α` is equal to the intersection of the
intersections of finite subfamilies. This version assumes `ι : Type*`. See also
`iInter_eq_iInter_finset'` for a version that works for `ι : Sort*`. -/
theorem iInter_eq_iInter_finset (s : ι → Set α) : ⋂ i, s i = ⋂ t : Finset ι, ⋂ i ∈ t, s i
-- Mathlib/Analysis/Convex/Segment.lean
theorem openSegment_subset_iff :
    openSegment 𝕜 x y ⊆ s ↔ ∀ a b : 𝕜, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- If a continuous function lies strictly above `a` on a compact set,
  it has a lower bound strictly above `a`. -/
theorem IsCompact.exists_forall_le' [ClosedIicTopology α] [NoMaxOrder α] {f : β → α}
    {s : Set β} (hs : IsCompact s) (hf : ContinuousOn f s) {a : α} (hf' : ∀ b ∈ s, a < f b) :
    ∃ a', a < a' ∧ ∀ b ∈ s, a' ≤ f b
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousAt.finset_sup (hs : ∀ i ∈ s, ContinuousAt (f i) x) :
    ContinuousAt (s.sup f) x
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem mk_dvd_mk {a b : α} : Associates.mk a ∣ Associates.mk b ↔ a ∣ b
-- Mathlib/Data/List/Rotate.lean
theorem rotate_eq_iff {l l' : List α} {n : ℕ} :
    l.rotate n = l' ↔ l = l'.rotate (l'.length - n % l'.length)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem biprod_isoCoprod_hom {X Y : C} [HasBinaryBiproduct X Y] :
    (biprod.isoCoprod X Y).hom = biprod.desc coprod.inl coprod.inr
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- Any shift of a Cauchy sequence is also a Cauchy sequence. -/
theorem cauchySeq_shift {u : ℕ → α} (k : ℕ) : CauchySeq (fun n ↦ u (n + k)) ↔ CauchySeq u
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem mapRange_apply {f : M → N} {hf : f 0 = 0} {g : α →₀ M} {a : α} :
    mapRange f hf g a = f (g a)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem ofNat_natAbs_of_nonpos {a : Int} (H : a ≤ 0) : (natAbs a : Int) = -a
-- Mathlib/Computability/Primrec.lean
theorem fin_app {n} : Primrec₂ (@id (Fin n → σ))
-- Mathlib/Algebra/Homology/ExactSequence.lean
/-- `F : ComposableArrows C n` is exact if it is a complex and that all short
complexes consisting of two consecutive arrows are exact. -/
structure Exact extends S.IsComplex : Prop where
  exact (i : ℕ) (hi : i + 2 ≤ n := by omega) : (S.sc toIsComplex i).Exact
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[to_additive]
theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
    center G = ⨅ g ∈ S, centralizer (zpowers g)
-- Mathlib/Order/SupIndep.lean
/-- Composing an independent indexed family with an injective function on the index results in
another indepedendent indexed family. -/
theorem Independent.comp {ι ι' : Sort*} {t : ι → α} {f : ι' → ι} (ht : Independent t)
    (hf : Injective f) : Independent (t ∘ f)
-- Mathlib/AlgebraicGeometry/Morphisms/Preimmersion.lean
theorem of_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [IsPreimmersion g]
    [IsPreimmersion (f ≫ g)] : IsPreimmersion f
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Equality case of the Rearrangement Inequality**: Pointwise scalar multiplication of `f` and
`g`, which monovary together, is unchanged by a permutation if and only if `f` and `g ∘ σ` monovary
together. Stated by permuting the entries of `g`. -/
theorem MonovaryOn.sum_smul_comp_perm_eq_sum_smul_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/RepresentationTheory/Action/Limits.lean
@[simp]
theorem add_hom {X Y : Action V G} (f g : X ⟶ Y) : (f + g).hom = f.hom + g.hom
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiable_const : MDifferentiable I I' fun _ : M => c
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem map_ne_zero_iff {x : M} : e x ≠ 0 ↔ x ≠ 0
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem mulVec_surjective_of_invertible (A : Matrix m m R) [Invertible A] :
    Function.Surjective A.mulVec
-- Mathlib/RingTheory/Bialgebra/Basic.lean
/-- `counitAlgHom R A` is the counit of the `R`-bialgebra `A`, as an `R`-algebra map. -/
@[simps!]
def counitAlgHom : A →ₐ[R] R
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v)
-- Mathlib/NumberTheory/RamificationInertia.lean
/-- The **fundamental identity** of ramification index `e` and inertia degree `f`:
for `P` ranging over the primes lying over `p`, `∑ P, e P * f P = [Frac(S) : Frac(R)]`;
here `S` is a finite `R`-module (and thus `Frac(S) : Frac(R)` is a finite extension) and `p`
is maximal.
-/
theorem sum_ramification_inertia (K L : Type*) [Field K] [Field L] [IsDedekindDomain R]
    [Algebra R K] [IsFractionRing R K] [Algebra S L] [IsFractionRing S L] [Algebra K L]
    [Algebra R L] [IsScalarTower R S L] [IsScalarTower R K L] [IsNoetherian R S]
    [IsIntegralClosure S R L] [p.IsMaximal] (hp0 : p ≠ ⊥) :
    (∑ P ∈ (factors (map (algebraMap R S) p)).toFinset,
        ramificationIdx (algebraMap R S) p P * inertiaDeg (algebraMap R S) p P) =
      finrank K L
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- A `c : Bicone F` is:
* an object `c.pt` and
* morphisms `π j : pt ⟶ F j` and `ι j : F j ⟶ pt` for each `j`,
* such that `ι j ≫ π j'` is the identity when `j = j'` and zero otherwise.
-/
-- @[nolint has_nonempty_instance] Porting note (#5171): removed
structure Bicone (F : J → C) where
  pt : C
  π : ∀ j, pt ⟶ F j
  ι : ∀ j, F j ⟶ pt
  ι_π : ∀ j j', ι j ≫ π j' =
    if h : j = j' then eqToHom (congrArg F h) else 0 := by aesop
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isBigOWith_zero_right_iff : (IsBigOWith c l f'' fun _x => (0 : F')) ↔ f'' =ᶠ[l] 0
-- Mathlib/Data/Matrix/Block.lean
/-- `Matrix.blockDiag'` as an `AddMonoidHom`. -/
@[simps]
def blockDiag'AddMonoidHom [AddZeroClass α] :
    Matrix (Σi, m' i) (Σi, n' i) α →+ ∀ i, Matrix (m' i) (n' i) α
-- Mathlib/Algebra/Polynomial/Roots.lean
/-- A monic polynomial `p` that has as many roots as its degree
can be written `p = ∏(X - a)`, for `a` in `p.roots`. -/
theorem prod_multiset_X_sub_C_of_monic_of_roots_card_eq (hp : p.Monic)
    (hroots : Multiset.card p.roots = p.natDegree) : (p.roots.map fun a => X - C a).prod = p
-- Mathlib/Data/Rel.lean
@[simp] lemma graph_def (f : α → β) (x y) : f.graph x y ↔ (f x = y)
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_right_differentiableWithinAt_iff {f : F → G} {s : Set F} {x : E} :
    DifferentiableWithinAt 𝕜 (f ∘ iso) (iso ⁻¹' s) x ↔ DifferentiableWithinAt 𝕜 f s (iso x)
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
lemma toTriangle_is3Clique (hx : x ∈ t) : (graph t).IsNClique 3 (toTriangle x)
-- Mathlib/Analysis/Normed/Operator/Banach.lean
theorem closure_preimage (hsurj : Surjective f) (s : Set F) : closure (f ⁻¹' s) = f ⁻¹' closure s
-- Mathlib/Probability/Process/Filtration.lean
theorem stronglyMeasurable_limitProcess : StronglyMeasurable[⨆ n, ℱ n] (limitProcess f ℱ μ)
-- Mathlib/Order/SupClosed.lean
@[simp] lemma supClosed_supClosure : SupClosed (supClosure s)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem eq_succ_of_ne_zero {n : Nat} {i : Fin (n + 1)} (hi : i ≠ 0) : ∃ j : Fin n, i = j.succ
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropAt_iff {P : (H → H') → Set H → H → Prop} {f : M → M'} {x : M} :
    LiftPropAt P f x ↔
      ContinuousAt f x ∧ P (chartAt H' (f x) ∘ f ∘ (chartAt H x).symm) univ (chartAt H x x)
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem J_inv : (J l R)⁻¹ = -J l R
-- Mathlib/Topology/Spectral/Hom.lean
@[ext]
theorem ext {f g : SpectralMap α β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[continuity]
theorem continuous_coe : Continuous ((↑) : ℝ → Angle)
-- Mathlib/Topology/Bases.lean
/-- Any open set is the union of the basis sets contained in it. -/
theorem IsTopologicalBasis.open_eq_sUnion' {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
    (ou : IsOpen u) : u = ⋃₀ { s ∈ B | s ⊆ u }
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_eq_norm_app_of_nonzero {f : PadicSeq p} (hf : ¬f ≈ 0) :
    ∃ k, f.norm = padicNorm p k ∧ k ≠ 0
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem _root_.Commute.exp_left [T2Space 𝔸] {x y : 𝔸} (h : Commute x y) : Commute (exp 𝕂 x) y
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@[simp]
theorem contractRight_algebraMap (r : R) : algebraMap R (CliffordAlgebra Q) r⌊d = 0
-- Mathlib/Combinatorics/Hall/Finite.lean
/-- First case of the inductive step: assuming that
`∀ (s : Finset ι), s.Nonempty → s ≠ univ → s.card < (s.biUnion t).card`
and that the statement of **Hall's Marriage Theorem** is true for all
`ι'` of cardinality ≤ `n`, then it is true for `ι` of cardinality `n + 1`.
-/
theorem hall_hard_inductive_step_A {n : ℕ} (hn : Fintype.card ι = n + 1)
    (ht : ∀ s : Finset ι, s.card ≤ (s.biUnion t).card)
    (ih :
      ∀ {ι' : Type u} [Fintype ι'] (t' : ι' → Finset α),
        Fintype.card ι' ≤ n →
          (∀ s' : Finset ι', s'.card ≤ (s'.biUnion t').card) →
            ∃ f : ι' → α, Function.Injective f ∧ ∀ x, f x ∈ t' x)
    (ha : ∀ s : Finset ι, s.Nonempty → s ≠ univ → s.card < (s.biUnion t).card) :
    ∃ f : ι → α, Function.Injective f ∧ ∀ x, f x ∈ t x
-- Mathlib/Order/Basic.lean
@[simp]
theorem update_lt_self_iff : update x i a < x ↔ a < x i
-- Mathlib/RepresentationTheory/Rep.lean
@[simp] theorem ihom_coev_app_hom (A B : Rep k G) :
    Action.Hom.hom ((ihom.coev A).app B) = (TensorProduct.mk k _ _).flip
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem lift_nhds_right {x : α} {g : Set α → Filter β} (hg : Monotone g) :
    (𝓝 x).lift g = (𝓤 α).lift fun s : Set (α × α) => g { y | (y, x) ∈ s }
-- Mathlib/Data/Sum/Interval.lean
theorem sumLift₂_eq_empty :
    sumLift₂ f g a b = ∅ ↔
      (∀ a₁ b₁, a = inl a₁ → b = inl b₁ → f a₁ b₁ = ∅) ∧
        ∀ a₂ b₂, a = inr a₂ → b = inr b₂ → g a₂ b₂ = ∅
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
/-- Tensoring an exact pair on the right gives an exact pair -/
theorem rTensor_exact : Exact (rTensor Q f) (rTensor Q g)
-- Mathlib/Analysis/Convex/EGauge.lean
lemma le_egauge_smul_right (c : 𝕜) (s : Set E) (x : E) :
    ‖c‖₊ * egauge 𝕜 s x ≤ egauge 𝕜 s (c • x)
-- Mathlib/Analysis/Convex/Gauge.lean
theorem Seminorm.gaugeSeminorm_ball (p : Seminorm ℝ E) :
    gaugeSeminorm (p.balanced_ball_zero 1) (p.convex_ball 0 1) (p.absorbent_ball_zero zero_lt_one) =
      p
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem support_binomial' (k m : ℕ) (x y : R) :
    Polynomial.support (C x * X ^ k + C y * X ^ m) ⊆ {k, m}
-- Mathlib/Order/Sublattice.lean
@[simp] lemma map_id : L.map (LatticeHom.id α) = L
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem mass_nonzero_iff (μ : FiniteMeasure Ω) : μ.mass ≠ 0 ↔ μ ≠ 0
-- Mathlib/RingTheory/PiTensorProduct.lean
@[simp]
theorem constantBaseRingEquiv_tprod (x : ι → R) :
    constantBaseRingEquiv ι R (tprod R x) = ∏ i, x i
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem arccos_eq_arctan {x : ℝ} (h : 0 < x) : arccos x = arctan (√(1 - x ^ 2) / x)
-- Mathlib/Probability/Independence/Basic.lean
lemma iIndepSets.meas_iInter [Fintype ι] (h : iIndepSets π μ) (hs : ∀ i, s i ∈ π i) :
    μ (⋂ i, s i) = ∏ i, μ (s i)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_toHomeomorph : ⇑e.toHomeomorph = e
-- Mathlib/Data/NNReal/Basic.lean
theorem iSup_div (f : ι → ℝ≥0) (a : ℝ≥0) : (⨆ i, f i) / a = ⨆ i, f i / a
-- Mathlib/Topology/SeparatedMap.lean
theorem isLocallyInjective_iff_isOpen_diagonal {f : X → Y} :
    IsLocallyInjective f ↔ IsOpen f.pullbackDiagonal
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma level_one' (hn : n = 1) : χ = 1
-- Mathlib/Analysis/LocallyConvex/Basic.lean
/-- The interior of a balanced set is balanced if it contains the origin. -/
protected theorem Balanced.interior (hA : Balanced 𝕜 A) (h : (0 : E) ∈ interior A) :
    Balanced 𝕜 (interior A)
-- Mathlib/LinearAlgebra/Span.lean
theorem span_preimage_le (f : F) (s : Set M₂) :
    span R (f ⁻¹' s) ≤ (span R₂ s).comap f
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma φ_four :
    W.φ 4 = C X * C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 - C W.preΨ₄ * W.ψ₂ ^ 4 * C W.Ψ₃ + C W.Ψ₃ ^ 4
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem eq_ones_iff {c : Composition n} : c = ones n ↔ ∀ i ∈ c.blocks, i = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- `HasImages` asserts that every morphism has an image. -/
class HasImages : Prop where
  has_image : ∀ {X Y : C} (f : X ⟶ Y), HasImage f
-- Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean
theorem nnnorm_def (x : tsze R M) : ‖x‖₊ = ‖fst x‖₊ + ‖snd x‖₊
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp, norm_cast]
theorem coe_pow (I : FractionalIdeal S P) (n : ℕ) : ↑(I ^ n) = (I : Submodule R P) ^ n
-- Mathlib/Data/PNat/Defs.lean
@[simp]
theorem not_lt_one (n : ℕ+) : ¬n < 1
-- Mathlib/Algebra/Module/Bimodule.lean
/-- Forgetting the `B` action, a `Submodule` over `A ⊗[R] B` is just a `Submodule` over `A`. -/
@[simps]
def toSubmodule (p : Submodule (A ⊗[R] B) M) : Submodule A M
-- Mathlib/Combinatorics/Quiver/SingleObj.lean
@[simp]
theorem pathEquivList_cons (p : Path (star α) (star α)) (a : star α ⟶ star α) :
    pathEquivList (Path.cons p a) = a :: pathToList p
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma ofReal_natCast (n : ℕ) : ofReal' n = n
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
@[simp]
theorem edgeFinset_bot : (⊥ : SimpleGraph V).edgeFinset = ∅
-- Mathlib/Data/String/Lemmas.lean
lemma congr_append : ∀ (a b : String), a ++ b = String.mk (a.data ++ b.data)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem smoothAt_snd {p : M × N} : SmoothAt (I.prod J) J Prod.snd p
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem eLpNorm_condexpL2_le (hm : m ≤ m0) (f : α →₂[μ] E) :
    eLpNorm (F := E) (condexpL2 E 𝕜 hm f) 2 μ ≤ eLpNorm f 2 μ
-- Mathlib/FieldTheory/Minpoly/Basic.lean
/-- An element is a root of its minimal polynomial. -/
@[simp]
theorem aeval : aeval x (minpoly A x) = 0
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem cthickening_max_zero (δ : ℝ) (E : Set α) : cthickening (max 0 δ) E = cthickening δ E
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem zmodEquivZPowers_apply_coe_int (i : ℤ) :
    h.zmodEquivZPowers i = Additive.ofMul (⟨ζ ^ i, i, rfl⟩ : Subgroup.zpowers ζ)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_ball_self (h : 0 < ε) : x ∈ ball x ε
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasStrictDerivAt.comp_of_eq
    (hh₂ : HasStrictDerivAt h₂ h₂' y) (hh : HasStrictDerivAt h h' x) (hy : y = h x) :
    HasStrictDerivAt (h₂ ∘ h) (h₂' * h') x
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- A Cauchy sequence in a complete space converges -/
theorem cauchySeq_tendsto_of_complete [Preorder β] [CompleteSpace α] {u : β → α}
    (H : CauchySeq u) : ∃ x, Tendsto u atTop (𝓝 x)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- Two sets are at zero Hausdorff distance if and only if they have the same closures. -/
theorem hausdorffDist_zero_iff_closure_eq_closure (fin : hausdorffEdist s t ≠ ⊤) :
    hausdorffDist s t = 0 ↔ closure s = closure t
-- Mathlib/Algebra/Quaternion.lean
@[simp] nonrec theorem sub_im : (a - b).im = a.im - b.im
-- Mathlib/Computability/TuringMachine.lean
theorem tr_reaches_rev {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
    (aa : tr a₁ a₂) {b₂} (ab : Reaches f₂ a₂ b₂) :
    ∃ c₁ c₂, Reaches f₂ b₂ c₂ ∧ tr c₁ c₂ ∧ Reaches f₁ a₁ c₁
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem associator_inv_hom (X Y Z : Mon_ C) : (α_ X Y Z).inv.hom = (α_ X.X Y.X Z.X).inv
-- Mathlib/GroupTheory/Sylow.lean
/-- If `H` is a subgroup of `G` of cardinality `p ^ n`,
  then `H` is contained in a subgroup of cardinality `p ^ (n + 1)`
  if `p ^ (n + 1)` divides the cardinality of `G` -/
theorem exists_subgroup_card_pow_succ [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime]
    (hdvd : p ^ (n + 1) ∣ Nat.card G) {H : Subgroup G} (hH : Nat.card H = p ^ n) :
    ∃ K : Subgroup G, Nat.card K = p ^ (n + 1) ∧ H ≤ K
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[simp]
theorem valuation_zero : valuation (0 : ℚ_[p]) = 0
-- Mathlib/Order/Heyting/Regular.lean
/-- A decidable proposition is intuitionistically Heyting-regular. -/
-- Porting note: removed @[nolint decidable_classical]
theorem isRegular_of_decidable (p : Prop) [Decidable p] : IsRegular p
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp]
theorem coe_unitGroupMulEquiv_apply (a : A.unitGroup) :
    ((A.unitGroupMulEquiv a : A) : K) = ((a : Kˣ) : K)
-- Mathlib/Order/Sublattice.lean
@[simp] lemma comap_top (f : LatticeHom α β) : (⊤ : Sublattice β).comap f = ⊤
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.base_of_basis_superset (hB : M.Base B) (hBX : B ⊆ X) (hIX : M.Basis I X) :
    M.Base I
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
protected theorem Decidable.not_forall {p : α → Prop} [Decidable (∃ x, ¬p x)]
    [∀ x, Decidable (p x)] : (¬∀ x, p x) ↔ ∃ x, ¬p x
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_addMonoidHom_id : (NonUnitalRingHom.id α : α →+ α) = AddMonoidHom.id α
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem coe_eq_toEquiv (h : α ≃ᵢ β) (a : α) : h a = h.toEquiv a
-- Mathlib/Data/Set/Basic.lean
theorem union_congr_right (hs : s ⊆ t ∪ u) (ht : t ⊆ s ∪ u) : s ∪ u = t ∪ u
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem IsNClique.mono (h : G ≤ H) : G.IsNClique n s → H.IsNClique n s
-- Mathlib/CategoryTheory/Limits/IsConnected.lean
/-- The domain of a final functor is connected if and only if its codomain is connected. -/
theorem isConnected_iff_of_final (F : C ⥤ D) [CategoryTheory.Functor.Final F] :
    IsConnected C ↔ IsConnected D
-- Mathlib/Control/Traversable/Lemmas.lean
theorem map_traverse (x : t α) : map f <$> traverse g x = traverse (map f ∘ g) x
-- Mathlib/Algebra/GroupWithZero/Action/Defs.lean
/-- Each element of the monoid defines a monoid homomorphism. -/
@[simps]
def MulDistribMulAction.toMonoidEnd :
    M →* Monoid.End A
-- Mathlib/Analysis/Convex/Strong.lean
lemma UniformConvexOn.add (hf : UniformConvexOn s φ f) (hg : UniformConvexOn s ψ g) :
    UniformConvexOn s (φ + ψ) (f + g)
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem StableUnderBaseChange.op {P : MorphismProperty C} (hP : StableUnderBaseChange P) :
    StableUnderCobaseChange P.op
-- Mathlib/Algebra/Polynomial/Div.lean
theorem map_dvd_map [Ring S] (f : R →+* S) (hf : Function.Injective f) {x y : R[X]}
    (hx : x.Monic) : x.map f ∣ y.map f ↔ x ∣ y
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma ball_prod_same (x : α) (y : β) (r : ℝ) : ball x r ×ˢ ball y r = ball (x, y) r
-- Mathlib/RingTheory/TensorProduct/Basic.lean
protected theorem mul_assoc (x y z : A ⊗[R] B) : mul (mul x y) z = mul x (mul y z)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean
lemma CstarRing.nnnorm_mem_spectrum_of_nonneg [Nontrivial A] {a : A} (ha : 0 ≤ a := by cfc_tac) :
    ‖a‖₊ ∈ spectrum ℝ≥0 a
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
/-- The function `x ^ s * exp (-b * x)` tends to `0` at `+∞`, for any real `s` and `b > 0`. -/
theorem tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero (s : ℝ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun x : ℝ => x ^ s * exp (-b * x)) atTop (𝓝 0)
-- Mathlib/Order/Bounds/Basic.lean
theorem isGLB_le_isLUB (ha : IsGLB s a) (hb : IsLUB s b) (hs : s.Nonempty) : a ≤ b
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
theorem coev_app_comp_pre_app (f : B ⟶ A) [Exponentiable B] :
    (exp.coev A).app X ≫ (pre f).app (A ⨯ X) =
      (exp.coev B).app X ≫ (exp B).map (Limits.prod.map f (𝟙 _))
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem nndist_le (hf : LipschitzWith K f) (x y : α) : nndist (f x) (f y) ≤ K * nndist x y