ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Sites/PreservesSheafification.lean
/-- The canonical isomorphism between `presheafToSheaf J A ⋙ Sheaf.composeAndSheafify J F`
and `(whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B` when `F : A ⥤ B`
preserves sheafification. -/
@[simps! inv_app]
noncomputable def presheafToSheafCompComposeAndSheafifyIso :
    presheafToSheaf J A ⋙ Sheaf.composeAndSheafify J F ≅
      (whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma biInter_mem {ι : Type*} (hC : IsSetRing C) {s : ι → Set α}
    (S : Finset ι) (hS : S.Nonempty) (hs : ∀ n ∈ S, s n ∈ C) :
    ⋂ i ∈ S, s i ∈ C
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[simp]
theorem ContinuousMap.C_apply (r : R) (a : α) : ContinuousMap.C r a = algebraMap R A r
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- A linear combination of some subset of an orthonormal set is orthogonal to other members of the
set. -/
theorem Orthonormal.inner_finsupp_eq_zero {v : ι → E} (hv : Orthonormal 𝕜 v) {s : Set ι} {i : ι}
    (hi : i ∉ s) {l : ι →₀ 𝕜} (hl : l ∈ Finsupp.supported 𝕜 𝕜 s) :
    ⟪Finsupp.total ι E 𝕜 v l, v i⟫ = 0
-- Mathlib/NumberTheory/Modular.lean
theorem three_lt_four_mul_im_sq_of_mem_fdo (h : z ∈ 𝒟ᵒ) : 3 < 4 * z.im ^ 2
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem span_eq_top_iff {s : Set P₁} (e : P₁ ≃ᵃ[k] P₂) :
    affineSpan k s = ⊤ ↔ affineSpan k (e '' s) = ⊤
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem lineMap_same (p : P1) : lineMap p p = const k k p
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essInf_antitone_measure {f : α → β} (hμν : μ ≪ ν) : essInf f ν ≤ essInf f μ
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem all_iff_forall (p : α → Bool) (as : Array α) (start stop) :
    all as p start stop ↔ ∀ i : Fin as.size, start ≤ i.1 ∧ i.1 < stop → p as[i]
-- Mathlib/LinearAlgebra/Matrix/Block.lean
theorem twoBlockTriangular_det' (M : Matrix m m R) (p : m → Prop) [DecidablePred p]
    (h : ∀ i, p i → ∀ j, ¬p j → M i j = 0) :
    M.det = (toSquareBlockProp M p).det * (toSquareBlockProp M fun i => ¬p i).det
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
theorem map_injective (adj : F ⊣ G) [F.PreservesMonomorphisms] (I : D) (hI : Injective I) :
    Injective (G.obj I)
-- Mathlib/Data/List/DropRight.lean
theorem rdropWhile_idempotent : rdropWhile p (rdropWhile p l) = rdropWhile p l
-- Mathlib/Topology/Algebra/ConstMulAction.lean
theorem HasCompactSupport.comp_smul {β : Type*} [Zero β] {f : α → β} (h : HasCompactSupport f)
    {c : G₀} (hc : c ≠ 0) : HasCompactSupport fun x => f (c • x)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
theorem card_le_m_add_one_of_mem_chunk_parts (hs : s ∈ (chunk hP G ε hU).parts) : s.card ≤ m + 1
-- Mathlib/Data/PNat/Prime.lean
@[norm_cast]
theorem coe_pnat_nat (p : Nat.Primes) : ((p : ℕ+) : ℕ) = p
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem index_dvd_of_le (h : H ≤ K) : K.index ∣ H.index
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_toSupHom (f : SupBotHom α β) : ⇑f.toSupHom = f
-- Mathlib/Algebra/Polynomial/Div.lean
theorem mem_span_C_X_sub_C_X_sub_C_iff_eval_eval_eq_zero {b : R[X]} {P : R[X][X]} :
    P ∈ Ideal.span {C (X - C a), X - C b} ↔ (P.eval b).eval a = 0
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp 1100] theorem singleton_disjoint : Disjoint [a] l ↔ a ∉ l
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem hasBasis_nhds_infty :
    (𝓝 (∞ : OnePoint X)).HasBasis (fun s : Set X => IsClosed s ∧ IsCompact s) fun s =>
      (↑) '' sᶜ ∪ {∞}
