ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Matrix/Block.lean
theorem blockDiagonal'_apply_ne (M : ∀ i, Matrix (m' i) (n' i) α) {k k'} (i j) (h : k ≠ k') :
    blockDiagonal' M ⟨k, i⟩ ⟨k', j⟩ = 0
-- Mathlib/Order/Monotone/Basic.lean
@[simp]
theorem antitone_toDual_comp_iff : Antitone (toDual ∘ f : α → βᵒᵈ) ↔ Monotone f
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_lt_one (h : ∀ i ∈ s, f i < 1) (hs : s.Nonempty) : ∏ i ∈ s, f i < 1
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem coe_zeta_mul_coe_moebius [Ring R] : (ζ * μ : ArithmeticFunction R) = 1
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp] lemma zero_ceilDiv (a : α) : (0 : β) ⌈/⌉ a = 0
-- Mathlib/Probability/ConditionalProbability.lean
/-- **Bayes' Theorem** -/
theorem cond_eq_inv_mul_cond_mul [IsFiniteMeasure μ]
    (hms : MeasurableSet s) (hmt : MeasurableSet t) : μ[t|s] = (μ s)⁻¹ * μ[s|t] * μ t
-- Mathlib/CategoryTheory/EqToHom.lean
theorem congr_inv_of_congr_hom (F G : C ⥤ D) {X Y : C} (e : X ≅ Y) (hX : F.obj X = G.obj X)
    (hY : F.obj Y = G.obj Y)
    (h₂ : F.map e.hom = eqToHom (by rw [hX]) ≫ G.map e.hom ≫ eqToHom (by rw [hY])) :
    F.map e.inv = eqToHom (by rw [hY]) ≫ G.map e.inv ≫ eqToHom (by rw [hX])
-- Mathlib/Order/CompleteLattice.lean
lemma iInf_prod' (f : β → γ → α) : (⨅ i, ⨅ j, f i j) = ⨅ x : β × γ, f x.1 x.2
-- Mathlib/Logic/Encodable/Basic.lean
@[ext]
protected theorem ext {a b : ULower α} : a.up = b.up → a = b
-- Mathlib/Algebra/Module/Submodule/Bilinear.lean
@[mono]
theorem map₂_le_map₂ {f : M →ₗ[R] N →ₗ[R] P} {p₁ p₂ : Submodule R M} {q₁ q₂ : Submodule R N}
    (hp : p₁ ≤ p₂) (hq : q₁ ≤ q₂) : map₂ f p₁ q₁ ≤ map₂ f p₂ q₂
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem SuperpolynomialDecay.param_inv_mul (hk : Tendsto k l atTop)
    (hf : SuperpolynomialDecay l k f) : SuperpolynomialDecay l k (f * k⁻¹)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffOn_id {s} : ContDiffOn 𝕜 n (id : E → E) s
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
@[simp]
theorem wittPolynomial_zero : wittPolynomial p R 0 = X 0
-- Mathlib/Data/List/AList.lean
@[simp]
theorem mem_union {a} {s₁ s₂ : AList β} : a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ ∨ a ∈ s₂
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
@[simp]
theorem adjointAux_apply (A : E →L[𝕜] F) (x : F) :
    adjointAux A x = ((toDual 𝕜 E).symm : NormedSpace.Dual 𝕜 E → E) ((toSesqForm A) x)
