ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem?_zipWith {f : α → β → γ} {i : Nat} :
    (List.zipWith f as bs)[i]? = match as[i]?, bs[i]? with
      | some a, some b => some (f a b) | _, _ => none
-- Mathlib/Data/Set/Basic.lean
theorem subset_diff_singleton {x : α} {s t : Set α} (h : s ⊆ t) (hx : x ∉ s) : s ⊆ t \ {x}
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma intCast_mul_right (h : SemiconjBy a x y) (n : ℤ) : SemiconjBy a (n * x) (n * y)
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem prodEquivOfIsCompl_symm_apply_snd_eq_zero (h : IsCompl p q) {x : E} :
    ((prodEquivOfIsCompl p q h).symm x).2 = 0 ↔ x ∈ p
-- Mathlib/Computability/PartrecCode.lean
private theorem hlup : Primrec fun p : _ × (_ × _) × _ => lup p.1 p.2.1 p.2.2
-- Mathlib/Data/Finset/Preimage.lean
theorem sigma_image_fst_preimage_mk {β : α → Type*} [DecidableEq α] (s : Finset (Σa, β a)) :
    ((s.image Sigma.fst).sigma fun a => s.preimage (Sigma.mk a) sigma_mk_injective.injOn) =
      s
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
/-- If two continuous functions are a.e. equal, then they are equal. -/
theorem eq_of_ae_eq {f g : X → Y} (h : f =ᵐ[μ] g) (hf : Continuous f) (hg : Continuous g) : f = g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
/--
`eq_of_testBit_eq` allows proving two natural numbers are equal
if their bits are all equal.
-/
theorem eq_of_testBit_eq {x y : Nat} (pred : ∀i, testBit x i = testBit y i) : x = y
-- Mathlib/Data/Real/Cardinality.lean
theorem cantorFunction_succ (f : ℕ → Bool) (h1 : 0 ≤ c) (h2 : c < 1) :
    cantorFunction c f = cond (f 0) 1 0 + c * cantorFunction c fun n => f (n + 1)
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
lemma condCDF_eq_stieltjesOfMeasurableRat_unit_prod (ρ : Measure (α × ℝ)) (a : α) :
    condCDF ρ a = stieltjesOfMeasurableRat (fun (p : Unit × α) r ↦ (preCDF ρ r p.2).toReal)
      (measurable_preCDF'.comp measurable_snd) ((), a)
-- Mathlib/Data/Setoid/Basic.lean
/-- The underlying binary operation of the infimum of a set of equivalence relations
    is the infimum of the set's image under the map to the underlying binary operation. -/
theorem sInf_def {s : Set (Setoid α)} : (sInf s).Rel = sInf (Rel '' s)
-- Mathlib/Topology/Clopen.lean
theorem isClopen_empty : IsClopen (∅ : Set X)
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
lemma map₂_tprod_tprod (f : Π i, s i →ₗ[R] t i →ₗ[R] t' i) (x : Π i, s i) (y : Π i, t i) :
    map₂ f (tprod R x) (tprod R y) = tprod R fun i ↦ f i (x i) (y i)
-- Mathlib/RingTheory/Ideal/Colon.lean
theorem annihilator_quotient {N : Submodule R M} :
    Module.annihilator R (M ⧸ N) = N.colon ⊤
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_le_iff_left : a - b ≤ c ↔ a ≤ b + c
-- Mathlib/Order/Filter/Ultrafilter.lean
protected theorem NeBot.le_pure_iff (hf : f.NeBot) : f ≤ pure a ↔ f = pure a
-- Mathlib/FieldTheory/KummerExtension.lean
lemma autAdjoinRootXPowSubCEquiv_root (η) :
    autAdjoinRootXPowSubCEquiv hζ hn H η (root _) = ((η : Kˣ) : K) • root _
-- Mathlib/Analysis/MeanInequalitiesPow.lean
theorem rpow_add_le_add_rpow {p : ℝ} (a b : ℝ≥0) (hp : 0 ≤ p) (hp1 : p ≤ 1) :
    (a + b) ^ p ≤ a ^ p + b ^ p
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem lift_of {x : R} : lift i a h x = i x
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem span_singleton_mul_right_mono [IsDomain R] {x : R} (hx : x ≠ 0) :
    span {x} * I ≤ span {x} * J ↔ I ≤ J
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- The points of a face of a simplex are given by `mono_of_fin`. -/
theorem face_points' {n : ℕ} (s : Simplex k P n) {fs : Finset (Fin (n + 1))} {m : ℕ}
    (h : fs.card = m + 1) : (s.face h).points = s.points ∘ fs.orderEmbOfFin h
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[simp, norm_cast, nolint simpNF]
theorem coe_to_nonUnitalAlgHom (f : A →ₐ[R] B) : ⇑(f.toNonUnitalAlgHom) = ⇑f
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem inl_injective [Zero M] : Function.Injective (inl : R → tsze R M)
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem Measurable.sup' (hf : Measurable f) (hg : Measurable g) : Measurable (f ⊔ g)
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
    Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)]
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
theorem pullback_map_eq_pullbackFstFstIso_inv {X Y S X' Y' S' : C} (f : X ⟶ S) (g : Y ⟶ S)
    (f' : X' ⟶ S') (g' : Y' ⟶ S') (i₁ : X ⟶ X') (i₂ : Y ⟶ Y') (i₃ : S ⟶ S')
    (e₁ : f ≫ i₃ = i₁ ≫ f') (e₂ : g ≫ i₃ = i₂ ≫ g') [Mono i₃] :
    pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂ =
      (pullbackFstFstIso f g f' g' i₁ i₂ i₃ e₁ e₂).inv ≫ pullback.snd _ _ ≫ pullback.fst _ _
-- Mathlib/Logic/Relation.lean
theorem Equivalence.eqvGen_iff (h : Equivalence r) : EqvGen r a b ↔ r a b
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_inter_Ioi : Iic a ∩ Ioi b = Ioc b a
-- Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean
/-- A family of continuous linear maps is `C^n` on `s` if all its applications are. -/
theorem contDiffOn_clm_apply {n : ℕ∞} {f : E → F →L[𝕜] G} {s : Set E} [FiniteDimensional 𝕜 F] :
    ContDiffOn 𝕜 n f s ↔ ∀ y, ContDiffOn 𝕜 n (fun x => f x y) s
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem cpow_def (x y : ℂ) : x ^ y = if x = 0 then if y = 0 then 1 else 0 else exp (log x * y)
-- Mathlib/Topology/Algebra/InfiniteSum/Real.lean
theorem summable_of_sum_le {ι : Type*} {f : ι → ℝ} {c : ℝ} (hf : 0 ≤ f)
    (h : ∀ u : Finset ι, ∑ x ∈ u, f x ≤ c) : Summable f
-- Mathlib/Order/UpperLower/Basic.lean
theorem isLowerSet_sInter {S : Set (Set α)} (hf : ∀ s ∈ S, IsLowerSet s) : IsLowerSet (⋂₀ S)
-- Mathlib/Topology/Instances/ENNReal.lean
/-- The truncated cast `ENNReal.truncateToReal t : ℝ≥0∞ → ℝ` is monotone when `t ≠ ∞`. -/
lemma monotone_truncateToReal {t : ℝ≥0∞} (t_ne_top : t ≠ ∞) : Monotone (truncateToReal t)
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
lemma toSections_fac : I.sectionsEquiv.symm ∘ Types.sectionOfCone c = c.toSections
-- Mathlib/RingTheory/Localization/InvSubmonoid.lean
theorem toInvSubmonoid_eq_mk' (x : M) : (toInvSubmonoid M S x : S) = mk' S 1 x
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
@[ext]
theorem leftDistributor_ext_right {J : Type} [Fintype J] {X Y : C} {f : J → C} {g h : X ⟶ Y ⊗ ⨁ f}
    (w : ∀ j, g ≫ (Y ◁ biproduct.π f j) = h ≫ (Y ◁ biproduct.π f j)) : g = h
-- Mathlib/Data/Rat/Lemmas.lean
theorem num_div_eq_of_coprime {a b : ℤ} (hb0 : 0 < b) (h : Nat.Coprime a.natAbs b.natAbs) :
    (a / b : ℚ).num = a
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem toFinsupp_sum {ι : Type*} (s : Finset ι) (f : ι → R[X]) :
    (∑ i ∈ s, f i : R[X]).toFinsupp = ∑ i ∈ s, (f i).toFinsupp
-- Mathlib/Order/Cover.lean
theorem CovBy.Ioo_eq (h : a ⋖ b) : Ioo a b = ∅
-- Mathlib/FieldTheory/MvPolynomial.lean
theorem quotient_mk_comp_C_injective (I : Ideal (MvPolynomial σ K)) (hI : I ≠ ⊤) :
    Function.Injective ((Ideal.Quotient.mk I).comp MvPolynomial.C)
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem outerMeasure_opens (U : Opens G) : μ.outerMeasure U = μ.innerContent U
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem whiskerLeft_hom {X Y : Mon_ C} (f : X ⟶ Y) (Z : Mon_ C) :
    (f ▷ Z).hom = f.hom ▷ Z.X
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- Two simplices with the same points have the same Monge point. -/
theorem mongePoint_eq_of_range_eq {n : ℕ} {s₁ s₂ : Simplex ℝ P n}
    (h : Set.range s₁.points = Set.range s₂.points) : s₁.mongePoint = s₂.mongePoint
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := aesop safe 20 apply (rule_sets := [Measurable])) const_nsmul]
protected theorem pow [Monoid β] [ContinuousMul β] (hf : AEStronglyMeasurable f μ) (n : ℕ) :
    AEStronglyMeasurable (f ^ n) μ
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem apply_le_nfpFamily [hι : Nonempty ι] {f : ι → Ordinal → Ordinal} (H : ∀ i, IsNormal (f i))
    {a b} : (∀ i, f i b ≤ nfpFamily.{u, v} f a) ↔ b ≤ nfpFamily.{u, v} f a
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem succ_coe (a : α) : succ (↑a : WithTop α) = ↑(succ a)
-- Mathlib/Algebra/Exact.lean
lemma of_comp_of_mem_range [Zero P] (h1 : g ∘ f = 0)
    (h2 : ∀ x, g x = 0 → x ∈ Set.range f) : Exact f g
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem max_eq_zero {a b : Ordinal} : max a b = 0 ↔ a = 0 ∧ b = 0
-- Mathlib/Topology/Clopen.lean
theorem continuous_boolIndicator_iff_isClopen (U : Set X) :
    Continuous U.boolIndicator ↔ IsClopen U