-- Mathlib/Data/Nat/Find.lean
lemma find_comp_succ (h₁ : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h0 : ¬ p 0) :
    Nat.find h₁ = Nat.find h₂ + 1
-- Mathlib/RepresentationTheory/Basic.lean
theorem smul_tprod_one_asModule (r : MonoidAlgebra k G) (x : V) (y : W) :
    -- Porting note: required to since Lean 4 doesn't unfold asModule
    let x' : ρV.asModule := x
    let z : (ρV.tprod 1).asModule := x ⊗ₜ y
    r • z = (r • x') ⊗ₜ y
-- Mathlib/GroupTheory/Coset.lean
@[to_additive zero_leftAddCoset]
theorem one_leftCoset : (1 : α) • s = s
-- Mathlib/Data/Set/Function.lean
protected theorem _root_.MonotoneOn.monotone (h : MonotoneOn f s) :
    Monotone (f ∘ Subtype.val : s → β)
-- Mathlib/Order/LiminfLimsup.lean
theorem isBounded_top : IsBounded r ⊤ ↔ ∃ t, ∀ x, r x t
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- `affineSpan` is monotone. -/
@[mono]
theorem affineSpan_mono {s₁ s₂ : Set P} (h : s₁ ⊆ s₂) : affineSpan k s₁ ≤ affineSpan k s₂
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem support_eq_empty {f : α →₀ M} : f.support = ∅ ↔ f = 0
-- Mathlib/NumberTheory/FermatPsp.lean
/-- Used in the proof of `psp_from_prime_psp`
-/
private theorem bp_helper {b p : ℕ} (hb : 0 < b) (hp : 1 ≤ p) :
    b ^ (2 * p) - 1 - (b ^ 2 - 1) = b * (b ^ (p - 1) - 1) * (b ^ p + b)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem UniformCauchySeqOn.uniformCauchySeqOnFilter (hF : UniformCauchySeqOn F p s) :
    UniformCauchySeqOnFilter F p (𝓟 s)
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma ringCon_le_iff {I J : TwoSidedIdeal R} : I ≤ J ↔ I.ringCon ≤ J.ringCon
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- Change a cone on `F.rightOp : J ⥤ Cᵒᵖ` to a cocone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeOfConeRightOp (c : Cone F.rightOp) : Cocone F
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- A filter `l` with the countable intersection property is disjoint with the neighborhood
filter of a Lindelöf set if and only if it is disjoint with the neighborhood filter of each point
of this set. -/
theorem IsLindelof.disjoint_nhdsSet_right {l : Filter X} [CountableInterFilter l]
    (hs : IsLindelof s) : Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x)
-- Mathlib/Probability/Kernel/Condexp.lean
theorem _root_.MeasureTheory.Integrable.norm_integral_condexpKernel [NormedSpace ℝ F]
    (hf_int : Integrable f μ) :
    Integrable (fun ω => ‖∫ y, f y ∂condexpKernel μ m ω‖) μ
