ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Expand.lean
/-- If `R` is of characteristic `p` and `¬p ∣ n`, then
`cyclotomic (n * p) R = (cyclotomic n R) ^ (p - 1)`. -/
theorem cyclotomic_mul_prime_eq_pow_of_not_dvd (R : Type*) {p n : ℕ} [hp : Fact (Nat.Prime p)]
    [Ring R] [CharP R p] (hn : ¬p ∣ n) : cyclotomic (n * p) R = cyclotomic n R ^ (p - 1)
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
lemma integrable_pow_mul_iteratedFDeriv (f : 𝓢(D, V))
    (k n : ℕ) : Integrable (fun x ↦ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖) μ
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem signAux3_mul_and_swap [Finite α] (f g : Perm α) (s : Multiset α) (hs : ∀ x, x ∈ s) :
    signAux3 (f * g) hs = signAux3 f hs * signAux3 g hs ∧
      Pairwise fun x y => signAux3 (swap x y) hs = -1
-- Mathlib/Topology/Constructions.lean
@[simp]
theorem continuous_sum_map {f : X → Y} {g : Z → W} :
    Continuous (Sum.map f g) ↔ Continuous f ∧ Continuous g
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycleOn.range_pow (hs : s.Finite) (h : f.IsCycleOn s) (ha : a ∈ s) :
    Set.range (fun n => (f ^ n) a : ℕ → α) = s
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem hasSum_div_const_iff (h : a₂ ≠ 0) : HasSum (fun i ↦ f i / a₂) (a₁ / a₂) ↔ HasSum f a₁
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
protected theorem ContinuousLinearMap.summable {f : ι → M} (φ : M →SL[σ] M₂) (hf : Summable f) :
    Summable fun b : ι ↦ φ (f b)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem IsPath.nil {u : V} : (nil : G.Walk u u).IsPath
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
@[simp] theorem forgetMonoidal_toFunctor : (forgetMonoidal C).toFunctor = forget C
-- Mathlib/Data/Prod/Basic.lean
@[refl]
theorem Lex.refl_right (r : α → α → Prop) (s : β → β → Prop) [IsRefl β s] : ∀ x, Prod.Lex r s x x
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem replace_eq_replaceTR : @List.replace = @replaceTR
-- Mathlib/Data/Rat/Star.lean
@[simp] lemma addSubmonoid_closure_range_mul_self : closure (range fun x : ℚ≥0 ↦ x * x) = ⊤
-- Mathlib/SetTheory/Cardinal/ToNat.lean
@[simp] lemma toNat_pos : 0 < toNat c ↔ c ≠ 0 ∧ c < ℵ₀
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive (attr := simp, nolint simpNF)]
theorem tprod_singleton (b : β) (f : β → α) : ∏' x : ({b} : Set β), f x = f b
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem hasPullback_of_cover : HasPullback f g
-- Mathlib/CategoryTheory/Monoidal/Types/Symmetric.lean
@[simp]
theorem braiding_hom_apply {X Y : Type u} {x : X} {y : Y} :
    ((β_ X Y).hom : X ⊗ Y → Y ⊗ X) (x, y) = (y, x)