-- Mathlib/Order/Category/Semilat.lean
@[simp]
theorem coe_of (α : Type*) [SemilatticeInf α] [OrderTop α] : ↥(of α) = α
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the two vectors passed to `oangle` are the same, the result is 0. -/
@[simp]
theorem oangle_self (x : V) : o.oangle x x = 0
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/-- Bijection between `α` and `PLift α` -/
theorem PLift.down_up {α : Sort u} (a : α) : Eq (down (up a)) a
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem le_of_mem (hJ : J ∈ π) : J ≤ I
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem isometry_id : @Isometry V V _ _ (id V)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
theorem strictAnti_iff_map_pos : StrictAnti (f : α → β) ↔ ∀ a < 0, 0 < f a
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem natDegree_comp_le : natDegree (p.comp q) ≤ natDegree p * natDegree q
-- Mathlib/Control/Monad/Cont.lean
theorem monadLift_bind [Monad m] [LawfulMonad m] {α β} (x : m α) (f : α → m β) :
    (monadLift (x >>= f) : ContT r m β) = monadLift x >>= monadLift ∘ f
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
protected lemma ext_iff (z₁ z₂ : Cocycle F G n) : z₁ = z₂ ↔ (z₁ : Cochain F G n) = z₂
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwise_pair : Set.Pairwise {a, b} r ↔ a ≠ b → r a b ∧ r b a
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem swap_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.swap = p.swap⁻¹
-- Mathlib/Order/InitialSeg.lean
theorem wellFounded_iff_principalSeg.{u} {β : Type u} {s : β → β → Prop} [IsTrans β s] :
    WellFounded s ↔ ∀ (α : Type u) (r : α → α → Prop) (_ : r ≺i s), WellFounded r