-- Mathlib/Data/Finset/Union.lean
@[simp]
lemma biUnion_singleton_eq_self [DecidableEq α] : s.biUnion (singleton : α → Finset α) = s
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
@[simp]
theorem mk_apply (f : C(I^N, X)) (H y) : (⟨f, H⟩ : Ω^ N X x) y = f y
-- Mathlib/Geometry/Manifold/Sheaf/Smooth.lean
@[simp, reassoc, elementwise] lemma smoothSheafCommRing.forgetStalk_inv_comp_eval
    (x : TopCat.of M) :
    (smoothSheafCommRing.forgetStalk IM I M R x).inv ≫
     (DFunLike.coe (smoothSheafCommRing.evalHom IM I M R x)) =
    smoothSheaf.evalHom _ _ _ _
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
@[simp]
theorem FreeAbelianGroup.toFinsupp_comp_toFreeAbelianGroup :
    toFinsupp.comp toFreeAbelianGroup = AddMonoidHom.id (X →₀ ℤ)
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
theorem torusIntegrable_zero_radius {f : ℂⁿ → E} {c : ℂⁿ} : TorusIntegrable f c 0
-- Mathlib/Logic/Basic.lean
@[congr]
theorem exists_prop_congr {p p' : Prop} {q q' : p → Prop} (hq : ∀ h, q h ↔ q' h) (hp : p ↔ p') :
    Exists q ↔ ∃ h : p', q' (hp.2 h)
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.coe_vecMulLinear [Fintype m] (M : Matrix m n R) :
    (M.vecMulLinear : _ → _) = M.vecMul
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
theorem UniqueMDiffWithinAt.smooth_bundle_preimage {p : TotalSpace F Z}
    (hs : UniqueMDiffWithinAt I s p.proj) :
    UniqueMDiffWithinAt (I.prod 𝓘(𝕜, F)) (π F Z ⁻¹' s) p
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem hom_inv_whiskerRight {X Y : C} (f : X ≅ Y) (Z : C) :
    f.hom ▷ Z ≫ f.inv ▷ Z = 𝟙 (X ⊗ Z)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_comm (nH : H.Normal) {a b : G} (h : a * b ∈ H) : b * a ∈ H
-- Mathlib/Data/Set/Card.lean
theorem encard_le_coe_iff_finite_ncard_le {k : ℕ} : s.encard ≤ k ↔ s.Finite ∧ s.ncard ≤ k
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem cycleRange_zero' {n : ℕ} (h : 0 < n) : cycleRange ⟨0, h⟩ = 1
-- Mathlib/Logic/Basic.lean
@[simp] theorem exists_or_eq_left (y : α) (p : α → Prop) : ∃ x : α, x = y ∨ p x
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma isIso_toCycles (hS : S.Exact) [Mono S.f] [S.HasLeftHomology]:
    IsIso S.toCycles
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp] lemma powersMulHom_symm_apply (f : Multiplicative ℕ →* α) :
    (powersMulHom α).symm f = f (ofAdd 1)
-- Mathlib/Data/Num/Bitwise.lean
theorem shiftl_succ_eq_bit0_shiftl : ∀ (p : PosNum) (n : Nat), p <<< n.succ = bit0 (p <<< n)
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_ball_mul [Nontrivial E] (x : E) {r : ℝ} (hr : 0 ≤ r) (s : ℝ) :
    μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 s)
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem filter_sub (p : α → Prop) [DecidablePred p] (f₁ f₂ : α →₀ G) :
    filter p (f₁ - f₂) = filter p f₁ - filter p f₂
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
/-- When `p = ∞`, this lemma does not hold without the additional assumption `Nonempty ι` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.norm_equiv_symm_const'` for a version which exchanges the hypothesis `p ≠ ∞` for
`Nonempty ι`. -/
theorem norm_equiv_symm_const {β} [SeminormedAddCommGroup β] (hp : p ≠ ∞) (b : β) :
    ‖(WithLp.equiv p (ι → β)).symm (Function.const _ b)‖ =
      (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖b‖
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_zero : ⌈(0 : α)⌉ = 0
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_neg_atTop_atBot : Tendsto (Neg.neg : β → β) atTop atBot
-- Mathlib/Topology/Bornology/Absorbs.lean
lemma Absorbent.zero_mem [NeBot (cobounded G₀)] [AddMonoid E] [DistribMulAction G₀ E]
    {s : Set E} (hs : Absorbent G₀ s) : (0 : E) ∈ s
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem subset_interior_div_right : s / interior t ⊆ interior (s / t)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- A field extension `E / F` of exponential characteristic `q` is purely inseparable
if and only if for every element `x` of `E`, the minimal polynomial of `x` over `F` is of form
`(X - x) ^ (q ^ n)` for some natural number `n`. -/
theorem isPurelyInseparable_iff_minpoly_eq_X_sub_C_pow (q : ℕ) [hF : ExpChar F q] :
    IsPurelyInseparable F E ↔
    ∀ x : E, ∃ n : ℕ, (minpoly F x).map (algebraMap F E) = (X - C x) ^ q ^ n
-- Mathlib/Algebra/Group/Action/Sigma.lean
/-- This is not an instance because `i` becomes a metavariable. -/
@[to_additive "This is not an instance because `i` becomes a metavariable."]
protected theorem FaithfulSMul' [FaithfulSMul M (α i)] : FaithfulSMul M (Σi, α i)
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubgroup A) (x : A) :
    x ∈ a⁻¹ • S ↔ a • x ∈ S
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem im_pos_of_dist_center_le {z : ℍ} {r : ℝ} {w : ℂ}
    (h : dist w (center z r) ≤ z.im * Real.sinh r) : 0 < w.im
