ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_finset [MeasurableSingletonClass α] (s : Finset α) (f : α → E)
    (hf : Integrable f (μ.restrict s)) :
    ∫ x in s, f x ∂μ = ∑ x ∈ s, (μ {x}).toReal • f x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_embedding_eq_zero_iff_lt : #(α ↪ β) = 0 ↔ #β < #α
-- Mathlib/RingTheory/OreLocalization/Basic.lean
protected theorem zero_add (x : X[S⁻¹]) : 0 + x = x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
@[simp] protected lemma map_neg : neg (W'.map f) (f ∘ P) = f ∘ W'.neg P
-- Mathlib/Data/Rat/Sqrt.lean
lemma sqrt_nonneg (q : ℚ) : 0 ≤ Rat.sqrt q
-- Mathlib/AlgebraicTopology/DoldKan/Faces.lean
theorem comp_Hσ_eq {Y : C} {n a q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (hnaq : n = a + q) :
    φ ≫ (Hσ q).f (n + 1) =
      -φ ≫ X.δ ⟨a + 1, Nat.succ_lt_succ (Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm))⟩ ≫
        X.σ ⟨a, Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm)⟩
-- Mathlib/CategoryTheory/Galois/GaloisObjects.lean
@[simp]
lemma autMap_apply_mul {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ τ : Aut A) :
    autMap f (σ * τ) = autMap f σ * autMap f τ
-- Mathlib/Algebra/MvPolynomial/Variables.lean
@[simp]
theorem vars_X [Nontrivial R] : (X n : MvPolynomial σ R).vars = {n}
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem of_smul_measure (c : ℝ≥0∞) (hc_ne_top : c ≠ ∞) (hT : DominatedFinMeasAdditive (c • μ) T C) :
    DominatedFinMeasAdditive μ T (c.toReal * C)
-- Mathlib/Analysis/Analytic/Within.lean
@[simp] lemma hasFPowerSeriesWithinAt_univ {f : E → F} {p : FormalMultilinearSeries 𝕜 E F} {x : E} :
    HasFPowerSeriesWithinAt f p univ x ↔ HasFPowerSeriesAt f p x
-- Mathlib/Topology/PartialHomeomorph.lean
protected theorem leftInvOn : LeftInvOn e.symm e e.source
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem mfderivWithin_inter (ht : t ∈ 𝓝 x) :
    mfderivWithin I I' f (s ∩ t) x = mfderivWithin I I' f s x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem factorization_eq_count {n p : α} :
    factorization n p = Multiset.count p (normalizedFactors n)
-- Mathlib/CategoryTheory/Sites/OneHypercover.lean
@[reassoc]
lemma multiforkLift_map (i₀ : E.I₀) : multiforkLift c ≫ F.val.map (E.f i₀).op = c.ι i₀
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_toAffineIsometry : ⇑(f.toAffineIsometry : V →ᵃⁱ[𝕜] V₂) = f
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
theorem coe_desc {X α β : Type*} [TopologicalSpace X] (f : X → α) (g : α → β)
    (h : LocallyConstant X β) (cond : g ∘ f = h) (inj : Function.Injective g) :
    ⇑(desc f h cond inj) = f
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_div' (hac : a ≤ c) (hbd : d < b) (c0 : 0 < c) (d0 : 0 < d) : a / b < c / d
-- Mathlib/Data/Set/Finite.lean
theorem Finite.sUnion {s : Set (Set α)} (hs : s.Finite) (H : ∀ t ∈ s, Set.Finite t) :
    (⋃₀ s).Finite
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem radical_le_vanishingIdeal_zeroLocus (I : Ideal (MvPolynomial σ k)) :
    I.radical ≤ vanishingIdeal (zeroLocus I)