-- Mathlib/CategoryTheory/GlueData.lean
theorem types_ι_jointly_surjective (D : GlueData (Type v)) (x : D.glued) :
    ∃ (i : _) (y : D.U i), D.ι i y = x
-- Mathlib/Data/Nat/PSub.lean
@[simp]
theorem ppred_succ {n : ℕ} : ppred (succ n) = some n
-- Mathlib/Analysis/NormedSpace/Exponential.lean
/-- If a normed ring `𝔸` is a normed algebra over two fields, then they define the same
`expSeries` on `𝔸`. -/
theorem expSeries_eq_expSeries (n : ℕ) (x : 𝔸) :
    (expSeries 𝕂 𝔸 n fun _ => x) = expSeries 𝕂' 𝔸 n fun _ => x
-- Mathlib/Order/LiminfLimsup.lean
theorem HasBasis.limsInf_eq_iSup_sInf {p : ι → Prop} {s : ι → Set α} {f : Filter α}
    (h : f.HasBasis p s) : limsInf f = ⨆ (i) (_ : p i), sInf (s i)
-- Mathlib/Topology/MetricSpace/MetricSeparated.lean
theorem mono_left {s'} (h' : IsMetricSeparated s' t) (hs : s ⊆ s') : IsMetricSeparated s t
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
theorem coeFn_injective : @Injective (P →ᵃⁱ[𝕜] P₂) (P → P₂) (↑)
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- `DFunLike.coe` as a `RingHom`. -/
@[simps!] def coeFnRingHom [Semiring Y] : LocallyConstant X Y →+* X → Y
-- Mathlib/Order/Hom/Basic.lean
/-- The "forgetful functor" from `α →o β` to `α → β` that takes the underlying function,
is monotone. -/
@[simps (config := .asFn)]
def coeFnHom : (α →o β) →o α → β
-- Mathlib/Topology/Basic.lean
@[simp]
theorem frequently_frequently_nhds {p : X → Prop} :
    (∃ᶠ x' in 𝓝 x, ∃ᶠ x'' in 𝓝 x', p x'') ↔ ∃ᶠ x in 𝓝 x, p x
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map₂Right_cons_cons :
    map₂Right f (a :: as) (b :: bs) = f (some a) b :: map₂Right f as bs
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem eq_false_of_decide {p : Prop} {_ : Decidable p} (h : decide p = false) : p = False
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem splittingOfFinsuppSurjective_splits (f : M →ₗ[R] α →₀ R) (s : Surjective f) :
    f.comp (splittingOfFinsuppSurjective f s) = LinearMap.id
