ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem ae_restrict_eq (hs : MeasurableSet s) : ae (μ.restrict s) = ae μ ⊓ 𝓟 s
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem coe_essSup {f : α → ℝ≥0} (hf : IsBoundedUnder (· ≤ ·) (ae μ) f) :
    ((essSup f μ : ℝ≥0) : ℝ≥0∞) = essSup (fun x => (f x : ℝ≥0∞)) μ
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma mulIndicator_le_self' (hf : ∀ x ∉ s, 1 ≤ f x) : mulIndicator s f ≤ f
-- Mathlib/Data/Int/Defs.lean
lemma pow_right_injective (h : 1 < a.natAbs) : ((a ^ ·) : ℕ → ℤ).Injective
-- Mathlib/CategoryTheory/GradedObject.lean
lemma hasMap_comp [X.HasMap p] [(X.mapObj p).HasMap q] : X.HasMap r
-- Mathlib/Topology/CompactOpen.lean
lemma nhds_compactOpen (f : C(X, Y)) :
    𝓝 f = ⨅ (K : Set X) (_ : IsCompact K) (U : Set Y) (_ : IsOpen U) (_ : MapsTo f K U),
      𝓟 {g : C(X, Y) | MapsTo g K U}
-- Mathlib/Probability/Kernel/Composition.lean
lemma snd_map_prod (κ : Kernel α β) {f : β → γ} {g : β → δ}
    (hf : Measurable f) (hg : Measurable g) :
    snd (map κ (fun x ↦ (f x, g x)) (hf.prod_mk hg)) = map κ g hg
-- Mathlib/Data/Multiset/Range.lean
theorem range_add_eq_union (a b : ℕ) : range (a + b) = range a ∪ (range b).map (a + ·)
-- Mathlib/Data/Set/Basic.lean
theorem SetCoe.exists {s : Set α} {p : s → Prop} :
    (∃ x : s, p x) ↔ ∃ (x : _) (h : x ∈ s), p ⟨x, h⟩
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
lemma lift'_unique (f : WithZero α →*₀ β) : f = lift' (f.toMonoidHom.comp coeMonoidHom)
-- Mathlib/GroupTheory/PGroup.lean
theorem to_inf_right {H K : Subgroup G} (hK : IsPGroup p K) : IsPGroup p (H ⊓ K : Subgroup G)
-- .lake/packages/batteries/Batteries/Data/RBMap/Basic.lean
theorem any_iff {t : RBNode α} : t.any p ↔ t.Any (p ·)
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_one [Nontrivial R] : abv 1 = 1
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem mapLe_isCycle {G G' : SimpleGraph V} (h : G ≤ G') {u : V} {p : G.Walk u u} :
    (p.mapLe h).IsCycle ↔ p.IsCycle
-- Mathlib/Topology/Bornology/Absorbs.lean
@[simp]
protected lemma univ : Absorbs G₀ univ s
-- Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean
@[simp]
theorem app_zero (X : C) : (0 : F ⟶ G).app X = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem zero_or (x : Nat) : 0 ||| x = x
-- Mathlib/Data/Nat/Defs.lean
lemma sqrt_lt' : sqrt m < n ↔ m < n ^ 2
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem Contravariant.MulLECancellable [Mul α] [LE α] [ContravariantClass α α (· * ·) (· ≤ ·)]
    {a : α} :
    MulLECancellable a
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem elim_lam_const_lam_const (c : γ) :
    Sum.elim (fun _ : α => c) (fun _ : β => c) = fun _ => c
-- Mathlib/Order/Filter/Basic.lean
theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
    Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem last_pos : (0 : Fin (n + 2)) < last (n + 1)
-- Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
/-- If the vector passed to `secondInter` is given by a subtraction involving the point in
`secondInter`, and the second point is inside the sphere, the second point is strictly between
the first point and the result of `secondInter`. -/
theorem Sphere.sbtw_secondInter {s : Sphere P} {p p' : P} (hp : p ∈ s)
    (hp' : dist p' s.center < s.radius) : Sbtw ℝ p p' (s.secondInter p (p' -ᵥ p))