-- Mathlib/Analysis/Convex/Slope.lean
theorem ConvexOn.secant_mono_aux1 (hf : ConvexOn 𝕜 s f) {x y z : 𝕜} (hx : x ∈ s) (hz : z ∈ s)
    (hxy : x < y) (hyz : y < z) : (z - x) * f y ≤ (z - y) * f x + (y - x) * f z
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsCoprime.pow_left_iff (hm : 0 < m) : IsCoprime (x ^ m) y ↔ IsCoprime x y
-- Mathlib/Order/Filter/Bases.lean
lemma HasAntitoneBasis.iInf_principal {ι : Type*} [Preorder ι] [Nonempty ι] [IsDirected ι (· ≤ ·)]
    {s : ι → Set α} (hs : Antitone s) : (⨅ i, 𝓟 (s i)).HasAntitoneBasis s
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem add_eq_right_iff_mul_omega_le {a b : Ordinal} : a + b = b ↔ a * omega ≤ b
-- Mathlib/CategoryTheory/Localization/Resolution.lean
lemma essSurj_of_hasLeftResolutions [Φ.HasLeftResolutions] : (Φ.functor ⋙ L₂).EssSurj
-- Mathlib/Data/Finset/Prod.lean
@[simp]
theorem disjoint_diag_offDiag : Disjoint s.diag s.offDiag
-- Mathlib/Data/Finsupp/Basic.lean
theorem comapDomain_smul [AddMonoid M] [Monoid R] [DistribMulAction R M] {f : α → β} (r : R)
    (v : β →₀ M) (hfv : Set.InjOn f (f ⁻¹' ↑v.support))
    (hfrv : Set.InjOn f (f ⁻¹' ↑(r • v).support) :=
      hfv.mono <| Set.preimage_mono <| Finset.coe_subset.mpr support_smul) :
    comapDomain f (r • v) hfrv = r • comapDomain f v hfv
-- Mathlib/Order/Filter/Interval.lean
protected theorem Tendsto.Ioo {l₁ l₂ : Filter α} [TendstoIxxClass Ioo l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Ioo (u₁ x) (u₂ x)) lb l₂.smallSets
-- Mathlib/Data/Set/Basic.lean
lemma disjoint_sdiff_left : Disjoint (t \ s) s
-- Mathlib/Algebra/Homology/SingleHomology.lean
@[reassoc (attr := simp)]
lemma homologyι_singleObjOpcyclesSelfIso_inv :
    ((single C c j).obj A).homologyι j ≫ (singleObjOpcyclesSelfIso _ _ _).inv =
      (singleObjHomologySelfIso _ _ _).hom
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_subset_iff' {f : α → M} {s : Set α} :
    mulSupport f ⊆ s ↔ ∀ x ∉ s, f x = 1
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem preimage_smul_closedBall (c : G) (x : X) (r : ℝ) :
    (c • ·) ⁻¹' closedBall x r = closedBall (c⁻¹ • x) r
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem as_ideal_le_as_ideal (x y : ProjectiveSpectrum 𝒜) :
    x.asHomogeneousIdeal ≤ y.asHomogeneousIdeal ↔ x ≤ y
-- Mathlib/Geometry/Euclidean/Triangle.lean
/-- The sum of the angles of a possibly degenerate triangle (where the
two given sides are nonzero), vector angle form. -/
theorem angle_add_angle_sub_add_angle_sub_eq_pi {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    angle x y + angle x (x - y) + angle y (y - x) = π
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem powerset_empty : 𝒫(∅ : Set α) = {∅}
-- Mathlib/Topology/UnitInterval.lean
theorem strictAnti_symm : StrictAnti σ
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_sup {a b : ℝ≥0∞} : a ≠ ∞ → b ≠ ∞ → (a ⊔ b).toReal = a.toReal ⊔ b.toReal
-- Mathlib/CategoryTheory/Comma/Over.lean
@[reassoc (attr := simp)]
theorem w {A B : Under X} (f : A ⟶ B) : A.hom ≫ f.right = B.hom
-- Mathlib/RingTheory/Coalgebra/Basic.lean
@[simp] theorem counit_comp_inl : counit ∘ₗ inl R A B = counit
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem image_uIcc_eq_Icc (h : ContinuousOn f [[a, b]]) :
    f '' [[a, b]] = Icc (sInf (f '' [[a, b]])) (sSup (f '' [[a, b]]))
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- Given a square from an isomorphism `i` to an arrow `p`, express the target part of `sq`
in terms of the inverse of `i`. -/
theorem square_from_iso_invert {X Y : T} (i : X ≅ Y) (p : Arrow T) (sq : Arrow.mk i.hom ⟶ p) :
    i.inv ≫ sq.left ≫ p.hom = sq.right
-- Mathlib/LinearAlgebra/AffineSpace/Ordered.lean
theorem lineMap_mono_right (hb : b ≤ b') (hr : 0 ≤ r) : lineMap a b r ≤ lineMap a b' r
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
@[simp]
lemma val_mul (x y : PreQuasiregular R) : (x * y).val = y.val + x.val + x.val * y.val
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem swap_le_swap_iff [LE α] [LE β] {a b : α ⊕ β} : a.swap ≤ b.swap ↔ a ≤ b
-- Mathlib/Data/List/Nodup.lean
protected theorem Nodup.map {f : α → β} (hf : Injective f) : Nodup l → Nodup (map f l)
-- Mathlib/Order/Atoms.lean
/-- A lattice is coatomic iff every element other than `⊤` has a coatom above it. -/
@[mk_iff]
class IsCoatomic [OrderTop α] : Prop where
  /-- Every element other than `⊤` has an atom above it. -/
  eq_top_or_exists_le_coatom : ∀ b : α, b = ⊤ ∨ ∃ a : α, IsCoatom a ∧ b ≤ a
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem setOf_mem {α} {s : Finset α} : { a | a ∈ s } = s
-- Mathlib/RingTheory/HahnSeries/Summable.lean
@[simp]
theorem coe_zero : ((0 : SummableFamily Γ R α) : α → HahnSeries Γ R) = 0
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem coe_toNatLinearEquiv : ⇑e.toNatLinearEquiv = e
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem recOn_cons (a : α) (m : Multiset α) :
    (a ::ₘ m).recOn C_0 C_cons C_cons_heq = C_cons a m (m.recOn C_0 C_cons C_cons_heq)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiff.continuous_fderiv (h : ContDiff 𝕜 n f) (hn : 1 ≤ n) :
    Continuous fun x => fderiv 𝕜 f x
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem whiskerLeft_id_bimod {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    whiskerLeft M (𝟙 N) = 𝟙 (M.tensorBimod N)
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- The range of a proper map is closed. -/
lemma IsProperMap.isClosed_range (hf : IsProperMap f) : IsClosed (range f)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_div_pow_anti (a1 : 1 ≤ a) : Antitone fun n : ℕ => 1 / a ^ n
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem curryLeft_zero {n : ℕ} : curryLeft (0 : M'' [⋀^Fin n.succ]→ₗ[R'] N'') = 0
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem preimage_closedBall (h : α ≃ᵢ β) (x : β) (r : ℝ) :
    h ⁻¹' Metric.closedBall x r = Metric.closedBall (h.symm x) r
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp, norm_cast]
theorem re_coe (z : 𝔻) : (z : ℂ).re = z.re
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoUniformly.tendstoUniformlyOnFilter (h : TendstoUniformly F f p) :
    TendstoUniformlyOnFilter F f p ⊤
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma ψ_even (m : ℕ) : W.ψ (2 * (m + 3)) * W.ψ₂ =
    W.ψ (m + 2) ^ 2 * W.ψ (m + 3) * W.ψ (m + 5) - W.ψ (m + 1) * W.ψ (m + 3) * W.ψ (m + 4) ^ 2
-- Mathlib/Data/Nat/Defs.lean
/-- `dvd` is injective in the left argument -/
lemma dvd_left_injective : Function.Injective ((· ∣ ·) : ℕ → ℕ → Prop)
-- Mathlib/Geometry/RingedSpace/Stalks.lean
@[simp]
theorem id (X : PresheafedSpace.{_, _, v} C) (x : X) :
    (𝟙 X : X ⟶ X).stalkMap x = 𝟙 (X.presheaf.stalk x)
-- Mathlib/Order/RelIso/Basic.lean
/-- A relation is well founded iff its lift to a quotient is. -/
@[simp]
theorem wellFounded_lift₂_iff [Setoid α] {r : α → α → Prop}
    {H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂} :
    WellFounded (Quotient.lift₂ r H) ↔ WellFounded r
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem le_trim (hm : m ≤ m0) : μ s ≤ μ.trim hm s
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem target_inter_inv_preimage_preimage (s : Set β) :
    e.target ∩ e.symm ⁻¹' (e ⁻¹' s) = e.target ∩ s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_of_sub_pos (h : 0 < n - m) : m < n
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem condexpIndSMul_add (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x y : G) :
    condexpIndSMul hm hs hμs (x + y) = condexpIndSMul hm hs hμs x + condexpIndSMul hm hs hμs y
-- Mathlib/Topology/Instances/Real.lean
theorem Real.totallyBounded_ball (x ε : ℝ) : TotallyBounded (ball x ε)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[norm_cast]
theorem WithTop.coe_iSup [SupSet α] (f : ι → α) (h : BddAbove (Set.range f)) :
    ↑(⨆ i, f i) = (⨆ i, f i : WithTop α)
-- Mathlib/GroupTheory/CosetCover.lean
theorem Subspace.biUnion_ne_univ_of_ne_top (hs : ∀ p ∈ s, p ≠ ⊤) :
    ⋃ p ∈ s, (p : Set E) ≠ Set.univ
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem le_sup_lintegral (f g : α →ₛ ℝ≥0∞) : f.lintegral μ ⊔ g.lintegral μ ≤ (f ⊔ g).lintegral μ
-- Mathlib/Data/Fintype/Pi.lean
@[simp]
theorem Fintype.piFinset_univ {α : Type*} {β : α → Type*} [DecidableEq α] [Fintype α]
    [∀ a, Fintype (β a)] :
    (Fintype.piFinset fun a : α => (Finset.univ : Finset (β a))) =
      (Finset.univ : Finset (∀ a, β a))
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_mono_right (ht : t₁ ⊆ t₂) : convexJoin 𝕜 s t₁ ⊆ convexJoin 𝕜 s t₂
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem preimage_mul_left_ball [IsometricSMul G G] (a b : G) (r : ℝ≥0∞) :
    (a * ·) ⁻¹' ball b r = ball (a⁻¹ * b) r
-- Mathlib/Computability/TuringMachine.lean
theorem tr_respects : Respects (TM0.step M) (TM1.step (tr M)) fun a b ↦ trCfg M a = b
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
@[simp]
lemma binaryProductIso_inv_comp_snd :
    (binaryProductIso F G).inv ≫ Limits.prod.snd = prod.snd
-- Mathlib/Order/Max.lean
theorem IsMax.mono (ha : IsMax a) (h : a ≤ b) : IsMax b
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- Turn a colimit for `F : Jᵒᵖ ⥤ C` into a limit for `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def isLimitConeRightOpOfCocone (F : Jᵒᵖ ⥤ C) {c : Cocone F} (hc : IsColimit c) :
    IsLimit (coneRightOpOfCocone c)
-- Mathlib/Topology/Inseparable.lean
@[simp]
theorem specializes_pi {f g : ∀ i, π i} : f ⤳ g ↔ ∀ i, f i ⤳ g i
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem map_comap_eq_self_of_surjective
    {f : R →+* S} (hf : Function.Surjective f) (t : Subsemiring S) : (t.comap f).map f = t
-- Mathlib/Topology/Order.lean
@[simp]
theorem induced_inf : (t₁ ⊓ t₂).induced g = t₁.induced g ⊓ t₂.induced g
-- Mathlib/Topology/Algebra/Ring/Ideal.lean
theorem QuotientRing.isOpenMap_coe : IsOpenMap (mk N)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_lt_of_sub_lt {a b c : Int} (h : a - b < c) : a - c < b
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
/--
A class describing the property of reflecting effective epimorphisms.
-/
class ReflectsEffectiveEpis (F : C ⥤ D) : Prop where
  /--
  A functor reflects effective epimorphisms if morphisms that are mapped to epimorphisms are
  themselves effective epimorphisms.
  -/
  reflects : ∀ {X Y : C} (f : X ⟶ Y), EffectiveEpi (F.map f) → EffectiveEpi f
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- The product of two `s`-factored numbers is again `s`-factored. -/
lemma mul_mem_factoredNumbers {s : Finset ℕ} {m n : ℕ} (hm : m ∈ factoredNumbers s)
    (hn : n ∈ factoredNumbers s) :
    m * n ∈ factoredNumbers s
-- Mathlib/Data/Set/Basic.lean
@[simp] theorem setOf_top : { _x : α | ⊤ } = univ
-- Mathlib/Data/Matrix/Basic.lean
/-- `Matrix.conjTranspose` as a `LinearMap` -/
@[simps apply]
def conjTransposeLinearEquiv [CommSemiring R] [StarRing R] [AddCommMonoid α] [StarAddMonoid α]
    [Module R α] [StarModule R α] : Matrix m n α ≃ₗ⋆[R] Matrix n m α
-- Mathlib/Analysis/Fourier/FourierTransform.lean
lemma fourierIntegralInv_comm (f : V → E) :
    𝓕 (𝓕⁻ f) = 𝓕⁻ (𝓕 f)
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_neg_iff {x y : PGame} : y ⧏ -x ↔ x ⧏ -y
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem ContinuousOn.clm_comp {X} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F}
    {s : Set X} (hg : ContinuousOn g s) (hf : ContinuousOn f s) :
    ContinuousOn (fun x => (g x).comp (f x)) s
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp] lemma nil_copy {x' y' : V} {p : G.Walk x y} (hx : x = x') (hy : y = y') :
    (p.copy hx hy).Nil = p.Nil
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1
-- Mathlib/Data/NNReal/Basic.lean
nonrec theorem exists_mem_Ioc_zpow {x : ℝ≥0} {y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y) :
    ∃ n : ℤ, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1))
-- Mathlib/Algebra/Lie/CartanExists.lean
lemma lieCharpoly_coeff_natDegree (i j : ℕ) (hij : i + j = finrank R M) :
    ((lieCharpoly R M x y).coeff i).natDegree ≤ j
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
@[simp]
theorem mapAction_ε_inv_hom : (inv (F.mapAction G).ε).hom = inv F.ε
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
@[simp]
theorem lineDerivWithin_univ : lineDerivWithin 𝕜 f univ x v = lineDeriv 𝕜 f x v
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem cosh_dist' (z w : ℍ) :
    Real.cosh (dist z w) = ((z.re - w.re) ^ 2 + z.im ^ 2 + w.im ^ 2) / (2 * z.im * w.im)
-- Mathlib/Data/Complex/Basic.lean
theorem mul_conj (z : ℂ) : z * conj z = normSq z
-- Mathlib/Data/Nat/Factors.lean
/-- For positive `a` and `b`, the prime factors of `a * b` are the union of those of `a` and `b` -/
theorem perm_primeFactorsList_mul {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).primeFactorsList ~ a.primeFactorsList ++ b.primeFactorsList
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/SimplyConnected.lean
/-- A simply connected space is one whose fundamental groupoid is equivalent to `Discrete Unit` -/
@[mk_iff simply_connected_def]
class SimplyConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  equiv_unit : Nonempty (FundamentalGroupoid X ≌ Discrete Unit)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem stepBound_pos_iff {n : ℕ} : 0 < stepBound n ↔ 0 < n
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
/-- Let `A` and `C` be the adjacency matrices of a strongly regular graph with parameters `n k ℓ μ`
and its complement respectively and `I` be the identity matrix,
then `A ^ 2 = k • I + ℓ • A + μ • C`. `C` is equivalent to the expression `J - I - A`
more often found in the literature, where `J` is the all-ones matrix. -/
theorem IsSRGWith.matrix_eq {α : Type*} [Semiring α] (h : G.IsSRGWith n k ℓ μ) :
    G.adjMatrix α ^ 2 = k • (1 : Matrix V V α) + ℓ • G.adjMatrix α + μ • Gᶜ.adjMatrix α
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem factors_decreasing [IsDomain α] (b₁ b₂ : α) (h₁ : b₁ ≠ 0) (h₂ : ¬IsUnit b₂) :
    span ({b₁ * b₂} : Set α) < span {b₁}
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem commMap_apply_of_isReal (x : (K →+* ℂ) → ℂ) {w : InfinitePlace K} (hw : IsReal w) :
    (commMap K x).1 ⟨w, hw⟩ = (x w.embedding).re
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem rootSet_one (S) [CommRing S] [IsDomain S] [Algebra T S] : (1 : T[X]).rootSet S = ∅
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mul_mk'_eq_mk'_of_mul (x y : R) (z : M) :
    (algebraMap R S) x * mk' S y z = mk' S (x * y) z
-- Mathlib/Data/Finset/Card.lean
theorem eq_of_superset_of_card_ge (hst : s ⊆ t) (hts : t.card ≤ s.card) : t = s
-- Mathlib/GroupTheory/Perm/Support.lean
theorem support_le_prod_of_mem {l : List (Perm α)} (h : f ∈ l) (hl : l.Pairwise Disjoint) :
    f.support ≤ l.prod.support
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem sub_eq_add : a - b = a + b
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem ofSet_univ_eq_refl : ofSet univ isOpen_univ = PartialHomeomorph.refl X
-- Mathlib/CategoryTheory/Shift/Basic.lean
/-- A helper structure to construct the shift functor `(Discrete A) ⥤ (C ⥤ C)`. -/
structure ShiftMkCore where
  /-- the family of shift functors -/
  F : A → C ⥤ C
  /-- the shift by 0 identifies to the identity functor -/
  zero : F 0 ≅ 𝟭 C
  /-- the composition of shift functors identifies to the shift by the sum -/
  add : ∀ n m : A, F (n + m) ≅ F n ⋙ F m
  /-- compatibility with the associativity -/
  assoc_hom_app : ∀ (m₁ m₂ m₃ : A) (X : C),
    (add (m₁ + m₂) m₃).hom.app X ≫ (F m₃).map ((add m₁ m₂).hom.app X) =
      eqToHom (by rw [add_assoc]) ≫ (add m₁ (m₂ + m₃)).hom.app X ≫
        (add m₂ m₃).hom.app ((F m₁).obj X) := by aesop_cat
  /-- compatibility with the left addition with 0 -/
  zero_add_hom_app : ∀ (n : A) (X : C), (add 0 n).hom.app X =
    eqToHom (by dsimp; rw [zero_add]) ≫ (F n).map (zero.inv.app X) := by aesop_cat
  /-- compatibility with the right addition with 0 -/
  add_zero_hom_app : ∀ (n : A) (X : C), (add n 0).hom.app X =
    eqToHom (by dsimp; rw [add_zero]) ≫ zero.inv.app ((F n).obj X) := by aesop_cat
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem symm_toRingEquiv : (e.symm : A₂ ≃+* A₁) = (e : A₁ ≃+* A₂).symm
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
@[simp]
theorem ι_range_comap_reverse :
    (ι Q).range.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
      = LinearMap.range (ι Q)
-- Mathlib/ModelTheory/Order.lean
theorem realize_denselyOrdered_iff [Preorder M] :
    M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability]
theorem measurable_infDist {s : Set α} : Measurable fun x => infDist x s
-- Mathlib/MeasureTheory/Measure/Tilted.lean
lemma tilted_comm (hf : Integrable (fun x ↦ exp (f x)) μ) {g : α → ℝ}
    (hg : Integrable (fun x ↦ exp (g x)) μ) :
    (μ.tilted f).tilted g = (μ.tilted g).tilted f
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem aeval_X : aeval x (X : R[X]) = x
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem succ_log_def {b x : Ordinal} (hb : 1 < b) (hx : x ≠ 0) :
    succ (log b x) = sInf { o : Ordinal | x < b ^ o }
-- Mathlib/Algebra/Ring/Subring/Basic.lean
/-- An induction principle for closure membership. If `p` holds for `0`, `1`, and all elements
of `s`, and is preserved under addition, negation, and multiplication, then `p` holds for all
elements of the closure of `s`. -/
@[elab_as_elim]
theorem closure_induction {s : Set R} {p : R → Prop} {x} (h : x ∈ closure s) (Hs : ∀ x ∈ s, p x)
    (zero : p 0) (one : p 1) (add : ∀ x y, p x → p y → p (x + y)) (neg : ∀ x : R, p x → p (-x))
    (mul : ∀ x y, p x → p y → p (x * y)) : p x
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem Subset.ndunion_eq_right {s t : Multiset α} (h : s ⊆ t) : s.ndunion t = t
-- Mathlib/Algebra/Group/UniqueProds.lean
@[to_additive]
theorem set_subsingleton (h : UniqueMul A B a0 b0) :
    Set.Subsingleton { ab : G × G | ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0 }
-- Mathlib/Data/Finset/Sups.lean
lemma card_diffs_iff :
    (s \\ t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun x ↦ x.1 \ x.2
-- Mathlib/Data/Seq/WSeq.lean
theorem LiftRel.swap_lem {R : α → β → Prop} {s1 s2} (h : LiftRel R s1 s2) :
    LiftRel (swap R) s2 s1
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem map_eq_empty : s.map f = ∅ ↔ s = ∅
-- Mathlib/Analysis/Complex/Convex.lean
/-- A version of `convexHull_prod` for `Set.reProdIm`. -/
lemma convexHull_reProdIm (s t : Set ℝ) :
    convexHull ℝ (s ×ℂ t) = convexHull ℝ s ×ℂ convexHull ℝ t
-- Mathlib/Data/Sym/Sym2.lean
protected theorem «exists» {α : Sort _} {f : Sym2 α → Prop} :
    (∃ x : Sym2 α, f x) ↔ ∃ x y, f s(x, y)
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
theorem singularPart_neg (s : SignedMeasure α) (μ : Measure α) :
    (-s).singularPart μ = -s.singularPart μ
-- Mathlib/LinearAlgebra/Ray.lean
theorem sameRay_neg_smul_left_iff_of_ne {v : M} {r : R} (hv : v ≠ 0) (hr : r ≠ 0) :
    SameRay R (r • v) (-v) ↔ r < 0
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocMod_add_toIcoMod_zero (a b : α) :
    toIocMod hp 0 (a - b) + toIcoMod hp 0 (b - a) = p
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem TendstoUniformlyOn.mul (hf : TendstoUniformlyOn f g l s)
    (hf' : TendstoUniformlyOn f' g' l s) : TendstoUniformlyOn (f * f') (g * g') l s
-- Mathlib/Algebra/Algebra/Operations.lean
theorem mul_smul_mul_eq_smul_mul_smul (x y : R) : (x * y) • (M * N) = (x • M) * (y • N)
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem uniformContinuous_vadd : UniformContinuous fun x : V × P => x.1 +ᵥ x.2
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt_of_succ_lt      {n m : Nat} : succ n < m → n < m
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem re_smul (g : GL(2, ℝ)⁺) (z : ℍ) : (g • z).re = (num g z / denom g z).re
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem mul_single_apply_of_not_exists_add [Add G] (r : k) {g g' : G} (x : k[G])
    (h : ¬∃ d, g' = d + g) : (x * single g r) g' = 0
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
theorem range_comp [RingHomSurjective σ₂₃] [RingHomSurjective σ₁₃] :
    LinearMap.range (h.comp (e : M →ₛₗ[σ₁₂] M₂) : M →ₛₗ[σ₁₃] M₃) = LinearMap.range h
-- Mathlib/Data/Finset/Image.lean
theorem image_subset_iff : s.image f ⊆ t ↔ ∀ x ∈ s, f x ∈ t
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_of_not_imp {a : Prop} : ¬(a → b) → ¬b
-- Mathlib/Algebra/MvPolynomial/Division.lean
theorem add_divMonomial (x y : MvPolynomial σ R) (s : σ →₀ ℕ) :
    (x + y) /ᵐᵒⁿᵒᵐⁱᵃˡ s = x /ᵐᵒⁿᵒᵐⁱᵃˡ s + y /ᵐᵒⁿᵒᵐⁱᵃˡ s
-- Mathlib/Data/Set/Image.lean
theorem subset_image_union (f : α → β) (s : Set α) (t : Set β) : f '' (s ∪ f ⁻¹' t) ⊆ f '' s ∪ t
-- Mathlib/Topology/Clopen.lean
theorem Set.Finite.isClopen_biInter {s : Set Y} (hs : s.Finite) {f : Y → Set X}
    (h : ∀ i ∈ s, IsClopen (f i)) : IsClopen (⋂ i ∈ s, f i)
-- Mathlib/Algebra/Module/Defs.lean
/-- A module over a `Subsingleton` semiring is a `Subsingleton`. We cannot register this
as an instance because Lean has no way to guess `R`. -/
protected theorem Module.subsingleton (R M : Type*) [Semiring R] [Subsingleton R] [AddCommMonoid M]
    [Module R M] : Subsingleton M
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem blocks_length : c.blocks.length = c.length