-- Mathlib/Topology/NhdsSet.lean
theorem mem_nhdsSet_iff_forall : s ∈ 𝓝ˢ t ↔ ∀ x : X, x ∈ t → s ∈ 𝓝 x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem surjOn_tan : SurjOn tan (Ioo (-(π / 2)) (π / 2)) univ
-- Mathlib/Algebra/GroupWithZero/Defs.lean
theorem mul_right_inj' (ha : a ≠ 0) : a * b = a * c ↔ b = c
-- Mathlib/Combinatorics/Quiver/Path.lean
lemma cons_ne_nil (p : Path a b) (e : b ⟶ a) : p.cons e ≠ Path.nil
-- Mathlib/MeasureTheory/Function/Floor.lean
theorem Int.measurable_floor [OpensMeasurableSpace R] : Measurable (Int.floor : R → ℤ)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
theorem opNNNorm_mul : ‖mul 𝕜 𝕜'‖₊ = 1
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast] lemma coe_eq_bot [Bot α] {a : α} : (a : WithTop α) = ⊥ ↔ a = ⊥
-- Mathlib/Algebra/Order/Kleene.lean
@[simp]
theorem kstar_eq_one : a∗ = 1 ↔ a ≤ 1
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
@[simp]
theorem pre_map {A₁ A₂ A₃ : C} [Exponentiable A₁] [Exponentiable A₂] [Exponentiable A₃]
    (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃) : pre (f ≫ g) = pre g ≫ pre f