-- Mathlib/GroupTheory/Abelianization.lean
@[simp]
theorem lift.of (x : G) : lift f (of x) = f x
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma map_preΨ₄ : (W.map f).preΨ₄ = W.preΨ₄.map f
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
/-- Double integrals commute with addition. -/
theorem integral_integral_add ⦃f g : α × β → E⦄ (hf : Integrable f (μ.prod ν))
    (hg : Integrable g (μ.prod ν)) :
    (∫ x, ∫ y, f (x, y) + g (x, y) ∂ν ∂μ) = (∫ x, ∫ y, f (x, y) ∂ν ∂μ) + ∫ x, ∫ y, g (x, y) ∂ν ∂μ
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem le_add_tsub_swap : a ≤ b + a - b
-- Mathlib/Combinatorics/SimpleGraph/Dart.lean
theorem dartOfNeighborSet_injective (v : V) : Function.Injective (G.dartOfNeighborSet v)
-- Mathlib/Order/OmegaCompletePartialOrder.lean
@[simp] theorem zip_coe (c₀ : Chain α) (c₁ : Chain β) (n : ℕ) : c₀.zip c₁ n = (c₀ n, c₁ n)
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
theorem adjMatrix_mulVec_const_apply_of_regular [NonAssocSemiring α] {d : ℕ} {a : α}
    (hd : G.IsRegularOfDegree d) {v : V} : (G.adjMatrix α *ᵥ Function.const _ a) v = d * a
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
/-- This is a generic version which allows us to prove both
`NonUnitalSubalgebra.unitization_injective` and `NonUnitalStarSubalgebra.unitization_injective`. -/
theorem _root_.AlgHomClass.unitization_injective {F R S A : Type*} [Field R] [Ring A]
    [Algebra R A] [SetLike S A] [hSA : NonUnitalSubringClass S A] [hSRA : SMulMemClass S R A]
    (s : S) (h1 : 1 ∉ s) [FunLike F (Unitization R s) A] [AlgHomClass F R (Unitization R s) A]
    (f : F) (hf : ∀ x : s, f x = x) : Function.Injective f
-- Mathlib/Data/Sign.lean
theorem sign_eq_neg_one_iff : sign a = -1 ↔ a < 0
-- Mathlib/Computability/Primrec.lean
theorem list_casesOn {f : α → List β} {g : α → σ} {h : α → β × List β → σ} :
    Primrec f →
      Primrec g →
        Primrec₂ h → @Primrec _ σ _ _ fun a => List.casesOn (f a) (g a) fun b l => h a (b, l)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
theorem comp_mul (g : β →*₀o γ) (f₁ f₂ : α →*₀o β) : g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arcsin_lt_pi_div_two {x : ℝ} : arcsin x < π / 2 ↔ x < 1
-- Mathlib/Data/Finset/Sups.lean
lemma image_subset_infs_right : a ∈ s → t.image (a ⊓ ·) ⊆ s ⊼ t
-- Mathlib/Algebra/Ring/Equiv.lean
/--
Construct an equivalence of rings from unital homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv {R S F G : Type*} [NonAssocSemiring R] [NonAssocSemiring S]
    [FunLike F R S] [FunLike G S R] [RingHomClass F R S]
    [RingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →+* R).comp (hom : R →+* S) = RingHom.id R)
    (inv_hom_id : (hom : R →+* S).comp (inv : S →+* R) = RingHom.id S) :
    R ≃+* S
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem ofMonotone_coe [IsTrichotomous α r] [IsAsymm β s] (f : α → β) (H) :
    (@ofMonotone _ _ r s _ _ f H : α → β) = f
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smoothAt_proj {p : TotalSpace F E} : SmoothAt (IB.prod 𝓘(𝕜, F)) IB (π F E) p
-- Mathlib/Data/Multiset/Bind.lean
theorem rel_bind {r : α → β → Prop} {p : γ → δ → Prop} {s t} {f : α → Multiset γ}
    {g : β → Multiset δ} (h : (r ⇒ Rel p) f g) (hst : Rel r s t) :
    Rel p (s.bind f) (t.bind g)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem inter_mul_subset : s₁ ∩ s₂ * t ⊆ s₁ * t ∩ (s₂ * t)