-- Mathlib/Data/Int/Cast/Lemmas.lean
theorem cast_dvd_cast [CommRing α] (m n : ℤ) (h : m ∣ n) : (m : α) ∣ (n : α)
-- Mathlib/Data/Nat/Digits.lean
/-- The digits in the base b+2 expansion of n are all less than b+2 -/
theorem digits_lt_base' {b m : ℕ} : ∀ {d}, d ∈ digits (b + 2) m → d < b + 2
-- Mathlib/Algebra/Order/Ring/Cast.lean
@[simp] lemma cast_pos : (0 : R) < n ↔ 0 < n
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
lemma exp_add (x y : EReal) : exp (x + y) = exp x * exp y
-- Mathlib/Order/SuccPred/Basic.lean
theorem max_of_succ_le {a : α} : succ a ≤ a → IsMax a
-- Mathlib/ModelTheory/DirectLimit.lean
lemma rangeLiftInclusion : (liftInclusion S).toHom.range = ⨆ i, S i
-- Mathlib/Topology/Bornology/Constructions.lean
lemma IsBounded.image_fst {s : Set (α × β)} (hs : IsBounded s) : IsBounded (Prod.fst '' s)
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_comp_eq_of_range_subset {g : M → N} {f : α → M}
    (hg : ∀ {x}, x ∈ range f → (g x = 1 ↔ x = 1)) :
    mulSupport (g ∘ f) = mulSupport f
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lsub_pos {ι : Type u} [h : Nonempty ι] (f : ι → Ordinal.{max u v}) : 0 < lsub.{_, v} f
-- Mathlib/Topology/Instances/Matrix.lean
@[continuity]
theorem Continuous.matrix_vecMulVec [Mul R] [ContinuousMul R] {A : X → m → R} {B : X → n → R}
    (hA : Continuous A) (hB : Continuous B) : Continuous fun x => vecMulVec (A x) (B x)