-- Mathlib/Order/Filter/Bases.lean
/-- We say that a filter `l` has an antitone basis `s : ι → Set α`, if `t ∈ l` if and only if `t`
includes `s i` for some `i`, and `s` is decreasing. -/
structure HasAntitoneBasis (l : Filter α) (s : ι'' → Set α)
    extends HasBasis l (fun _ => True) s : Prop where
  /-- The sequence of sets is antitone. -/
  protected antitone : Antitone s
-- Mathlib/Data/Set/Function.lean
lemma bijOn_of_subsingleton' [Subsingleton α] [Subsingleton β] (f : α → β)
    (h : s.Nonempty ↔ t.Nonempty) : BijOn f s t
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
theorem aemeasurable_limRatio : AEMeasurable (v.limRatio ρ) μ
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[deprecated getElem?_set_ne (since := "2024-06-12")]
theorem get?_set_ne (a : α) {m n} (l : List α) (h : m ≠ n) : (set l m a).get? n = l.get? n
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
theorem finrank_real_complex_fact' : Fact (finrank ℝ ℂ = 1 + 1)
-- Mathlib/LinearAlgebra/Matrix/Orthogonal.lean
theorem HasOrthogonalCols.transpose_hasOrthogonalRows [Fintype m] (h : A.HasOrthogonalCols) :
    Aᵀ.HasOrthogonalRows
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_singleton {f : β → α} {b : β} : ⨅ x ∈ (singleton b : Set β), f x = f b
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem degree_mul_leadingCoeff_self_inv (p : K[X]) :
    degree (p * C (leadingCoeff p)⁻¹) = degree p
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
/-- Evaluation of a `σ₁₂`-linear map at a fixed `a`, as an `AddMonoidHom`. -/
@[simps]
def evalAddMonoidHom (a : M) : (M →ₛₗ[σ₁₂] M₂) →+ M₂
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem mem_subring_iff {x : ℚ_[p]} : x ∈ subring p ↔ ‖x‖ ≤ 1
-- Mathlib/Data/Nat/Defs.lean
@[simp] lemma add_def : Nat.add m n = m + n
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
protected theorem lift_mk {β : Sort*} {f : V → β}
    {h : ∀ (v w : V) (p : G.Walk v w), p.IsPath → f v = f w} {v : V} :
    ConnectedComponent.lift f h (G.connectedComponentMk v) = f v
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
@[simp]
theorem Sheaf.Hom.add_app (f g : P ⟶ Q) (U) : (f + g).1.app U = f.1.app U + g.1.app U
-- Mathlib/Topology/Category/Stonean/EffectiveEpi.lean
theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : Stonean.{u}}
    (X : α → Stonean.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ]
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f
-- Mathlib/MeasureTheory/Function/L1Space.lean
/-- A non-quantitative version of Markov inequality for integrable functions: the measure of points
where `‖f x‖ > ε` is finite for all positive `ε`. -/
lemma Integrable.measure_norm_gt_lt_top {f : α → β} (hf : Integrable f μ) {ε : ℝ} (hε : 0 < ε) :
    μ {x | ε < ‖f x‖} < ∞