-- Mathlib/Order/Filter/Pointwise.lean
theorem NeBot.zero_mul_nonneg (hg : g.NeBot) : 0 ≤ 0 * g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivWithinAt.csin (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') s x
-- Mathlib/Topology/Order/LowerUpperTopology.lean
lemma topology_eq : ‹_› = upper α
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem cancel_right {g₁ g₂ : BoundedLatticeHom β γ} {f : BoundedLatticeHom α β}
    (hf : Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem ofEq_symm (h : S₁ = S₂) : (ofEq S₁ S₂ h).symm = ofEq S₂ S₁ h.symm
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem associator_inv_naturality_middle (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d) :
    f ◁ η ▷ h ≫ (α_ f g' h).inv = (α_ f g h).inv ≫ (f ◁ η) ▷ h
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_eq_zero_iff_of_nonneg_ae {f : X → ℝ} (hf : 0 ≤ᵐ[μ.restrict s] f)
    (hfi : IntegrableOn f s μ) : ∫ x in s, f x ∂μ = 0 ↔ f =ᵐ[μ.restrict s] 0
-- Mathlib/Data/PEquiv.lean
theorem mem_ofSet_iff {s : Set α} [DecidablePred (· ∈ s)] {a b : α} :
    a ∈ ofSet s b ↔ a = b ∧ a ∈ s
-- Mathlib/Data/Set/Subsingleton.lean
theorem Nontrivial.mono (hs : s.Nontrivial) (hst : s ⊆ t) : t.Nontrivial
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iic_union_Ioi : Iic a ∪ Ioi a = univ
-- Mathlib/Order/Filter/Prod.lean
@[gcongr]
theorem prod_mono_right (f : Filter α) {g₁ g₂ : Filter β} (hf : g₁ ≤ g₂) : f ×ˢ g₁ ≤ f ×ˢ g₂
-- Mathlib/CategoryTheory/Products/Unitor.lean
/-- The left unitor functor `1 × C ⥤ C` -/
@[simps]
def leftUnitor : Discrete (PUnit : Type w) × C ⥤ C
-- Mathlib/Control/LawfulFix.lean
theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f
-- Mathlib/Analysis/NormedSpace/HomeomorphBall.lean
@[simp]
theorem univBall_source (c : P) (r : ℝ) : (univBall c r).source = univ
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_units {y : Gˣ} : orderOf (y : G) = orderOf y
-- Mathlib/Order/Hom/Set.lean
@[simp]
theorem symm_image_image (e : α ≃o β) (s : Set α) : e.symm '' (e '' s) = s
-- Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
theorem adjoint_apply_of_not_dense (hT : ¬Dense (T.domain : Set E)) (y : T†.domain) : T† y = 0
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
/-- Let `s : Finset (ι × ℝ)` be a set of hyperplanes `{x : ι → ℝ | x i = r}` in `ι → ℝ` encoded as
pairs `(i, r)`. Suppose that this set contains all faces of a box `J`. The hyperplanes of `s` split
a box `I` into subboxes. Let `Js` be one of them. If `J` and `Js` have nonempty intersection, then
`Js` is a subbox of `J`.  -/
theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Finset (ι × ℝ)}
    (H : ∀ i, {(i, J.lower i), (i, J.upper i)} ⊆ s) (HJs : Js ∈ splitMany I s)
    (Hn : ¬Disjoint (J : WithBot (Box ι)) Js) : Js ≤ J
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
protected theorem Specializes.mul {a b c d : M} (hab : a ⤳ b) (hcd : c ⤳ d) : (a * c) ⤳ (b * d)
-- Mathlib/Algebra/Order/Ring/Defs.lean
/-- An `OrderedSemiring` is a semiring with a partial order such that addition is monotone and
multiplication by a nonnegative number is monotone. -/
class OrderedSemiring (α : Type u) extends Semiring α, OrderedAddCommMonoid α where
  /-- `0 ≤ 1` in any ordered semiring. -/
  protected zero_le_one : (0 : α) ≤ 1
  /-- In an ordered semiring, we can multiply an inequality `a ≤ b` on the left
  by a non-negative element `0 ≤ c` to obtain `c * a ≤ c * b`. -/
  protected mul_le_mul_of_nonneg_left : ∀ a b c : α, a ≤ b → 0 ≤ c → c * a ≤ c * b
  /-- In an ordered semiring, we can multiply an inequality `a ≤ b` on the right
  by a non-negative element `0 ≤ c` to obtain `a * c ≤ b * c`. -/
  protected mul_le_mul_of_nonneg_right : ∀ a b c : α, a ≤ b → 0 ≤ c → a * c ≤ b * c
-- Mathlib/Data/Int/Defs.lean
lemma lt_succ_self (a : ℤ) : a < succ a
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiff.div_const {f : E → 𝕜'} {n} (hf : ContDiff 𝕜 n f) (c : 𝕜') :
    ContDiff 𝕜 n fun x => f x / c
-- Mathlib/Logic/Equiv/Defs.lean
/-- `ULift α` is equivalent to `α`. -/
@[simps (config := .asFn) apply]
protected def ulift {α : Type v} : ULift.{u} α ≃ α
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem isVanKampenColimit_of_isEmpty [HasStrictInitialObjects C] [IsEmpty J] {F : J ⥤ C}
    (c : Cocone F) (hc : IsColimit c) : IsVanKampenColimit c
-- Mathlib/Control/Fold.lean
theorem foldMap_map [Monoid γ] (f : α → β) (g : β → γ) (xs : t α) :
    foldMap g (f <$> xs) = foldMap (g ∘ f) xs
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem linearIndependent : LinearIndependent R x
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem perm_iff_count {l₁ l₂ : List α} : l₁ ~ l₂ ↔ ∀ a, count a l₁ = count a l₂
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[mono]
protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.transpose ≤ ν.transpose
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem exp_antiperiodic : Function.Antiperiodic exp (π * I)
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp]
theorem card_sum [Finite α] [Finite β] : Nat.card (α ⊕ β) = Nat.card α + Nat.card β
-- Mathlib/Analysis/Calculus/Deriv/Linear.lean
@[simp]
protected theorem LinearMap.deriv : deriv e x = e 1
-- Mathlib/Geometry/RingedSpace/Stalks.lean
theorem restrictStalkIso_inv_eq_ofRestrict {U : TopCat} (X : PresheafedSpace.{_, _, v} C)
    {f : U ⟶ (X : TopCat.{v})} (h : OpenEmbedding f) (x : U) :
    (X.restrictStalkIso h x).inv = (X.ofRestrict h).stalkMap x
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- All generalized eigenvalues are eigenvalues. -/
theorem hasEigenvalue_of_hasGenEigenvalue {f : End R M} {μ : R} {k : ℕ}
    (hμ : f.HasGenEigenvalue μ k) : f.HasEigenvalue μ
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.not_iff_comm [Decidable a] [Decidable b] : (¬a ↔ b) ↔ (¬b ↔ a)
-- Mathlib/Data/Nat/Defs.lean
lemma mul_left_eq_self_iff (hb : 0 < b) : a * b = b ↔ a = 1
-- Mathlib/Algebra/Ring/Semiconj.lean
theorem neg_one_left (x : R) : SemiconjBy (-1) x x
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivAt.add (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x) :
    HasDerivAt (fun x => f x + g x) (f' + g') x
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
lemma nil_iff_support_eq {p : G.Walk v w} : p.Nil ↔ p.support = [v]
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem negOfNat_eq_subNatNat_zero (n) : negOfNat n = subNatNat 0 n
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem range_le_ker_iff (f : G →* G') (g : G' →* G'') : f.range ≤ g.ker ↔ g.comp f = 1
-- Mathlib/CategoryTheory/Limits/Constructions/BinaryProducts.lean
/-- Any category with pushouts and initial object has binary coproducts. -/
theorem hasBinaryCoproducts_of_hasInitial_and_pushouts [HasInitial C] [HasPushouts C] :
    HasBinaryCoproducts C
-- Mathlib/Order/BoundedOrder.lean
theorem Ne.bot_lt (h : a ≠ ⊥) : ⊥ < a
-- Mathlib/Topology/Inseparable.lean
theorem inducing_mk : Inducing (mk : X → SeparationQuotient X)
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBoundedUnder.mono_ge [Preorder β] {l : Filter α} {u v : α → β}
    (hu : IsBoundedUnder (· ≥ ·) l u) (hv : u ≤ᶠ[l] v) : IsBoundedUnder (· ≥ ·) l v
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem List.trop_sum [AddMonoid R] (l : List R) : trop l.sum = List.prod (l.map trop)
-- Mathlib/ModelTheory/Syntax.lean
@[simp]
theorem onFormula_apply (φ : L ≃ᴸ L') :
    (φ.onFormula : L.Formula α → L'.Formula α) = φ.toLHom.onFormula
-- Mathlib/Algebra/Group/Opposite.lean
@[simp]
theorem unop_pow {β} [Pow α β] (a : αᵃᵒᵖ) (b : β) : unop (a ^ b) = unop a ^ b
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem iInf₂ {κ : Sort*} {κ' : κ → Sort*} {f : ∀ i, κ' i → Ideal A}
    (h : ∀ i j, (f i j).IsHomogeneous 𝒜) : (⨅ (i) (j), f i j).IsHomogeneous 𝒜
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[fun_prop]
theorem ContinuousOn.div₀ (hf : ContinuousOn f s) (hg : ContinuousOn g s) (h₀ : ∀ x ∈ s, g x ≠ 0) :
    ContinuousOn (fun x => f x / g x) s
-- Mathlib/CategoryTheory/Endofunctor/Algebra.lean
/-- A composition of natural transformations gives the composition of corresponding functors. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def functorOfNatTransComp {F₀ F₁ F₂ : C ⥤ C} (α : F₀ ⟶ F₁) (β : F₁ ⟶ F₂) :
    functorOfNatTrans (α ≫ β) ≅ functorOfNatTrans α ⋙ functorOfNatTrans β
-- Mathlib/CategoryTheory/Comma/Basic.lean
/-- The functor sending an object `X` in the comma category to `X.right`. -/
@[simps]
def snd : Comma L R ⥤ B
-- Mathlib/Analysis/Calculus/LineDeriv/QuadraticMap.lean
@[simp]
protected theorem lineDeriv (f : QuadraticMap 𝕜 E F) : lineDeriv 𝕜 f = polar f
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem card_smul_finset (a : α) (s : Finset β) : (a • s).card = s.card
-- Mathlib/RepresentationTheory/Basic.lean
@[simp]
theorem tprod_apply (g : G) : (ρV ⊗ ρW) g = TensorProduct.map (ρV g) (ρW g)
-- Mathlib/Data/PNat/Interval.lean
theorem map_subtype_embedding_uIcc : (uIcc a b).map (Embedding.subtype _) = uIcc ↑a ↑b
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_inj [AddMonoidWithOne α] [CharZero α] {m n : PosNum} : (m : α) = n ↔ m = n
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem mul_assoc : ∀ (n m k : Nat), (n * m) * k = n * (m * k)
-- Mathlib/Algebra/MvPolynomial/Derivation.lean
@[ext]
theorem derivation_ext {D₁ D₂ : Derivation R (MvPolynomial σ R) A} (h : ∀ i, D₁ (X i) = D₂ (X i)) :
    D₁ = D₂
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiag_blockDiagonal [DecidableEq o] (M : o → Matrix m n α) :
    blockDiag (blockDiagonal M) = M
-- Mathlib/Data/Int/Defs.lean
lemma ediv_of_neg_of_pos {a b : ℤ} (Ha : a < 0) (Hb : 0 < b) : ediv a b = -((-a - 1) / b + 1)
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- In the characteristic zero case, the weights in the centroid sum
to 1 if the number of points is not zero. -/
theorem sum_centroidWeights_eq_one_of_card_ne_zero [CharZero k] (h : card s ≠ 0) :
    ∑ i ∈ s, s.centroidWeights k i = 1
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
/-- A map `f : α → β` between uniform spaces is called *uniform inducing* if the uniformity filter
on `α` is the pullback of the uniformity filter on `β` under `Prod.map f f`. If `α` is a separated
space, then this implies that `f` is injective, hence it is a `UniformEmbedding`. -/
@[mk_iff]
structure UniformInducing (f : α → β) : Prop where
  /-- The uniformity filter on the domain is the pullback of the uniformity filter on the codomain
  under `Prod.map f f`. -/
  comap_uniformity : comap (fun x : α × α => (f x.1, f x.2)) (𝓤 β) = 𝓤 α
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive]
protected theorem mul_smul (x y : R[S⁻¹]) (z : X[S⁻¹]) : (x * y) • z = x • y • z
-- Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean
theorem exists_nat_measurableEquiv_range_coe_fin_of_finite [Finite α] :
    ∃ n : ℕ, Nonempty (α ≃ᵐ range ((↑) : Fin n → ℝ))
-- Mathlib/ModelTheory/Types.lean
theorem exists_modelType_is_realized_in (p : T.CompleteType α) :
    ∃ M : Theory.ModelType.{u, v, max u v w} T, p ∈ T.realizedTypes M α
-- Mathlib/GroupTheory/Perm/Support.lean
theorem Disjoint.mem_imp (h : Disjoint f g) {x : α} (hx : x ∈ f.support) : x ∉ g.support
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- Various statements equivalent to the fact that `f n` grows exponentially slower than `R ^ n`.

* 0: $f n = o(a ^ n)$ for some $-R < a < R$;
* 1: $f n = o(a ^ n)$ for some $0 < a < R$;
* 2: $f n = O(a ^ n)$ for some $-R < a < R$;
* 3: $f n = O(a ^ n)$ for some $0 < a < R$;
* 4: there exist `a < R` and `C` such that one of `C` and `R` is positive and $|f n| ≤ Ca^n$
     for all `n`;
* 5: there exists `0 < a < R` and a positive `C` such that $|f n| ≤ Ca^n$ for all `n`;
* 6: there exists `a < R` such that $|f n| ≤ a ^ n$ for sufficiently large `n`;
* 7: there exists `0 < a < R` such that $|f n| ≤ a ^ n$ for sufficiently large `n`.

NB: For backwards compatibility, if you add more items to the list, please append them at the end of
the list. -/
theorem TFAE_exists_lt_isLittleO_pow (f : ℕ → ℝ) (R : ℝ) :
    TFAE
      [∃ a ∈ Ioo (-R) R, f =o[atTop] (a ^ ·), ∃ a ∈ Ioo 0 R, f =o[atTop] (a ^ ·),
        ∃ a ∈ Ioo (-R) R, f =O[atTop] (a ^ ·), ∃ a ∈ Ioo 0 R, f =O[atTop] (a ^ ·),
        ∃ a < R, ∃ C : ℝ, (0 < C ∨ 0 < R) ∧ ∀ n, |f n| ≤ C * a ^ n,
        ∃ a ∈ Ioo 0 R, ∃ C > 0, ∀ n, |f n| ≤ C * a ^ n, ∃ a < R, ∀ᶠ n in atTop, |f n| ≤ a ^ n,
        ∃ a ∈ Ioo 0 R, ∀ᶠ n in atTop, |f n| ≤ a ^ n]
-- Mathlib/LinearAlgebra/Basis.lean
/--
Over any nontrivial ring, the existence of a finite spanning set implies that any basis is finite.
-/
lemma basis_finite_of_finite_spans (w : Set M) (hw : w.Finite) (s : span R w = ⊤) {ι : Type w}
    (b : Basis ι R M) : Finite ι
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_le_one [ZeroLEOneClass α] [PosMulMono α] [MulPosMono α]
    (ha : a ≤ 1) (hb' : 0 ≤ b) (hb : b ≤ 1) : a * b ≤ 1
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
@[simp]
theorem mk_mem_carrier (z : HomogeneousLocalization.NumDenSameDeg 𝒜 (.powers f)) :
    HomogeneousLocalization.mk z ∈ carrier x ↔ z.num.1 ∈ x.1.asHomogeneousIdeal
-- Mathlib/Data/Real/EReal.lean
@[simp] theorem neg_lt_neg_iff {a b : EReal} : -a < -b ↔ b < a
-- Mathlib/Algebra/AddTorsor.lean
/-- Cancellation adding the results of two subtractions. -/
@[simp]
theorem vsub_add_vsub_cancel (p₁ p₂ p₃ : P) : p₁ -ᵥ p₂ + (p₂ -ᵥ p₃) = p₁ -ᵥ p₃
-- Mathlib/Data/Set/NAry.lean
theorem image2_singleton : image2 f {a} {b} = {f a b}
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_add_measure {m : MeasurableSpace α} (μ ν : Measure α) (f : α → ℝ≥0∞) :
    (μ + ν).withDensity f = μ.withDensity f + ν.withDensity f
-- Mathlib/Algebra/GroupWithZero/Hom.lean
protected lemma map_mul (f : α →*₀ β) (a b : α) : f (a * b) = f a * f b
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
/-- An equivalence of categories `e` between `C` and `D` induces an equivalence between
    `MonoOver X` and `MonoOver (e.functor.obj X)` whenever `X` is an object of `C`. -/
@[simps]
def congr (e : C ≌ D) : MonoOver X ≌ MonoOver (e.functor.obj X)
-- Mathlib/Algebra/Algebra/Prod.lean
@[simp]
theorem prod_fst_snd : prod (fst R A B) (snd R A B) = 1
-- Mathlib/Order/SuccPred/Basic.lean
theorem Ioc_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioc (pred a) b = Icc a b
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp] lemma basisOf_vadd (v : V) (b : AffineBasis ι k P) : (v +ᵥ b).basisOf = b.basisOf
-- Mathlib/Topology/Algebra/MulAction.lean
/-- An `AddTorsor` for a connected space is a connected space. This is not an instance because
it loops for a group as a torsor over itself. -/
protected theorem AddTorsor.connectedSpace : ConnectedSpace P
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.toLin_finTwoProd (a b c d : R) :
    Matrix.toLin (Basis.finTwoProd R) (Basis.finTwoProd R) !![a, b; c, d] =
      (a • LinearMap.fst R R R + b • LinearMap.snd R R R).prod
        (c • LinearMap.fst R R R + d • LinearMap.snd R R R)
-- Mathlib/Testing/SlimCheck/Functions.lean
theorem applyId_injective [DecidableEq α] {xs ys : List α} (h₀ : List.Nodup xs) (h₁ : xs ~ ys) :
    Injective.{u + 1, u + 1} (List.applyId (xs.zip ys))
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma natDegree_polynomial [Nontrivial R] : W.polynomial.natDegree = 2
-- Mathlib/SetTheory/Game/Basic.lean
/-- A small family of games is bounded below. -/
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → Game.{u}) :
    BddBelow (Set.range f)
-- Mathlib/Data/Finset/Card.lean
theorem Multiset.toFinset_card_eq_card_iff_nodup {m : Multiset α} :
    m.toFinset.card = card m ↔ m.Nodup
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem TopologicalGroup.tendstoUniformly_iff {ι α : Type*} (F : ι → α → G) (f : α → G)
    (p : Filter ι) :
    @TendstoUniformly α G ι (TopologicalGroup.toUniformSpace G) F f p ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a, F i a / f a ∈ u
-- Mathlib/Analysis/Normed/Module/Ray.lean
theorem not_sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : ¬SameRay ℝ x y ↔ x ≠ y
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@[simp]
theorem cramer_one : cramer (1 : Matrix n n α) = 1
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_lt_top (a : α) : pred a < ⊤
-- Mathlib/Data/List/Nodup.lean
theorem nodup_iff_get?_ne_get? {l : List α} :
    l.Nodup ↔ ∀ i j : ℕ, i < j → j < l.length → l.get? i ≠ l.get? j
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem DFinsupp.toFinsupp_coe (f : Π₀ _ : ι, M) : ⇑f.toFinsupp = f
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem lineMap_eq_lineMap_iff [NoZeroSMulDivisors k V1] {p₀ p₁ : P1} {c₁ c₂ : k} :
    lineMap p₀ p₁ c₁ = lineMap p₀ p₁ c₂ ↔ p₀ = p₁ ∨ c₁ = c₂
-- Mathlib/FieldTheory/Adjoin.lean
theorem _root_.minpoly.natDegree_le (x : L) [FiniteDimensional K L] :
    (minpoly K x).natDegree ≤ finrank K L
-- Mathlib/CategoryTheory/Limits/Elements.lean
@[simp]
lemma map_lift_mapCone (c : Cone F) :
    A.map (limit.lift (F ⋙ π A) ((π A).mapCone c)) c.pt.snd = liftedConeElement F