-- Mathlib/Data/Nat/Size.lean
theorem lt_size_self (n : ℕ) : n < 2 ^ size n
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_const_mul_self (c : R) (f : α → R) (l : Filter α) :
    IsBigOWith ‖c‖ l (fun x => c * f x) f
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMaxOn.comp_continuousOn [TopologicalSpace δ] {t : Set α} {s : Set δ} {g : δ → α}
    {b : δ} (hf : IsLocalMaxOn f t (g b)) (hst : s ⊆ g ⁻¹' t) (hg : ContinuousOn g s) (hb : b ∈ s) :
    IsLocalMaxOn (f ∘ g) s b
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem map_lowerCentralSeries_le (f : M →ₗ⁅R,L⁆ M₂) :
    (lowerCentralSeries R L M k).map f ≤ lowerCentralSeries R L M₂ k
-- Mathlib/Algebra/Group/PNatPowAssoc.lean
theorem ppow_add (k n : ℕ+) (x : M) : x ^ (k + n) = x ^ k * x ^ n
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
theorem toLinearMap_injective :
    Function.Injective (Isometry.toLinearMap : (Q₁ →qᵢ Q₂) → M₁ →ₗ[R] M₂)
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem equiv_comp : RingHom.comp (equiv i j p) i = j
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem sign_eq_div_abs (a : Int) : sign a = a.div (natAbs a)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem map_cons {w : V} (h : G.Adj w u) : (cons h p).map f = cons (f.map_adj h) (p.map f)
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
lemma smul_def (f : R[X]) (m : PolynomialModule R M) :
    f • m = aeval (Finsupp.lmapDomain M R Nat.succ) f m
-- Mathlib/Topology/MetricSpace/Contracting.lean
theorem tendsto_iterate_efixedPoint' {s : Set α} (hsc : IsComplete s) (hsf : MapsTo f s s)
    (hf : ContractingWith K <| hsf.restrict f s s) {x : α} (hxs : x ∈ s) (hx : edist x (f x) ≠ ∞) :
    Tendsto (fun n ↦ f^[n] x) atTop (𝓝 <| efixedPoint' f hsc hsf hf x hxs hx)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem sub_ofNat' (x : Fin n) (y : Nat) (lt : 0 < n) :
    x - Fin.ofNat' y lt = Fin.ofNat' ((n - y % n) + x.val) lt
-- Mathlib/CategoryTheory/Functor/Trifunctor.lean
/-- Auxiliary definition for `bifunctorComp₂₃`. -/
@[simps]
def bifunctorComp₂₃Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma ofUnits_sSup (s : Set (Subgroup Mˣ)) : (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem bot_eq_zero : (⊥ : FractionalIdeal S P) = 0
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_X_pow {n : ℕ} : aeval x ((X : R[X]) ^ n) = x ^ n
-- Mathlib/Data/Nat/Choose/Multinomial.lean
theorem multinomial_filter_ne [DecidableEq α] (a : α) (m : Multiset α) :
    m.multinomial = m.card.choose (m.count a) * (m.filter (a ≠ ·)).multinomial
-- Mathlib/Logic/Basic.lean
theorem dite_ne_right_iff : (dite P A fun _ ↦ b) ≠ b ↔ ∃ h, A h ≠ b
-- Mathlib/Order/JordanHolder.lean
theorem last_eraseLast_le (s : CompositionSeries X) : s.eraseLast.last ≤ s.last
-- Mathlib/Analysis/Convex/Extreme.lean
theorem extremePoints_subset : A.extremePoints 𝕜 ⊆ A
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem add_singleton_eq (a : A) (r : R) : σ a + {r} = σ (a + ↑ₐ r)
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem toSubalgebra_toIntermediateField (S : Subalgebra K L) (inv_mem : ∀ x ∈ S, x⁻¹ ∈ S) :
    (S.toIntermediateField inv_mem).toSubalgebra = S
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem negSucc_lt_zero (n : Nat) : -[n+1] < 0
-- Mathlib/Topology/Order/LawsonTopology.lean
/-- An upper set is Lawson open if and only if it is Scott open -/
lemma lawsonOpen_iff_scottOpen_of_isUpperSet {s : Set α} (h : IsUpperSet s) :
    IsOpen (WithLawson.ofLawson ⁻¹' s) ↔ IsOpen (WithScott.ofScott ⁻¹' s)
-- Mathlib/Data/Quot.lean
@[simp]
theorem map'_mk'' (f : α → β) (h) (x : α) :
    (Quotient.mk'' x : Quotient s₁).map' f h = (Quotient.mk'' (f x) : Quotient s₂)
-- Mathlib/Data/Complex/Basic.lean
theorem inv_def (z : ℂ) : z⁻¹ = conj z * ((normSq z)⁻¹ : ℝ)
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem range_natCast : range ((↑) : ℕ → Cardinal) = Iio ℵ₀
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
@[simp]
theorem sumToIter_Xr (c : S₂) : sumToIter R S₁ S₂ (X (Sum.inr c)) = C (X c)
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem le_iff_mem_closure (x y : PrimeSpectrum R) :
    x ≤ y ↔ y ∈ closure ({x} : Set (PrimeSpectrum R))
-- Mathlib/Data/Quot.lean
theorem Quotient.exists {α : Sort*} {s : Setoid α} {p : Quotient s → Prop} :
    (∃ a, p a) ↔ ∃ a : α, p ⟦a⟧
-- Mathlib/Data/QPF/Multivariate/Constructions/Const.lean
theorem get_map (x : (Const n A) α) : Const.get (f <$$> x) = Const.get x
-- Mathlib/NumberTheory/Primorial.lean
theorem primorial_succ {n : ℕ} (hn1 : n ≠ 1) (hn : Odd n) : (n + 1)# = n#
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem filterMap_eq_map (f : α → β) : filterMap (some ∘ f) = map f
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive]
theorem edist_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (x y : G) : edist x⁻¹ y = edist x y⁻¹
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[mono]
protected lemma Reachable.mono {u v : V} {G G' : SimpleGraph V}
    (h : G ≤ G') (Guv : G.Reachable u v) : G'.Reachable u v
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_mul {d : R} (_ : (a₁ : R) * b = c₁) (_ : a₂ * b = c₂) (_ : c₁ + c₂ = d) :
    (a₁ + a₂) * b = d
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp]
theorem quot_mk_eq_coe (x : R) : Quot.mk c x = (x : c.Quotient)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem nat_lt_omega (n : ℕ) : ↑n < ω
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem coe_copy (S : NonUnitalSubalgebra R A) (s : Set A) (hs : s = ↑S) :
    (S.copy s hs : Set A) = s
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem discreteTopology_pi_basisFun [Finite ι] :
    DiscreteTopology (span ℤ (Set.range (Pi.basisFun ℝ ι)))
-- Mathlib/Data/Finsupp/BigOperators.lean
theorem Multiset.support_sum_eq [AddCommMonoid M] (s : Multiset (ι →₀ M))
    (hs : s.Pairwise (_root_.Disjoint on Finsupp.support)) :
    s.sum.support = (s.map Finsupp.support).sup
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
theorem support_add (a b : FreeAbelianGroup X) : support (a + b) ⊆ a.support ∪ b.support
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
/-- `Kᗮ` can be characterized as the intersection of the kernels of the operations of
inner product with each of the elements of `K`. -/
theorem orthogonal_eq_inter : Kᗮ = ⨅ v : K, LinearMap.ker (innerSL 𝕜 (v : E))
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The cokernel of `biprod.inr : Y ⟶ X ⊞ Y` is `X`. -/
@[simps!]
def cokernelBiprodInrIso : cokernel (biprod.inr : Y ⟶ X ⊞ Y) ≅ X
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem denom_algebraMap (p : K[X]) : denom (algebraMap _ (RatFunc K) p) = 1
-- Mathlib/Tactic/Positivity/Basic.lean
private lemma ite_ne_zero (ha : a ≠ 0) (hb : b ≠ 0) : ite p a b ≠ 0
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The adjoint is unique: a map `A` is the adjoint of `B` iff it satisfies `⟪A x, y⟫ = ⟪x, B y⟫`
for all `x` and `y`. -/
theorem eq_adjoint_iff (A : E →L[𝕜] F) (B : F →L[𝕜] E) : A = B† ↔ ∀ x y, ⟪A x, y⟫ = ⟪x, B y⟫
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem coeff_ne_zero_of_eq_degree (hn : degree p = n) : coeff p n ≠ 0
-- Mathlib/Algebra/Star/CHSH.lean
theorem tsirelson_inequality_aux : √2 * √2 ^ 3 = √2 * (2 * (√2)⁻¹ + 4 * ((√2)⁻¹ * 2⁻¹))
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
theorem mul_right_eq_zero {a b : M₀} (ha : IsUnit a) : a * b = 0 ↔ b = 0
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem id_apply (a : α) : BoundedLatticeHom.id α a = a
-- Mathlib/Data/PNat/Find.lean
theorem one_le_find : 1 < PNat.find h ↔ ¬p 1
-- Mathlib/Probability/Distributions/Exponential.lean
lemma isProbabilityMeasureExponential {r : ℝ} (hr : 0 < r) :
    IsProbabilityMeasure (expMeasure r)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Mono.lean
@[simp]
theorem pullbackSymmetry_hom_of_mono_eq [Mono f] : (pullbackSymmetry f f).hom = 𝟙 _
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma ΨSq_three : W.ΨSq 3 = W.Ψ₃ ^ 2
-- Mathlib/Data/PNat/Basic.lean
@[simp]
theorem le_one_iff {n : ℕ+} : n ≤ 1 ↔ n = 1
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
theorem exists_affineIndependent (s : Set P) :
    ∃ t ⊆ s, affineSpan k t = affineSpan k s ∧ AffineIndependent k ((↑) : t → P)
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem hasStrictFDerivAt_multiset_prod [DecidableEq ι] [Fintype ι] {u : Multiset ι} {x : ι → 𝔸'} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ (u.map x).prod)
      (u.map (fun i ↦ ((u.erase i).map x).prod • proj i)).sum x
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem image_eq_empty : s.image f = ∅ ↔ s = ∅
-- Mathlib/Algebra/NeZero.lean
@[field_simps]
lemma two_ne_zero [OfNat α 2] [NeZero (2 : α)] : (2 : α) ≠ 0
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The cosine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
adjacent side. -/
theorem cos_oangle_left_mul_dist_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P}
    (h : ∡ p₁ p₂ p₃ = ↑(π / 2)) : Real.Angle.cos (∡ p₃ p₁ p₂) * dist p₁ p₃ = dist p₁ p₂
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem integrable_toReal_condDistrib (hX : AEMeasurable X μ) (hs : MeasurableSet s) :
    Integrable (fun a => (condDistrib Y X μ (X a) s).toReal) μ
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem range_restrict (f : α → β) (s : Set α) : Set.range (s.restrict f) = f '' s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_X_le : degree (X : R[X]) ≤ 1
-- Mathlib/Logic/IsEmpty.lean
@[simp]
theorem nonempty_fun : Nonempty (α → β) ↔ IsEmpty α ∨ Nonempty β
-- Mathlib/Analysis/BoxIntegral/Integrability.lean
/-- The indicator function of a measurable set is McShane integrable with respect to any
locally-finite measure. -/
theorem hasIntegralIndicatorConst (l : IntegrationParams) (hl : l.bRiemann = false)
    {s : Set (ι → ℝ)} (hs : MeasurableSet s) (I : Box ι) (y : E) (μ : Measure (ι → ℝ))
    [IsLocallyFiniteMeasure μ] :
    HasIntegral.{u, v, v} I l (s.indicator fun _ => y) μ.toBoxAdditive.toSMul
      ((μ (s ∩ I)).toReal • y)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem toFinset_mul (s t : Set α) [Fintype s] [Fintype t] [Fintype ↑(s * t)] :
    (s * t).toFinset = s.toFinset * t.toFinset
-- Mathlib/Order/GaloisConnection.lean
theorem monotone_l : Monotone l
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.of_add_mul_left_right (h : IsCoprime x (y + x * z)) : IsCoprime x y
-- Mathlib/Order/Filter/EventuallyConst.lean
theorem eventuallyConst_set {s : Set α} :
    EventuallyConst s l ↔ (∀ᶠ x in l, x ∈ s) ∨ (∀ᶠ x in l, x ∉ s)
-- Mathlib/CategoryTheory/Monad/Types.lean
/-- A lawful `Control.Monad` gives a category theory `Monad` on the category of types.
-/
@[simps!]
def ofTypeMonad : Monad (Type u)
-- Mathlib/GroupTheory/FreeGroup/IsFreeGroup.lean
theorem ext_hom ⦃f g : G →* H⦄ (h : ∀ a : Generators G, f (of a) = g (of a)) : f = g
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem setLIntegral_withDensity_eq_setLIntegral_mul (μ : Measure α) {f g : α → ℝ≥0∞}
    (hf : Measurable f) (hg : Measurable g) {s : Set α} (hs : MeasurableSet s) :
    ∫⁻ x in s, g x ∂μ.withDensity f = ∫⁻ x in s, (f * g) x ∂μ
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_self'' {x : M} : mk' S x.1 x = 1
-- Mathlib/LinearAlgebra/Span.lean
theorem span_nat_eq_addSubmonoid_closure (s : Set M) :
    (span ℕ s).toAddSubmonoid = AddSubmonoid.closure s
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[aesop safe 20 apply (rule_sets := [Measurable])]
protected theorem edist {β : Type*} [SeminormedAddCommGroup β] {f g : α → β}
    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    AEMeasurable (fun a => edist (f a) (g a)) μ