-- Mathlib/Data/List/Chain.lean
@[simp]
theorem chain'_singleton (a : α) : Chain' R [a]
-- Mathlib/Topology/Sets/Closeds.lean
nonrec theorem Closeds.compl_compl (s : Closeds α) : s.compl.compl = s
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem MeasurePreserving.setIntegral_image_emb {Y} {_ : MeasurableSpace Y} {f : X → Y} {ν}
    (h₁ : MeasurePreserving f μ ν) (h₂ : MeasurableEmbedding f) (g : Y → E) (s : Set X) :
    ∫ y in f '' s, g y ∂ν = ∫ x in s, g (f x) ∂μ
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem dropUntil_copy {u v w v' w'} (p : G.Walk v w) (hv : v = v') (hw : w = w')
    (h : u ∈ (p.copy hv hw).support) :
    (p.copy hv hw).dropUntil u h = (p.dropUntil u (by subst_vars; exact h)).copy rfl hw
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
@[simp]
lemma shiftIso_zero_hom_app (a : A) (X : C) :
    (F.shiftIso 0 a a (zero_add a)).hom.app X = (shiftFunctorZero D A).hom.app _
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem coe_bind (l : List α) (f : α → List β) : (@bind α β l fun a => f a) = l.bind f
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The abscissa of absolute convergence of the L-series of the Möbius function is `1`. -/
lemma abscissaOfAbsConv_moebius : abscissaOfAbsConv ↗μ = 1
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem unop_iSup (S : ι → Subring Rᵐᵒᵖ) : (iSup S).unop = ⨆ i, (S i).unop
-- Mathlib/FieldTheory/IntermediateField.lean
theorem set_range_subset : Set.range (algebraMap K L) ⊆ S
-- Mathlib/Algebra/Homology/BifunctorHomotopy.lean
@[reassoc]
lemma ιMapBifunctor_hom₁ (i₁ i₁' : I₁) (i₂ : I₂) (j j' : J)
    (h : ComplexShape.π c₁ c₂ c (i₁', i₂) = j) (h' : c₁.prev i₁' = i₁) :
    ιMapBifunctor K₁ K₂ F c i₁' i₂ j h ≫ hom₁ h₁ f₂ F c j j' = ComplexShape.ε₁ c₁ c₂ c (i₁, i₂) •
      (F.map (h₁.hom i₁' i₁)).app (K₂.X i₂) ≫ (F.obj (L₁.X i₁)).map (f₂.f i₂) ≫
        ιMapBifunctorOrZero L₁ L₂ F c _ _ j'
-- Mathlib/RingTheory/LocalRing/Module.lean
/--
Given a linear map `l : M → N` over a local ring `(R, 𝔪, k)`
with `M` finite and `N` finite free,
`l` is a split injection if and only if `k ⊗ l` is a (split) injection.
-/
theorem LocalRing.split_injective_iff_lTensor_residueField_injective
    [Module.Finite R M] [Module.Finite R N] [Module.Free R N] (l : M →ₗ[R] N) :
    (∃ l', l' ∘ₗ l = LinearMap.id) ↔ Function.Injective (l.lTensor (ResidueField R))
-- Mathlib/Data/Complex/Exponential.lean
theorem sin_conj : sin (conj x) = conj (sin x)
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
/-- If `φ : S₁ ⟶ S₂` is a morphism of short complexes such that `φ.τ₁` is epi, `φ.τ₂` is an iso
and `φ.τ₃` is mono, then a homology data for `S₂` induces a homology data for `S₁`.
The inverse construction is `ofEpiOfIsIsoOfMono`. -/
@[simps]
noncomputable def ofEpiOfIsIsoOfMono' (φ : S₁ ⟶ S₂) (h : HomologyData S₂)
    [Epi φ.τ₁] [IsIso φ.τ₂] [Mono φ.τ₃] : HomologyData S₁
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem HasFDerivWithinAt.arsinh (hf : HasFDerivWithinAt f f' s a) :
    HasFDerivWithinAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a
-- Mathlib/Data/Sigma/Basic.lean
theorem ext_iff {x₀ x₁ : PSigma β} : x₀ = x₁ ↔ x₀.1 = x₁.1 ∧ HEq x₀.2 x₁.2
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem isPreconnected_Ici : IsPreconnected (Ici a)
-- Mathlib/Analysis/NormedSpace/Real.lean
theorem frontier_sphere (x : E) {r : ℝ} (hr : r ≠ 0) : frontier (sphere x r) = sphere x r
-- Mathlib/Algebra/Lie/Submodule.lean
lemma iSup_induction {ι} (N : ι → LieSubmodule R L M) {C : M → Prop} {x : M}
    (hx : x ∈ ⨆ i, N i) (hN : ∀ i, ∀ y ∈ N i, C y) (h0 : C 0)
    (hadd : ∀ y z, C y → C z → C (y + z)) : C x
-- Mathlib/Data/List/Cycle.lean
theorem nextOr_cons_of_ne (xs : List α) (y x d : α) (h : x ≠ y) :
    nextOr (y :: xs) x d = nextOr xs x d
-- Mathlib/Order/Hom/Lattice.lean
/-- `SupHomClass F α β` states that `F` is a type of `⊔`-preserving morphisms.

You should extend this class when you extend `SupHom`. -/
class SupHomClass (F α β : Type*) [Sup α] [Sup β] [FunLike F α β] : Prop where
  /-- A `SupHomClass` morphism preserves suprema. -/
  map_sup (f : F) (a b : α) : f (a ⊔ b) = f a ⊔ f b
-- Mathlib/MeasureTheory/Measure/Sub.lean
@[simp]
theorem sub_self : μ - μ = 0
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma shiftFunctorZero_inv_app_shift (n : A) :
    (shiftFunctorZero C A).inv.app (X⟦n⟧) =
  ((shiftFunctorZero C A).inv.app X)⟦n⟧' ≫ (shiftFunctorComm C n 0).inv.app X
-- Mathlib/GroupTheory/Perm/Basic.lean
/-- `extendDomain` as a group homomorphism -/
@[simps]
def extendDomainHom : Perm α →* Perm β
-- Mathlib/Data/List/AList.lean
theorem mk_cons_eq_insert (c : Sigma β) (l : List (Sigma β)) (h : (c :: l).NodupKeys) :
    (⟨c :: l, h⟩ : AList β) = insert c.1 c.2 ⟨l, nodupKeys_of_nodupKeys_cons h⟩
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
/-- A version of `measurable_div_const` that assumes `MeasurableMul` instead of
  `MeasurableDiv`. This can be nice to avoid unnecessary type-class assumptions. -/
@[to_additive " A version of `measurable_sub_const` that assumes `MeasurableAdd` instead of
  `MeasurableSub`. This can be nice to avoid unnecessary type-class assumptions. "]
theorem measurable_div_const' {G : Type*} [DivInvMonoid G] [MeasurableSpace G] [MeasurableMul G]
    (g : G) : Measurable fun h => h / g
-- Mathlib/MeasureTheory/Group/MeasurableEquiv.lean
@[to_additive (attr := simp)]
theorem symm_mulRight (g : G) : (mulRight g).symm = mulRight g⁻¹
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addY_of_Z_eq_zero_right {P Q : Fin 3 → R} (hQ : W'.Equation Q) (hQz : Q z = 0) :
    W'.addY P Q = (-(Q x * P z)) ^ 3 * P y
-- Mathlib/Data/Matrix/Basis.lean
theorem col_eq_zero_of_commute_stdBasisMatrix {i j k : n} {M : Matrix n n α}
    (hM : Commute (stdBasisMatrix i j 1) M) (hki : k ≠ i) : M k i = 0
-- Mathlib/GroupTheory/Perm/ClosureSwap.lean
theorem finite_compl_fixedBy_swap {x y : α} : (fixedBy α (swap x y))ᶜ.Finite
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem mem_map_equiv {f : R ≃+* S} {K : Subsemiring R} {x : S} :
    x ∈ K.map (f : R →+* S) ↔ f.symm x ∈ K
-- Mathlib/Order/WithBot.lean
@[simp]
theorem ofDual_apply_coe (a : αᵒᵈ) : WithBot.ofDual (a : WithBot αᵒᵈ) = ofDual a
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem tsum_mul_right [T2Space α] : ∑' x, f x * a = (∑' x, f x) * a
-- Mathlib/RingTheory/Congruence/Basic.lean
protected theorem neg {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    {a b} (h : t a b) : t (-a) (-b)
-- Mathlib/Init/Algebra/Classes.lean
@[elab_without_expected_type]
theorem trans_of [IsTrans α r] {a b c : α} : a ≺ b → b ≺ c → a ≺ c
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem disjoint_supported_supported {s t : Set α} (h : Disjoint s t) :
    Disjoint (supported M R s) (supported M R t)
-- Mathlib/Data/Seq/WSeq.lean
theorem destruct_map (f : α → β) (s : WSeq α) :
    destruct (map f s) = Computation.map (Option.map (Prod.map f (map f))) (destruct s)
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.inter [DecidableEq α] (l₂ : List α) : Nodup l₁ → Nodup (l₁ ∩ l₂)
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
@[mono]
theorem mono_cast : Monotone (Nat.cast : ℕ → α)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem exp_neg_mul_sq_isLittleO_exp_neg {b : ℝ} (hb : 0 < b) :
    (fun x : ℝ => exp (-b * x ^ 2)) =o[atTop] fun x : ℝ => exp (-x)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_toMeasurable_add_inter_left {s t : Set α} (hs : MeasurableSet s)
    (ht : (μ + ν) t ≠ ∞) : μ (toMeasurable (μ + ν) t ∩ s) = μ (t ∩ s)
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem mk_coe (e : α ≃+*o β) (h) : (⟨e, h⟩ : α ≃+*o β) = e
-- Mathlib/LinearAlgebra/Matrix/HermitianFunctionalCalculus.lean
/-- The star algebra homomorphism underlying the instance of the continuous functional
calculus of a Hermitian matrix. This is an auxiliary definition and is not intended
for use outside of this file. -/
@[simps]
noncomputable def cfcAux : C(spectrum ℝ A, ℝ) →⋆ₐ[ℝ] (Matrix n n 𝕜)
-- Mathlib/Algebra/Order/CompleteField.lean
theorem cutMap_self (a : α) : cutMap α a = Iio a ∩ range (Rat.cast : ℚ → α)
-- Mathlib/CategoryTheory/Iso.lean
theorem eq_of_inv_eq_inv {f g : X ⟶ Y} [IsIso f] [IsIso g] (p : inv f = inv g) : f = g
-- Mathlib/Data/Nat/Factorization/Basic.lean
@[simp]
theorem factorization_div {d n : ℕ} (h : d ∣ n) :
    (n / d).factorization = n.factorization - d.factorization
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
/-- The standard basis of the endomorphism algebra of a module
induced by a basis of the module.

If `M` is a module with basis `b` indexed by a finite type `ι`,
then `Basis.end b` is the basis of `Module.End R M` indexed by `ι × ι`
where `(i, j)` indexes the linear map that sends `b j` to `b i`
and sends all other basis vectors to `0`.  -/
@[simps! (config := .lemmasOnly) repr_apply repr_symm_apply]
noncomputable
abbrev _root_.Basis.end (b : Basis ι R M) : Basis (ι × ι) R (Module.End R M)
-- Mathlib/RingTheory/Localization/NumDen.lean
theorem num_mul_den_eq_num_iff_eq' {x y : K} :
    y * algebraMap A K (den A x) = algebraMap A K (num A x) ↔ x = y
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictMono.prod_map (hf : StrictMono f) (hg : StrictMono g) : StrictMono (Prod.map f g)
-- Mathlib/Data/List/Basic.lean
theorem eq_cons_of_length_one {l : List α} (h : l.length = 1) :
    l = [l.nthLe 0 (by omega)]
-- Mathlib/Data/Finmap.lean
@[simp]
theorem lookup_empty (a) : lookup a (∅ : Finmap β) = none
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mem_brange {o : Ordinal} {f : ∀ a < o, α} {a} : a ∈ brange o f ↔ ∃ i hi, f i hi = a
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
protected lemma inv [DecidableEq n] {M : Matrix n n R} (hM : M.PosSemidef) : M⁻¹.PosSemidef
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_dite (f : ∀ i, p i → Set α) (g : ∀ i, ¬p i → Set α) :
    ⋂ i, (if h : p i then f i h else g i h) = (⋂ (i) (h : p i), f i h) ∩ ⋂ (i) (h : ¬p i), g i h
-- Mathlib/Data/ENat/Basic.lean
@[simp]
theorem coe_toNat_eq_self : ENat.toNat n = n ↔ n ≠ ⊤
-- Mathlib/Data/Finsupp/Order.lean
lemma le_def : f ≤ g ↔ ∀ i, f i ≤ g i
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem exp_neg : exp (-x) = (exp x)⁻¹
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive zsmul_add] lemma mul_zpow : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
theorem sSup_closed_unit_ball_eq_norm {𝕜 𝕜₂ E F : Type*} [NormedAddCommGroup E]
    [SeminormedAddCommGroup F] [DenselyNormedField 𝕜] [NontriviallyNormedField 𝕜₂] {σ₁₂ : 𝕜 →+* 𝕜₂}
    [NormedSpace 𝕜 E] [NormedSpace 𝕜₂ F] [RingHomIsometric σ₁₂] (f : E →SL[σ₁₂] F) :
    sSup ((fun x => ‖f x‖) '' closedBall 0 1) = ‖f‖
-- Mathlib/CategoryTheory/Limits/MonoCoprod.lean
lemma mono_binaryCofanSum_inl' [MonoCoprod C] (inl : c₁.pt ⟶ c.pt)
    (hinl : ∀ (i₁ : I₁), c₁.inj i₁ ≫ inl = c.inj (Sum.inl i₁)) :
    Mono inl
-- .lake/packages/lean4/src/lean/Init/Core.lean
/-- The analogue of `Quot.ind`: every element of `Quotient s` is of the form `Quotient.mk s a`. -/
protected theorem ind {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop} : ((a : α) → motive (Quotient.mk s a)) → (q : Quotient s) → motive q
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma mult_comap_le (f : k →+* K) (w : InfinitePlace K) : mult (w.comap f) ≤ mult w
-- Mathlib/Algebra/Order/Monoid/TypeTags.lean
@[simp]
theorem ofAdd_lt {a b : α} : ofAdd a < ofAdd b ↔ a < b
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
protected theorem map_mul_inv [Group α] [DivisionMonoid β] (f : α →* β) (g h : α) :
    f (g * h⁻¹) = f g * (f h)⁻¹
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Iic (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Iic a = Iic (a / c)
-- Mathlib/FieldTheory/Adjoin.lean
@[simp] protected
theorem rank_bot : Module.rank F (⊥ : IntermediateField F E) = 1
-- Mathlib/Data/Int/Defs.lean
@[simp, nolint simpNF]
protected lemma neg_nonpos_iff_nonneg : -a ≤ 0 ↔ 0 ≤ a
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_mul (x₁ x₂ : R) (y₁ y₂ : M) : mk' S (x₁ * x₂) (y₁ * y₂) = mk' S x₁ y₁ * mk' S x₂ y₂
-- Mathlib/Data/Matrix/Reflection.lean
/-- This can be used to prove
```lean
example (a b c d : α) [Mul α] [AddCommMonoid α] :
  dot_product ![a, b] ![c, d] = a * c + b * d :=
(dot_productᵣ_eq _ _).symm
```
-/
@[simp]
theorem dotProductᵣ_eq [Mul α] [AddCommMonoid α] {m} (a b : Fin m → α) :
    dotProductᵣ a b = dotProduct a b
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem multipliable_iff_tprod_vanishing : Multipliable f ↔
    ∀ e ∈ 𝓝 (1 : α), ∃ s : Finset β, ∀ t : Set β, Disjoint t s → (∏' b : t, f b) ∈ e
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `X`. -/
@[simps!]
noncomputable def yonedaCompLimIsoCocones (F : J ⥤ C) :
    yoneda ⋙ (whiskeringLeft _ _ _).obj F.op ⋙ lim ≅ F.cocones
-- Mathlib/Order/Category/Preord.lean
/-- Constructs an equivalence between preorders from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : Preord.{u}} (e : α ≃o β) : α ≅ β
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp, norm_cast]
theorem coe_dfinsupp_sumAddHom [AddZeroClass R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (f : Π₀ i, β i) (g : ∀ i, β i →+ R →+ S) :
    ⇑(sumAddHom g f) = sumAddHom (fun i => (coeFn R S).comp (g i)) f
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
/-- The block matrix `A.fromBlocks 0 0 D` is diagonal if `A` and `D` are diagonal. -/
theorem IsDiag.fromBlocks [Zero α] {A : Matrix m m α} {D : Matrix n n α} (ha : A.IsDiag)
    (hd : D.IsDiag) : (A.fromBlocks 0 0 D).IsDiag
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := simp)]
theorem smul_orbit (g : G) (a : α) : g • orbit G a = orbit G a
-- Mathlib/MeasureTheory/Group/AEStabilizer.lean
@[to_additive]
lemma stabilizer_le_aestabilizer (s : Set α) : stabilizer G s ≤ aestabilizer G μ s
-- Mathlib/Algebra/Category/Ring/Basic.lean
/--
Ring equivalence are isomorphisms in category of semirings
-/
@[simps]
def _root_.RingEquiv.toSemiRingCatIso {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    SemiRingCat.of X ≅ SemiRingCat.of Y
-- Mathlib/Data/Finset/NAry.lean
lemma inf'_image₂_left (g : γ → δ) (h : (image₂ f s t).Nonempty) :
    inf' (image₂ f s t) h g =
      inf' s h.of_image₂_left fun x ↦ inf' t h.of_image₂_right (g <| f x ·)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_inj {e e' : M₁ ≃SL[σ₁₂] M₂} : (e : M₁ →SL[σ₁₂] M₂) = e' ↔ e = e'
-- Mathlib/LinearAlgebra/Trace.lean
/-- When `M` is finite free, the trace of a linear map correspond to the contraction pairing under
the isomorphism `End(M) ≃ M* ⊗ M`-/
@[simp]
theorem trace_eq_contract : LinearMap.trace R M ∘ₗ dualTensorHom R M M = contractLeft R M
-- Mathlib/Dynamics/PeriodicPts.lean
theorem bUnion_ptsOfPeriod : ⋃ n > 0, ptsOfPeriod f n = periodicPts f
-- Mathlib/CategoryTheory/Idempotents/HomologicalComplex.lean
/-- The functor `HomologicalComplex (Karoubi C) c ⥤ Karoubi (HomologicalComplex C c)`,
on objects -/
@[simps]
def obj (K : HomologicalComplex (Karoubi C) c) : Karoubi (HomologicalComplex C c)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem image_eq (h : e.IsImage s t) : e '' (e.source ∩ s) = e.target ∩ t
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
@[simp]
theorem coe_toLinearMap (f : Q₁ →qᵢ Q₂) : ⇑f.toLinearMap = f
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem eq_prod_range_div {M : Type*} [CommGroup M] (f : ℕ → M) (n : ℕ) :
    f n = f 0 * ∏ i ∈ range n, f (i + 1) / f i
-- Mathlib/Topology/PartialHomeomorph.lean
theorem of_image_eq (h : e '' (e.source ∩ s) = e.target ∩ t) : e.IsImage s t
-- Mathlib/Algebra/Order/UpperLower.lean
@[to_additive]
private theorem one_mul (s : LowerSet α) : 1 * s = s
-- Mathlib/Order/Hom/CompleteLattice.lean
/-- Using `Set.image`, a function between types yields a `sSupHom` between their lattices of
subsets.

See also `CompleteLatticeHom.setPreimage`. -/
@[simps]
def sSupHom.setImage (f : α → β) : sSupHom (Set α) (Set β)
-- Mathlib/Analysis/MellinTransform.lean
theorem mellinConvergent_of_isBigO_rpow [NormedSpace ℂ E] {a b : ℝ} {f : ℝ → E} {s : ℂ}
    (hfc : LocallyIntegrableOn f <| Ioi 0) (hf_top : f =O[atTop] (· ^ (-a)))
    (hs_top : s.re < a) (hf_bot : f =O[𝓝[>] 0] (· ^ (-b))) (hs_bot : b < s.re) :
    MellinConvergent f s
-- Mathlib/Computability/Primrec.lean
theorem list_getI [Inhabited α] : Primrec₂ (@List.getI α _)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem rat_inv_continuous_lemma {β : Type*} [DivisionRing β] (abv : β → α) [IsAbsoluteValue abv]
    {ε K : α} (ε0 : 0 < ε) (K0 : 0 < K) :
    ∃ δ > 0, ∀ {a b : β}, K ≤ abv a → K ≤ abv b → abv (a - b) < δ → abv (a⁻¹ - b⁻¹) < ε
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem castLT_castAdd (m : Nat) (i : Fin n) :
    castLT (castAdd m i) (castAdd_lt m i) = i
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
@[simp]
theorem separatingLeft_congr_iff :
    (e₁.arrowCongr (e₂.arrowCongr (LinearEquiv.refl R M)) B).SeparatingLeft ↔ B.SeparatingLeft
-- Mathlib/Algebra/Group/AddChar.lean
/-- The values of an additive character on an additive group are units. -/
lemma val_isUnit {A M} [AddGroup A] [Monoid M] (φ : AddChar A M) (a : A) : IsUnit (φ a)
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
/-- The compatibility of the shift functors on `CochainComplex C ℤ` with respect
to the addition of integers. -/
@[simps!]
def shiftFunctorAdd' (n₁ n₂ n₁₂ : ℤ) (h : n₁ + n₂ = n₁₂) :
    shiftFunctor C n₁₂ ≅ shiftFunctor C n₁ ⋙ shiftFunctor C n₂
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem singleton_sub_eq (a : A) (r : R) : {r} - σ a = σ (↑ₐ r - a)
-- Mathlib/Data/Set/Function.lean
theorem congr_right (h₁ : LeftInvOn f₁' f₁ s) (heq : EqOn f₁ f₂ s) : LeftInvOn f₁' f₂ s
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem mem_image₂ : c ∈ image₂ f s t ↔ ∃ a ∈ s, ∃ b ∈ t, f a b = c
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem hasBasis_nhds_zero_of_basis [TopologicalSpace F] [TopologicalAddGroup F]
    {ι : Type*} (𝔖 : Set (Set E)) (h𝔖₁ : 𝔖.Nonempty) (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop}
    {b : ι → Set F} (h : (𝓝 0 : Filter F).HasBasis p b) :
    (𝓝 (0 : UniformConvergenceCLM σ F 𝔖)).HasBasis
      (fun Si : Set E × ι => Si.1 ∈ 𝔖 ∧ p Si.2)
      fun Si => { f : E →SL[σ] F | ∀ x ∈ Si.1, f x ∈ b Si.2 }
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp, norm_cast] lemma cast_neg (q : ℚ) : ↑(-q) = (-q : α)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem isPartitionDisjUnionOfEqDiff (h : π₂.iUnion = ↑I \ π₁.iUnion) :
    IsPartition (π₁.disjUnion π₂ <| h.symm ▸ disjoint_sdiff_self_right)
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive lipschitzWith_one_norm]
theorem lipschitzWith_one_norm' : LipschitzWith 1 (norm : E → ℝ)
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem mem_rightTransversals_iff_existsUnique_quotient_mk''_eq :
    S ∈ rightTransversals (H : Set G) ↔
      ∀ q : Quotient (QuotientGroup.rightRel H), ∃! s : S, Quotient.mk'' s.1 = q
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
lemma pi {J : Type w} {C : J → Type u} {D : J → Type u'}
    [∀ j, Category.{v} (C j)] [∀ j, Category.{v'} (D j)]
    (W : ∀ j, MorphismProperty (C j)) (F : ∀ j, C j ⥤ D j)
    (hF : ∀ j, (W j).IsInvertedBy (F j)) :
    (MorphismProperty.pi W).IsInvertedBy (Functor.pi F)
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem rootSet_def (p : T[X]) (S) [CommRing S] [IsDomain S] [Algebra T S] [DecidableEq S] :
    p.rootSet S = (p.aroots S).toFinset
-- Mathlib/LinearAlgebra/Basis.lean
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i
-- Mathlib/Order/CompleteLattice.lean
lemma iInf_sigma' {κ : β → Type*} (f : ∀ i, κ i → α) :
    (⨅ i, ⨅ j, f i j) = ⨅ x : Σ i, κ i, f x.1 x.2
-- Mathlib/Tactic/PushNeg.lean
theorem not_implies_eq : (¬ (p → q)) = (p ∧ ¬ q)
-- Mathlib/Topology/Basic.lean
theorem IsOpen.and : IsOpen { x | p₁ x } → IsOpen { x | p₂ x } → IsOpen { x | p₁ x ∧ p₂ x }
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem map_map [CommSemiring S₂] (g : S₁ →+* S₂) (p : MvPolynomial σ R) :
    map g (map f p) = map (g.comp f) p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem sub_mul_div (x n p : Nat) (h₁ : n*p ≤ x) : (x - n*p) / n = x / n - p
-- Mathlib/Algebra/Polynomial/Div.lean
theorem natDegree_modByMonic_lt (p : R[X]) {q : R[X]} (hmq : Monic q) (hq : q ≠ 1) :
    natDegree (p %ₘ q) < q.natDegree
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem le_of_mul_le_of_one_le_left [CovariantClass α α (· * ·) (· ≤ ·)] {a b c : α} (h : a * b ≤ c)
    (hle : 1 ≤ b) :
    a ≤ c
-- Mathlib/Algebra/Field/Subfield.lean
theorem isGLB_sInf (S : Set (Subfield K)) : IsGLB S (sInf S)
-- Mathlib/Algebra/DirectSum/Module.lean
theorem lof_eq_of (i : ι) (b : M i) : lof R ι M i b = of M i b
-- Mathlib/Data/Fin/Tuple/Basic.lean
lemma snoc_zero {α : Type*} (p : Fin 0 → α) (x : α) :
    Fin.snoc p x = fun _ ↦ x
-- Mathlib/Order/Basic.lean
theorem lt_imp_lt_of_le_imp_le {β} [LinearOrder α] [Preorder β] {a b : α} {c d : β}
    (H : a ≤ b → c ≤ d) (h : d < c) : b < a