-- Mathlib/Topology/PartialHomeomorph.lean
theorem ofSet_trans' {s : Set X} (hs : IsOpen s) :
    (ofSet s hs).trans e = e.restr (e.source ∩ s)
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem val_eq_coe (I : FractionalIdeal S P) : I.val = I
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.affinity (hs : StarConvex 𝕜 x s) (z : E) (c : 𝕜) :
    StarConvex 𝕜 (z + c • x) ((fun x => z + c • x) '' s)
-- Mathlib/Algebra/Homology/Embedding/Basic.lean
/-- The embedding from `up ℕ` to `up ℤ` which sends `n : ℕ` to `p + n`. -/
@[simps!]
def embeddingUpIntGE : Embedding (up ℕ) (up ℤ)
-- Mathlib/Topology/GDelta.lean
/-- A countable intersection of Gδ sets is a Gδ set. -/
theorem IsGδ.sInter {S : Set (Set X)} (h : ∀ s ∈ S, IsGδ s) (hS : S.Countable) : IsGδ (⋂₀ S)
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
lemma yonedaEquivFst_eq (p : YonedaCollection F X) : p.yonedaEquivFst = yonedaEquiv p.fst
-- Mathlib/Data/Nat/Defs.lean
protected lemma sub_lt_sub_iff_right (h : c ≤ a) : a - c < b - c ↔ a < b
-- Mathlib/Data/Matrix/Basic.lean
theorem star_dotProduct_star : star v ⬝ᵥ star w = star (w ⬝ᵥ v)
-- Mathlib/Data/Finset/Union.lean
@[simp, norm_cast]
lemma coe_disjiUnion {h} : (s.disjiUnion t h : Set β) = ⋃ x ∈ (s : Set α), t x
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc (attr := simp)]
theorem coprod.map_map {A₁ A₂ A₃ B₁ B₂ B₃ : C} [HasBinaryCoproduct A₁ B₁] [HasBinaryCoproduct A₂ B₂]
    [HasBinaryCoproduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃) :
    coprod.map f g ≫ coprod.map h k = coprod.map (f ≫ h) (g ≫ k)
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem lintegral_laverage (μ : Measure α) [IsFiniteMeasure μ] (f : α → ℝ≥0∞) :
    ∫⁻ _x, ⨍⁻ a, f a ∂μ ∂μ = ∫⁻ x, f x ∂μ
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
/-- A column partitioned matrix mulitplied by a row partitioned matrix gives the sum of the "outer"
products of the block matrices -/
lemma fromColumns_mul_fromRows (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R)
    (B₁ : Matrix n₁ n R) (B₂ : Matrix n₂ n R) :
    fromColumns A₁ A₂ * fromRows B₁ B₂ = (A₁ * B₁ + A₂ * B₂)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Poly.of_denote_le_cancel {ctx : Context} {m₁ m₂ : Poly} (h : denote_le ctx (cancel m₁ m₂)) : denote_le ctx (m₁, m₂)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem cons_eq_cons {a b : α} {l l' : List α} : a :: l = b :: l' ↔ a = b ∧ l = l'
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_reindex_left (f : α → β → γ) (el : l ≃ l') (em : m ≃ m') (M : Matrix l m α)
    (N : Matrix n n' β) :
    kroneckerMap f (Matrix.reindex el em M) N =
      reindex (el.prodCongr (Equiv.refl _)) (em.prodCongr (Equiv.refl _)) (kroneckerMap f M N)
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesAt.toHasFPowerSeriesAt
    (hf : HasFiniteFPowerSeriesAt f p x n) : HasFPowerSeriesAt f p x
-- Mathlib/Order/Fin/Basic.lean
theorem rev_zero_eq_top (n : ℕ) [NeZero n] : rev (0 : Fin n) = ⊤
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
theorem disjoint_ordT5Nhd : Disjoint (ordT5Nhd s t) (ordT5Nhd t s)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[local simp] theorem neg_ofNat_zero : -((0 : Nat) : Int) = 0
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem diff_inter_self_eq_diff {s t : Set α} : s \ (t ∩ s) = s \ t
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem ModularForm.toSlashInvariantForm_coe (f : ModularForm Γ k) : ⇑f.1 = f
-- Mathlib/Topology/Instances/PNat.lean
theorem uniformEmbedding_coe : UniformEmbedding ((↑) : ℕ+ → ℕ)
-- Mathlib/NumberTheory/Dioph.lean
@[simp]
theorem sub_apply (f g : Poly α) (x : α → ℕ) : (f - g) x = f x - g x
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- `LocallyConstant.map` as an `AlgHom` -/
@[simps!]
def mapₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z]
    (f : Y →ₐ[R] Z) : LocallyConstant X Y →ₐ[R] LocallyConstant X Z
-- Mathlib/Data/Nat/Cast/Defs.lean
@[simp, norm_cast]
theorem cast_add [AddMonoidWithOne R] (m n : ℕ) : ((m + n : ℕ) : R) = m + n
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem support_finSuccEquiv_nonempty {f : MvPolynomial (Fin (n + 1)) R} (h : f ≠ 0) :
    (finSuccEquiv R n f).support.Nonempty
-- Mathlib/Analysis/Asymptotics/Theta.lean
@[simp]
theorem isTheta_const_const_iff [NeBot l] {c₁ : E''} {c₂ : F''} :
    ((fun _ : α ↦ c₁) =Θ[l] fun _ ↦ c₂) ↔ (c₁ = 0 ↔ c₂ = 0)
-- Mathlib/Data/Quot.lean
@[elab_as_elim]
protected theorem induction_on {α : Sort*} {r : α → α → Prop} {β : Quot r → Prop} (q : Quot r)
    (h : ∀ a, β (Quot.mk r a)) : β q
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
lemma quasispectrumRestricts_iff
    {R S A : Type*} [CommSemiring R] [CommSemiring S] [NonUnitalRing A]
    [Module R A] [Module S A] [Algebra R S] (a : A) (f : S → R) :
    QuasispectrumRestricts a f ↔ (quasispectrum S a).RightInvOn f (algebraMap R S) ∧
      Function.LeftInverse f (algebraMap R S)
-- Mathlib/CategoryTheory/Preadditive/Generator.lean
theorem isSeparator_iff_faithful_preadditiveCoyonedaObj (G : C) :
    IsSeparator G ↔ (preadditiveCoyonedaObj (op G)).Faithful
-- Mathlib/Data/Matrix/Notation.lean
theorem mul_fin_three [AddCommMonoid α] [Mul α]
    (a₁₁ a₁₂ a₁₃ a₂₁ a₂₂ a₂₃ a₃₁ a₃₂ a₃₃ b₁₁ b₁₂ b₁₃ b₂₁ b₂₂ b₂₃ b₃₁ b₃₂ b₃₃ : α) :
    !![a₁₁, a₁₂, a₁₃;
       a₂₁, a₂₂, a₂₃;
       a₃₁, a₃₂, a₃₃] * !![b₁₁, b₁₂, b₁₃;
                           b₂₁, b₂₂, b₂₃;
                           b₃₁, b₃₂, b₃₃] =
    !![a₁₁*b₁₁ + a₁₂*b₂₁ + a₁₃*b₃₁, a₁₁*b₁₂ + a₁₂*b₂₂ + a₁₃*b₃₂, a₁₁*b₁₃ + a₁₂*b₂₃ + a₁₃*b₃₃;
       a₂₁*b₁₁ + a₂₂*b₂₁ + a₂₃*b₃₁, a₂₁*b₁₂ + a₂₂*b₂₂ + a₂₃*b₃₂, a₂₁*b₁₃ + a₂₂*b₂₃ + a₂₃*b₃₃;
       a₃₁*b₁₁ + a₃₂*b₂₁ + a₃₃*b₃₁, a₃₁*b₁₂ + a₃₂*b₂₂ + a₃₃*b₃₂, a₃₁*b₁₃ + a₃₂*b₂₃ + a₃₃*b₃₃]
-- Mathlib/LinearAlgebra/Lagrange.lean
@[simp]
theorem eval_basis_self (hvs : Set.InjOn v s) (hi : i ∈ s) :
    (Lagrange.basis s v i).eval (v i) = 1
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem sub_abv_le_abv_sub (a b : R) : abv a - abv b ≤ abv (a - b)
-- Mathlib/Dynamics/Newton.lean
theorem newtonMap_apply_of_not_isUnit (h : ¬ (IsUnit <| aeval x (derivative P))) :
    P.newtonMap x = x
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- A closed subset of a Lindelöf set is a Lindelöf set. -/
theorem IsLindelof.of_isClosed_subset (hs : IsLindelof s) (ht : IsClosed t) (h : t ⊆ s) :
    IsLindelof t
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem neg : mapFun f (-x) = -mapFun f x
-- Mathlib/Algebra/Star/Unitary.lean
/-- Unitary conjugation preserves the spectrum, star on left. -/
@[simp]
lemma spectrum.unitary_conjugate {a : A} {u : unitary A} :
    spectrum R (u * a * (star u : A)) = spectrum R a
-- Mathlib/Data/Matrix/Basis.lean
theorem mem_range_scalar_iff_commute_stdBasisMatrix {M : Matrix n n α} :
    M ∈ Set.range (Matrix.scalar n) ↔ ∀ (i j : n), i ≠ j → Commute (stdBasisMatrix i j 1) M
-- Mathlib/Data/Nat/Pairing.lean
theorem unpair_lt {n : ℕ} (n1 : 1 ≤ n) : (unpair n).1 < n
-- Mathlib/Data/Nat/Cast/Basic.lean
@[ext]
theorem MonoidWithZeroHom.ext_nat {f g : ℕ →*₀ A} : (∀ {n : ℕ}, 0 < n → f n = g n) → f = g
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem one_lt_rpow_of_pos_of_lt_one_of_neg {x : ℝ≥0∞} {z : ℝ} (hx1 : 0 < x) (hx2 : x < 1)
    (hz : z < 0) : 1 < x ^ z
-- Mathlib/Data/Nat/Factorization/Induction.lean
/-- For any multiplicative function `f` with `f 1 = 1` and `f 0 = 1`,
we can evaluate `f n` by evaluating `f` at `p ^ k` over the factorization of `n` -/
theorem multiplicative_factorization' {β : Type*} [CommMonoid β] (f : ℕ → β)
    (h_mult : ∀ x y : ℕ, Coprime x y → f (x * y) = f x * f y) (hf0 : f 0 = 1) (hf1 : f 1 = 1) :
    f n = n.factorization.prod fun p k => f (p ^ k)
-- Mathlib/Data/ENNReal/Real.lean
/-- If `a ≤ b + c` and `a = ∞` whenever `b = ∞` or `c = ∞`, then
`ENNReal.toReal a ≤ ENNReal.toReal b + ENNReal.toReal c`. This lemma is useful to transfer
triangle-like inequalities from `ENNReal`s to `Real`s. -/
theorem toReal_le_add' (hle : a ≤ b + c) (hb : b = ∞ → a = ∞) (hc : c = ∞ → a = ∞) :
    a.toReal ≤ b.toReal + c.toReal