-- Mathlib/Order/LiminfLimsup.lean
theorem _root_.Antitone.isBoundedUnder_ge_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Antitone v) (hl : l.IsBoundedUnder (· ≤ ·) u) :
    l.IsBoundedUnder (· ≥ ·) (v ∘ u)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[simp] theorem Prod.map_apply (f : α → β) (g : γ → δ) (x) (y) :
    Prod.map f g (x, y) = (f x, g y)
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp]
theorem card_eq_top_of_infinite [Infinite α] : card α = ⊤
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_limit {o} (h : IsLimit o) {a} : a < o ↔ ∃ x < o, a < x
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem mk'_apply (x : G) : mk' N x = x
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalExtrOn.isLocalExtr (hf : IsLocalExtrOn f s a) (hs : s ∈ 𝓝 a) : IsLocalExtr f a
-- Mathlib/Logic/Equiv/Set.lean
/-- If `α` is equivalent to `β`, then `Set α` is equivalent to `Set β`. -/
@[simps]
protected def congr {α β : Type*} (e : α ≃ β) : Set α ≃ Set β
-- Mathlib/Algebra/CharZero/Defs.lean
@[simp] lemma ofNat_ne_one (n : ℕ) [n.AtLeastTwo] : (no_index (ofNat n) : R) ≠ 1
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem gcd_dedup (s : Multiset α) : (dedup s).gcd = s.gcd
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma sUnion_diffFinset (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
    ⋃₀ hC.diffFinset hs ht = s \ t
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem equivCongr_apply_apply {δ} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x) :
    ab.equivCongr cd e x = cd (e (ab.symm x))
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma cpow_inv_two_im_eq_sqrt {x : ℂ} (hx : 0 ≤ x.im) :
    (x ^ (2⁻¹ : ℂ)).im = sqrt ((abs x - x.re) / 2)
-- Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean
@[reassoc]
lemma triangleMapOfHomotopy_comm₃ :
    mapOfHomotopy H ≫ (triangle φ₂).mor₃ = (triangle φ₁).mor₃ ≫ a⟦1⟧'
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma intCast_mul_left (h : Commute a b) (m : ℤ) : Commute (m  * a) b
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the spans of two vectors are equal, twice angles with those vectors on the left are
equal. -/
theorem two_zsmul_oangle_left_of_span_eq {x y : V} (z : V) (h : (ℝ ∙ x) = ℝ ∙ y) :
    (2 : ℤ) • o.oangle x z = (2 : ℤ) • o.oangle y z
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem map_add (f : A →ₑ+[φ] B) (x y : A) : f (x + y) = f x + f y
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- The number of square roots of `a` modulo `p` is determined by the Legendre symbol. -/
theorem card_sqrts (hp : p ≠ 2) (a : ℤ) :
    ↑{x : ZMod p | x ^ 2 = a}.toFinset.card = legendreSym p a + 1
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
@[simp]
theorem center_zero (z : ℍ) : center z 0 = z
-- Mathlib/Analysis/Convolution.lean
theorem smul_convolution [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : y • f ⋆[L, μ] g = y • (f ⋆[L, μ] g)
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma coe_corootSpace_eq_span_singleton (α : Weight K H L) :
    (corootSpace α).toSubmodule = K ∙ coroot α
-- Mathlib/Order/Hom/Order.lean
@[simp] lemma coe_sup [SemilatticeSup β] (f g : α →o β) :
  ((f ⊔ g : α →o β) : α → β) = (f : α → β) ⊔ g
-- Mathlib/Topology/Sets/Closeds.lean
/-- The closure of a set, as an element of `TopologicalSpace.Closeds`. -/
@[simps]
protected def closure (s : Set α) : Closeds α
-- Mathlib/Computability/TMToPartrec.lean
theorem supports_insert {K S q} :
    Supports (insert q K) S ↔ TM2.SupportsStmt S (tr q) ∧ Supports K S
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem sum_integral_adjacent_intervals_Ico {a : ℕ → ℝ} {m n : ℕ} (hmn : m ≤ n)
    (hint : ∀ k ∈ Ico m n, IntervalIntegrable f μ (a k) (a <| k + 1)) :
    ∑ k ∈ Finset.Ico m n, ∫ x in a k..a <| k + 1, f x ∂μ = ∫ x in a m..a n, f x ∂μ
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
lemma leftHomologyMap_congr (h : Homotopy φ₁ φ₂) [S₁.HasLeftHomology] [S₂.HasLeftHomology] :
    leftHomologyMap φ₁ = leftHomologyMap φ₂
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem norm_expSeries_div_summable_of_mem_ball (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    Summable fun n => ‖x ^ n / (n ! : 𝔸)‖
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
protected theorem HasFDerivAtFilter.snd (h : HasFDerivAtFilter f₂ f₂' x L) :
    HasFDerivAtFilter (fun x => (f₂ x).2) ((snd 𝕜 F G).comp f₂') x L
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem eqOn_empty (f₁ f₂ : α → β) : EqOn f₁ f₂ ∅
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem reverse_replicate (n) (a : α) : reverse (replicate n a) = replicate n a
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem apply_le_nfpBFamily (ho : o ≠ 0) (H : ∀ i hi, IsNormal (f i hi)) {a b} :
    (∀ i hi, f i hi b ≤ nfpBFamily.{u, v} o f a) ↔ b ≤ nfpBFamily.{u, v} o f a
-- Mathlib/AlgebraicGeometry/Morphisms/Affine.lean
lemma isAffine_of_isAffineHom [IsAffineHom f] [IsAffine Y] : IsAffine X
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.congr (hf : ConcaveOn 𝕜 s f) (hfg : EqOn f g s) : ConcaveOn 𝕜 s g
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_eq_add_one_sub_fract (ha : fract a ≠ 0) : (⌈a⌉ : α) = a + 1 - fract a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem pred_lt_self : ∀ {a}, 0 < a → pred a < a
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem SmoothManifoldWithCorners.mk' {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) (M : Type*) [TopologicalSpace M] [ChartedSpace H M]
    [gr : HasGroupoid M (contDiffGroupoid ∞ I)] : SmoothManifoldWithCorners I M
-- Mathlib/Data/Set/Countable.lean
theorem countable_isTop (α : Type*) [PartialOrder α] : { x : α | IsTop x }.Countable
-- Mathlib/Data/Fintype/Card.lean
/-- The pigeonhole principle for infinitely many pigeons in finitely many pigeonholes. If there are
infinitely many pigeons in finitely many pigeonholes, then there are at least two pigeons in the
same pigeonhole.

See also: `Fintype.exists_ne_map_eq_of_card_lt`, `Finite.exists_infinite_fiber`.
-/
theorem Finite.exists_ne_map_eq_of_infinite {α β} [Infinite α] [Finite β] (f : α → β) :
    ∃ x y : α, x ≠ y ∧ f x = f y
-- Mathlib/Data/Finset/Lattice.lean
theorem subset_set_biUnion_of_mem {s : Finset α} {f : α → Set β} {x : α} (h : x ∈ s) :
    f x ⊆ ⋃ y ∈ s, f y
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- The `sInf` of a union of two sets is the min of the infima of each subset, under the assumptions
that all sets are bounded below and nonempty. -/
theorem csInf_union (hs : BddBelow s) (sne : s.Nonempty) (ht : BddBelow t) (tne : t.Nonempty) :
    sInf (s ∪ t) = sInf s ⊓ sInf t
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem map_spec (as : Array α) (f : α → β) (p : Fin as.size → β → Prop)
    (hs : ∀ i, p i (f as[i])) :
    ∃ eq : (as.map f).size = as.size, ∀ i h, p ⟨i, h⟩ ((as.map f)[i])
-- Mathlib/Order/BooleanAlgebra.lean
theorem compl_surjective : Function.Surjective (compl : α → α)
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem isLUB_lowerBounds : IsLUB (lowerBounds s) a ↔ IsGLB s a
-- Mathlib/MeasureTheory/Group/GeometryOfNumbers.lean
/-- The **Minkowski Convex Body Theorem for compact domain**. If `s` is a convex compact symmetric
domain of `E` whose volume is large enough compared to the covolume of a lattice `L` of `E`, then it
contains a non-zero lattice point of `L`. Compared to
`exists_ne_zero_mem_lattice_of_measure_mul_two_pow_lt_measure`, this version requires in addition
that `s` is compact and `L` is discrete but provides a weaker inequality rather than a strict
inequality. -/
theorem exists_ne_zero_mem_lattice_of_measure_mul_two_pow_le_measure [NormedAddCommGroup E]
    [NormedSpace ℝ E] [BorelSpace E] [FiniteDimensional ℝ E] [Nontrivial E] [IsAddHaarMeasure μ]
    {L : AddSubgroup E} [Countable L] [DiscreteTopology L] (fund : IsAddFundamentalDomain L F μ)
    (h_symm : ∀ x ∈ s, -x ∈ s) (h_conv : Convex ℝ s) (h_cpt : IsCompact s)
    (h : μ F * 2 ^ finrank ℝ E ≤ μ s) :
    ∃ x ≠ 0, ((x : L) : E) ∈ s
-- Mathlib/Data/DFinsupp/Basic.lean
theorem mk_of_mem (hi : i ∈ s) : (mk s x : ∀ i, β i) i = x ⟨i, hi⟩
-- Mathlib/Init/Algebra/Classes.lean
@[elab_without_expected_type]
theorem asymm_of [IsAsymm α r] {a b : α} : a ≺ b → ¬b ≺ a
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
theorem hasFDerivAt_exp_smul_const_of_mem_ball' (x : 𝔸) (t : 𝕊)
    (htx : t • x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    HasFDerivAt (fun u : 𝕊 => exp 𝕂 (u • x))
      (((1 : 𝕊 →L[𝕂] 𝕊).smulRight x).smulRight (exp 𝕂 (t • x))) t
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
@[refl]
theorem refl (f : Ω^ N X x) : Homotopic f f
-- Mathlib/Algebra/DirectLimit.lean
/-- A component that corresponds to zero in the direct limit is already zero in some
bigger module in the directed system. -/
theorem of.zero_exact [IsDirected ι (· ≤ ·)] [DirectedSystem G fun i j h => f i j h] (i x)
    (h : of G f i x = 0) : ∃ j hij, f i j hij x = 0
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.fin_insertNth {n} {π : Fin (n + 1) → Type*}
    [∀ i, TopologicalSpace (π i)] (i : Fin (n + 1)) {f : α → π i} {a : α} {s : Set α}
    (hf : ContinuousWithinAt f s a) {g : α → ∀ j : Fin n, π (i.succAbove j)}
    (hg : ContinuousWithinAt g s a) : ContinuousWithinAt (fun a => i.insertNth (f a) (g a)) s a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem zero_pow {n : Nat} (H : 0 < n) : 0 ^ n = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem sub_lt_add_one (a b) : a - b < a + 1
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem comap_comap (s : Subsemiring T) (g : S →+* T) (f : R →+* S) :
    (s.comap g).comap f = s.comap (g.comp f)
-- Mathlib/GroupTheory/GroupAction/BigOperators.lean
theorem Finset.smul_prod {r : α} {f : γ → β} {s : Finset γ} :
    (r • ∏ x ∈ s, f x) = ∏ x ∈ s, r • f x
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem coe_rTensorHom : (rTensorHom M : (N →ₗ[R] P) → N ⊗[R] M →ₗ[R] P ⊗[R] M) = rTensor M
-- Mathlib/Algebra/Order/Group/Basic.lean
/-- Alias of `zpow_left_inj`, for ease of discovery alongside `zsmul_le_zsmul_iff'` and
`zsmul_lt_zsmul_iff'`. -/
@[to_additive "Alias of `zsmul_right_inj`, for ease of discovery alongside `zsmul_le_zsmul_iff'` and
`zsmul_lt_zsmul_iff'`."]
lemma zpow_eq_zpow_iff' (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq {m : MeasurableSpace α} (μ : Measure α) (f : α →ₛ F) :
    f.integral μ = ∑ x ∈ f.range, (μ (f ⁻¹' {x})).toReal • x
-- Mathlib/Data/Matroid/Sum.lean
@[simp] lemma disjointSum_indep_iff {h I} :
    (M.disjointSum N h).Indep I ↔ M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem mem_skewAdjointMatricesSubmodule :
    A₁ ∈ skewAdjointMatricesSubmodule J ↔ J.IsSkewAdjoint A₁
-- Mathlib/Data/Matroid/Sum.lean
@[simp] lemma sigma_ground_eq : (Matroid.sigma M).E = univ.sigma fun i ↦ (M i).E
-- Mathlib/Computability/Partrec.lean
theorem rfind {p : α → ℕ →. Bool} (hp : Partrec₂ p) : Partrec fun a => Nat.rfind (p a)
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**, strict differentiability at filter in both endpoints.

If `f` is a measurable function integrable on `a..b`, `(la, la')` is an `intervalIntegral.FTCFilter`
pair around `a`, and `f` has a finite limit `c` almost surely at `la'`, then
`(∫ x in v..b, f x) - ∫ x in u..b, f x = -(v - u) • c + o(‖v - u‖)` as `u` and `v` tend to `la`.

This lemma could've been formulated using `HasStrictDerivAtFilter` if we had this definition. -/
theorem integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left
    (hab : IntervalIntegrable f volume a b) (hmeas : StronglyMeasurableAtFilter f la')
    (hf : Tendsto f (la' ⊓ ae volume) (𝓝 c)) (hu : Tendsto u lt la) (hv : Tendsto v lt la) :
    (fun t => ((∫ x in v t..b, f x) - ∫ x in u t..b, f x) + (v t - u t) • c) =o[lt] (v - u)
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
/-- The monoidal structure coming from finite coproducts is symmetric.
-/
@[simps]
def symmetricOfHasFiniteCoproducts [HasInitial C] [HasBinaryCoproducts C] :
    SymmetricCategory C
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_X_pow : degree ((X : R[X]) ^ n) = n
-- Mathlib/Data/Real/Basic.lean
@[simp]
theorem mk_pos {f : CauSeq ℚ abs} : 0 < mk f ↔ Pos f
-- Mathlib/Condensed/Light/TopComparison.lean
/--
`TopCat.toLightCondSet` yields a functor from `TopCat.{u}` to `LightCondSet.{u}`.
-/
@[simps]
noncomputable def topCatToLightCondSet : TopCat.{u} ⥤ LightCondSet.{u}
-- Mathlib/Topology/LocallyConstant/Algebra.lean
theorem charFn_eq_one [Nontrivial Y] (x : X) (hU : IsClopen U) : charFn Y hU x = (1 : Y) ↔ x ∈ U
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_iff_not_smul_mem_span :
    LinearIndependent R v ↔ ∀ (i : ι) (a : R), a • v i ∈ span R (v '' (univ \ {i})) → a = 0
-- Mathlib/CategoryTheory/Category/Cat.lean
@[simp]
theorem comp_obj {C D E : Cat} (F : C ⟶ D) (G : D ⟶ E) (X : C) : (F ≫ G).obj X = G.obj (F.obj X)
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem degree_of_zero : (0 : Cubic R).toPoly.degree = ⊥
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csInf_Ioc [DenselyOrdered α] (h : a < b) : sInf (Ioc a b) = a
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem X_dvd_iff {s : σ} {φ : MvPowerSeries σ R} :
    (X s : MvPowerSeries σ R) ∣ φ ↔ ∀ m : σ →₀ ℕ, m s = 0 → coeff R m φ = 0
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem diff_singleton_eq_self {a : α} {s : Set α} (h : a ∉ s) : s \ {a} = s
-- Mathlib/Order/RelIso/Basic.lean
/-- The map `coe_fn : (r ↪r s) → (α → β)` is injective. -/
theorem coe_fn_injective : Injective fun f : r ↪r s => (f : α → β)
-- Mathlib/RingTheory/Idempotents.lean
/-- A family of orthogonal idempotents lift along nil ideals. -/
lemma OrthogonalIdempotents.lift_of_isNilpotent_ker [Finite I]
    (h : ∀ x ∈ RingHom.ker f, IsNilpotent x)
    {e : I → S} (he : OrthogonalIdempotents e) (he' : ∀ i, e i ∈ f.range) :
    ∃ e' : I → R, OrthogonalIdempotents e' ∧ f ∘ e' = e
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem w_def (D : ℝ) :
    (w D : E → ℝ) = fun x => ((∫ x : E, u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)
-- Mathlib/CategoryTheory/PEmpty.lean
/-- Any two functors out of the empty category are *equal*. You probably want to use
`emptyExt` instead of this.
-/
theorem empty_ext' (F G : Discrete.{w} PEmpty ⥤ C) : F = G
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
@[simp]
theorem uniformity_toTopologicalSpace_eq [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    (UniformConvergenceCLM.instUniformSpace σ F 𝔖).toTopologicalSpace =
      UniformConvergenceCLM.instTopologicalSpace σ F 𝔖
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem rightAngleRotationAux₁_rightAngleRotationAux₁ (x : E) :
    o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x) = -x
-- Mathlib/Algebra/Star/StarRingHom.lean
theorem one_apply (a : A) : (1 : A →⋆ₙ+* A) a = a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[local simp]
private theorem one_div_two : 1/2 = 0
-- Mathlib/Order/Filter/Lift.lean
theorem lift_lift'_same_le_lift' {g : Set α → Set α → Set β} :
    (f.lift fun s => f.lift' (g s)) ≤ f.lift' fun s => g s s
-- Mathlib/Probability/Independence/Kernel.lean
theorem indep_bot_right (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ] :
    Indep m' ⊥ κ μ
-- Mathlib/Algebra/CharZero/Defs.lean
@[simp] lemma ofNat_ne_zero (n : ℕ) [n.AtLeastTwo] : (no_index (ofNat n) : R) ≠ 0
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
theorem map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
    map I g ∘ₗ map I f = map I (g ∘ₗ f)
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem fract_eq_fract (m n : E) : fract b m = fract b n ↔ -m + n ∈ span ℤ (Set.range b)
-- Mathlib/SetTheory/Ordinal/Basic.lean
private theorem succ_le_iff' {a b : Ordinal} : a + 1 ≤ b ↔ a < b
-- Mathlib/Data/Set/Lattice.lean
theorem sInter_prod {S : Set (Set α)} (hS : S.Nonempty) (t : Set β) :
    ⋂₀ S ×ˢ t = ⋂ s ∈ S, s ×ˢ t
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive]
theorem update_mul [∀ i, Mul (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (i : I) (x₁ : f i)
    (x₂ : f i) : update (f₁ * f₂) i (x₁ * x₂) = update f₁ i x₁ * update f₂ i x₂
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem minkowskiBound_lt_top : minkowskiBound K I < ⊤
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem filter_sub [DecidableEq α] (s t : Multiset α) :
    filter p (s - t) = filter p s - filter p t
-- Mathlib/Order/Iterate.lean
theorem seq_lt_seq_of_le_of_lt (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
    (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n
-- Mathlib/Order/Category/FinBddDistLat.lean
/-- `OrderDual` as a functor. -/
@[simps]
def dual : FinBddDistLat ⥤ FinBddDistLat
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- For `D : J ⥤ Coalgebra T`, `D ⋙ forget T` has a limit, then `D` has a limit provided limits
of shape `J` are preserved by `T`.
-/
theorem forget_creates_limits_of_comonad_preserves [PreservesLimitsOfShape J (T : C ⥤ C)]
    (D : J ⥤ Coalgebra T) [HasLimit (D ⋙ forget T)] : HasLimit D
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp]
lemma ι_preimage_self : U.ι ⁻¹ᵁ U = ⊤
-- Mathlib/Data/List/Join.lean
/-- Reversing a join is the same as reversing the order of parts and reversing all parts. -/
theorem reverse_join (L : List (List α)) :
    L.join.reverse = (L.map reverse).reverse.join
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem all_eq_not_any_not (l : List α) (p : α → Bool) : l.all p = !l.any (!p .)
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- For every nonempty open cover of a Lindelöf set, there exists a subcover indexed by ℕ. -/
theorem IsLindelof.indexed_countable_subcover {ι : Type v} [Nonempty ι]
    (hs : IsLindelof s) (U : ι → Set X) (hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) :
    ∃ f : ℕ → ι, s ⊆ ⋃ n, U (f n)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasStrictDerivAt_const_rpow {a : ℝ} (ha : 0 < a) (x : ℝ) :
    HasStrictDerivAt (fun x => a ^ x) (a ^ x * log a) x
-- Mathlib/RingTheory/ClassGroup.lean
/-- Induction principle for the class group: to show something holds for all `x : ClassGroup R`,
we can choose a fraction field `K` and show it holds for the equivalence class of each
`I : FractionalIdeal R⁰ K`. -/
@[elab_as_elim]
theorem ClassGroup.induction {P : ClassGroup R → Prop}
    (h : ∀ I : (FractionalIdeal R⁰ K)ˣ, P (ClassGroup.mk I)) (x : ClassGroup R) : P x
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
@[simp]
lemma equivPolynomialSelf_apply_eq (p : PolynomialModule R R) :
    equivPolynomialSelf p = equivPolynomial p
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive (attr := simp)]
theorem unop_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    unop (no_index (OfNat.ofNat n : αᵐᵒᵖ)) = OfNat.ofNat n
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem mem_twoCocycles_def (f : G × G → A) :
    f ∈ twoCocycles A ↔ ∀ g h j : G,
      A.ρ g (f (h, j)) - f (g * h, j) + f (g, h * j) - f (g, h) = 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem OrthogonalFamily.orthonormal_sigma_orthonormal {α : ι → Type*} {v_family : ∀ i, α i → G i}
    (hv_family : ∀ i, Orthonormal 𝕜 (v_family i)) :
    Orthonormal 𝕜 fun a : Σi, α i => V a.1 (v_family a.1 a.2)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem limit_le {o} (h : IsLimit o) {a} : o ≤ a ↔ ∀ x < o, x ≤ a
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem map_target {x : β} (h : x ∈ e.target) : e.symm x ∈ e.source
-- Mathlib/Geometry/RingedSpace/SheafedSpace.lean
theorem mk_coe (carrier) (presheaf) (h) :
    (({ carrier
        presheaf
        IsSheaf := h } : SheafedSpace C) : TopCat) = carrier
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasStrictDerivAt.mul (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :
    HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x
-- Mathlib/Data/Fin/Basic.lean
/--
The `Fin.castSucc_eq_zero_iff` in `Lean` only applies in `Fin (n+1)`.
This one instead uses a `NeZero n` typeclass hypothesis.
-/
@[simp]
theorem castSucc_eq_zero_iff' [NeZero n] (a : Fin n) : castSucc a = 0 ↔ a = 0
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem measure_pos_of_mem_nhds (h : s ∈ 𝓝 x) : 0 < μ s
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem sqrt_normSq_eq_norm (x : F) : √(normSqF x) = ‖x‖
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
/-- This class assumes that the map `β × γ → β` given by `(x, y) ↦ x ^ y` is measurable. -/
class MeasurablePow (β γ : Type*) [MeasurableSpace β] [MeasurableSpace γ] [Pow β γ] : Prop where
  measurable_pow : Measurable fun p : β × γ => p.1 ^ p.2
-- Mathlib/SetTheory/Game/PGame.lean
@[simp] theorem Subsequent.moveLeft_mk_right {xL : xl → PGame} {i : xr} (xR : xr → PGame) (j) :
    Subsequent ((xR i).moveLeft j) (mk xl xr xL xR)
-- Mathlib/Algebra/Polynomial/DenomsClearable.lean
theorem denomsClearable_zero (N : ℕ) (a : R) (bu : bi * i b = 1) : DenomsClearable a b N 0 i
-- Mathlib/Data/Complex/Exponential.lean
theorem abs_sin_le_one : |sin x| ≤ 1
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`perfectClosure F K` if and only if `x` is contained in `perfectClosure F E`. -/
theorem map_mem_perfectClosure_iff (i : E →ₐ[F] K) {x : E} :
    i x ∈ perfectClosure F K ↔ x ∈ perfectClosure F E
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
@[simp]
theorem modOf_apply_add_self (x : k[G]) (g : G) (d : G) : (x %ᵒᶠ g) (d + g) = 0