ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma vanishingIdeal_isClosed_isIrreducible :
    vanishingIdeal (R := R) '' {s | IsClosed s ∧ IsIrreducible s} = {P | P.IsPrime}
-- Mathlib/Data/Finset/Pointwise.lean
theorem vsub_subset_vsub_right : s₁ ⊆ s₂ → s₁ -ᵥ t ⊆ s₂ -ᵥ t
-- Mathlib/Algebra/Ring/CentroidHom.lean
/-- The natural ring homomorphism from `R` into `CentroidHom α`.

This is a stronger version of `Module.toAddMonoidEnd`. -/
@[simps! apply_toFun]
def _root_.Module.toCentroidHom : R →+* CentroidHom α
-- Mathlib/Data/Real/GoldenRatio.lean
/-- The geometric sequence `fun n ↦ ψ^n` is a solution of `fibRec`. -/
theorem geom_goldConj_isSol_fibRec : fibRec.IsSolution (ψ ^ ·)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem denom_div_dvd (p q : K[X]) : denom (algebraMap _ _ p / algebraMap _ _ q) ∣ q
-- Mathlib/Algebra/BigOperators/Associated.lean
theorem Prime.dvd_finset_prod_iff {S : Finset α} {p : M} (pp : Prime p) (g : α → M) :
    p ∣ S.prod g ↔ ∃ a ∈ S, p ∣ g a
-- Mathlib/RingTheory/Localization/Integer.lean
theorem isInteger_add {a b : S} (ha : IsInteger R a) (hb : IsInteger R b) : IsInteger R (a + b)
-- Mathlib/Data/Int/Interval.lean
@[simp]
theorem card_Icc : (Icc a b).card = (b + 1 - a).toNat
-- Mathlib/Data/List/Basic.lean
theorem mem_getLast?_cons {x y : α} : ∀ {l : List α}, x ∈ l.getLast? → x ∈ (y :: l).getLast?
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- The definition of `centroidWeightsIndicator`. -/
theorem centroidWeightsIndicator_def :
    s.centroidWeightsIndicator k = Set.indicator (↑s) (s.centroidWeights k)
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem zero_product : (0 : Multiset α) ×ˢ t = 0
-- Mathlib/Data/Real/Hyperreal.lean
theorem infiniteNeg_mul_of_infiniteNeg_not_infinitesimal_pos {x y : ℝ*} :
    InfiniteNeg x → ¬Infinitesimal y → 0 < y → InfiniteNeg (x * y)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem toArray_data : (a : Array α) → a.data.toArray = a
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_eq_ofNat {m : ℕ∞} {n : ℕ} [n.AtLeastTwo] :
    (m : Cardinal) = no_index (OfNat.ofNat n) ↔ m = OfNat.ofNat n
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem span_empty : span R (∅ : Set M) = ⊥
-- Mathlib/Topology/PartialHomeomorph.lean
theorem restr_source' (s : Set X) (hs : IsOpen s) : (e.restr s).source = e.source ∩ s
-- Mathlib/Data/Set/Finite.lean
@[simp]
theorem toFinset_ssubset {t : Finset α} : hs.toFinset ⊂ t ↔ s ⊂ t
-- Mathlib/Data/Matrix/Rank.lean
theorem rank_conjTranspose_mul_self (A : Matrix m n R) : (Aᴴ * A).rank = A.rank
-- Mathlib/Data/Set/Lattice.lean
theorem directedOn_iUnion {r} {f : ι → Set α} (hd : Directed (· ⊆ ·) f)
    (h : ∀ x, DirectedOn r (f x)) : DirectedOn r (⋃ x, f x)
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp] theorem map_adj_iff {v w : V} : G'.Adj (f v) (f w) ↔ G.Adj v w
-- Mathlib/Dynamics/PeriodicPts.lean
/-- `MulAction.period m a` is definitionally equal to `Function.minimalPeriod (m • ·) a`. -/
@[to_additive "`AddAction.period m a` is definitionally equal to
`Function.minimalPeriod (m +ᵥ ·) a`"]
theorem period_eq_minimalPeriod {m : M} {a : α} :
    MulAction.period m a = minimalPeriod (fun x => m • x) a
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem algebraMap_apply [SMulCommClass R S A] (r : S) :
    algebraMap S (A ⊗[R] B) r = (algebraMap S A) r ⊗ₜ 1
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem mem_bot {s : Set α} : s ∈ (⊥ : Filter α)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem ContDiffAt.rpow_const_of_ne (hf : ContDiffAt ℝ n f x) (h : f x ≠ 0) :
    ContDiffAt ℝ n (fun x => f x ^ p) x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem aleph_add_aleph (o₁ o₂ : Ordinal) : aleph o₁ + aleph o₂ = aleph (max o₁ o₂)
-- Mathlib/Algebra/GeomSum.lean
theorem RingHom.map_geom_sum₂ [Semiring α] [Semiring β] (x y : α) (n : ℕ) (f : α →+* β) :
    f (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) = ∑ i ∈ range n, f x ^ i * f y ^ (n - 1 - i)
-- .lake/packages/lean4/src/lean/Init/Data/AC.lean
theorem Context.mergeIdem_head : mergeIdem (x :: x :: xs) = mergeIdem (x :: xs)
-- Mathlib/Condensed/Light/Explicit.lean
/-- A light condensed object satisfies the equalizer condition. -/
theorem equalizerCondition (X : LightCondensed A) : EqualizerCondition X.val
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
@[simp]
theorem cycleOf_apply_apply_pow_self (f : Perm α) [DecidableRel f.SameCycle] (x : α) (k : ℕ) :
    cycleOf f x ((f ^ k) x) = (f ^ (k + 1) : Perm α) x
-- Mathlib/Data/ZMod/Basic.lean
/-- The coercions are respectively `Nat.cast` and `ZMod.cast`. -/
@[simp]
theorem natCast_comp_val [NeZero n] : ((↑) : ℕ → R) ∘ (val : ZMod n → ℕ) = cast
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_nonneg (hs : MeasurableSet s) (hf : ∀ x, x ∈ s → 0 ≤ f x) :
    0 ≤ ∫ x in s, f x ∂μ
-- Mathlib/Analysis/NormedSpace/MStructure.lean
@[simp]
theorem coe_sdiff [FaithfulSMul M X] (P Q : { P : M // IsLprojection X P }) :
    ↑(P \ Q) = (↑P : M) * (1 - ↑Q)
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem measure_eq_zero_of_trim_eq_zero (hm : m ≤ m0) (h : μ.trim hm s = 0) : μ s = 0
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- We say a quotient of `α` by `G` `HasAddFundamentalDomain` if there is a measurable set
  `s` for which `IsAddFundamentalDomain G s` holds. -/
class HasAddFundamentalDomain (G α : Type*) [Zero G] [VAdd G α] [MeasurableSpace α]
    (ν : Measure α := by volume_tac) : Prop where
  ExistsIsAddFundamentalDomain : ∃ s : Set α, IsAddFundamentalDomain G s ν
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
@[nontriviality]
theorem contDiffOn_of_subsingleton [Subsingleton F] : ContDiffOn 𝕜 n f s
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive mem_ball_iff_norm']
theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r
-- Mathlib/GroupTheory/GroupAction/Quotient.lean
theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G) (s : S) :
    quotientCenterEmbedding hS g s = ⟨⁅g, s⁆, g, s, rfl⟩
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_sub_one (a : α) : fract (a - 1) = fract a
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- A version of `MultilinearMap.cons_smul` for `AlternatingMap`. -/
theorem map_vecCons_smul {n : ℕ} (f : M [⋀^Fin n.succ]→ₗ[R] N) (m : Fin n → M) (c : R)
    (x : M) : f (Matrix.vecCons (c • x) m) = c • f (Matrix.vecCons x m)
-- Mathlib/Order/Filter/Basic.lean
theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g
-- Mathlib/ModelTheory/Quotients.lean
theorem Term.realize_quotient_mk' {β : Type*} (t : L.Term β) (x : β → M) :
    (t.realize fun i => (⟦x i⟧ : Quotient s)) = ⟦@Term.realize _ _ ps.toStructure _ x t⟧
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_le_nonneg {s : Set X} (hs : MeasurableSet s) (hf : StronglyMeasurable f)
    (hfi : Integrable f μ) : ∫ x in s, f x ∂μ ≤ ∫ x in {y | 0 ≤ f y}, f x ∂μ
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
/-- If `f : ℝ → ℝ` is integrable on `(a, b]` for real numbers `a < b`, and positive on the interior
of the interval, then its integral over `a..b` is strictly positive. -/
theorem intervalIntegral_pos_of_pos_on {f : ℝ → ℝ} {a b : ℝ} (hfi : IntervalIntegrable f volume a b)
    (hpos : ∀ x : ℝ, x ∈ Ioo a b → 0 < f x) (hab : a < b) : 0 < ∫ x : ℝ in a..b, f x
-- Mathlib/Analysis/Normed/Group/Rat.lean
@[norm_cast, simp]
theorem _root_.Int.norm_cast_rat (m : ℤ) : ‖(m : ℚ)‖ = ‖m‖
-- Mathlib/Order/Monotone/Basic.lean
protected theorem StrictMono.comp (hg : StrictMono g) (hf : StrictMono f) : StrictMono (g ∘ f)
-- Mathlib/Algebra/Order/Ring/WithTop.lean
@[simp, norm_cast] lemma coe_pow (a : α) (n : ℕ) : (↑(a ^ n) : WithBot α) = a ^ n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem_append_right' (since := "2024-06-12")]
theorem get_append_right' {l₁ l₂ : List α} {n : Nat} (h₁ : l₁.length ≤ n) (h₂) :
    (l₁ ++ l₂).get ⟨n, h₂⟩ = l₂.get ⟨n - l₁.length, get_append_right_aux h₁ h₂⟩
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive (attr := simp)]
theorem prod_map_mul {α : Type*} [CommMonoid α] {l : List ι} {f g : ι → α} :
    (l.map fun i => f i * g i).prod = (l.map f).prod * (l.map g).prod
-- Mathlib/AlgebraicGeometry/Scheme.lean
theorem mem_basicOpen_top' {U : X.Opens} (f : Γ(X, U)) (x : X) :
    x ∈ X.basicOpen f ↔ ∃ (m : x ∈ U), IsUnit (X.presheaf.germ (⟨x, m⟩ : U) f)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addY_of_Z_ne_zero {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2) :
    W.addY P Q / addZ P Q ^ 3 = W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
      (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3))
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
theorem Set.Finite.of_summable_const [LinearOrderedAddCommGroup α] [TopologicalSpace α]
    [Archimedean α] [OrderClosedTopology α] {b : α} (hb : 0 < b) (hf : Summable fun _ : ι ↦ b) :
    (Set.univ : Set ι).Finite
-- Mathlib/Data/ENNReal/Basic.lean
theorem toNNReal_ne_zero : a.toNNReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ∞
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
/-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
lemma Full.of_comp_faithful [Full <| F ⋙ G] [G.Faithful] : Full F
-- Mathlib/CategoryTheory/Limits/Shapes/SplitEqualizer.lean
/-- A split equalizer diagram consists of morphisms

```
      ι   f
    W → X ⇉ Y
          g
```

satisfying `ι ≫ f = ι ≫ g` together with morphisms

```
      r   t
    W ← X ← Y
```

satisfying `ι ≫ r = 𝟙 W`, `g ≫ t = 𝟙 X` and `f ≫ t = r ≫ ι`.

The name "equalizer" is appropriate, since any split equalizer is a equalizer, see
`CategoryTheory.IsSplitEqualizer.isEqualizer`.
Split equalizers are also absolute, since a functor preserves all the structure above.
-/
structure IsSplitEqualizer {W : C} (ι : W ⟶ X) where
  /-- A map from `X` to the equalizer -/
  leftRetraction : X ⟶ W
  /-- A map in the opposite direction to `f` and `g` -/
  rightRetraction : Y ⟶ X
  /-- Composition of `ι` with `f` and with `g` agree -/
  condition : ι ≫ f = ι ≫ g := by aesop_cat
  /-- `leftRetraction` splits `ι` -/
  ι_leftRetraction : ι ≫ leftRetraction = 𝟙 W := by aesop_cat
  /-- `rightRetraction` splits `g` -/
  bottom_rightRetraction : g ≫ rightRetraction = 𝟙 X := by aesop_cat
  /-- `f` composed with `rightRetraction` is `leftRetraction` composed with `ι` -/
  top_rightRetraction : f ≫ rightRetraction = leftRetraction ≫ ι := by aesop_cat
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem map_sup (s t : Subsemiring R) (f : R →+* S) : (s ⊔ t).map f = s.map f ⊔ t.map f
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_neg_coe_angle {x : ℂ} (hx : x ≠ 0) : (arg (-x) : Real.Angle) = arg x + π
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[to_additive (attr := simp, norm_cast)]
lemma coe_mul_coe [SetLike S G] [DivInvMonoid G] [SubgroupClass S G] (H : S) :
    H * H = (H : Set G)
-- Mathlib/Tactic/Abel.lean
lemma subst_into_addg {α} [AddCommGroup α] (l r tl tr t)
    (prl : (l : α) = tl) (prr : r = tr) (prt : tl + tr = t) : l + r = t
-- Mathlib/Analysis/BoxIntegral/Partition/Additive.lean
/-- If `f` is a box additive function on subboxes of `I` and `π₁`, `π₂` are two prepartitions of
`I` that cover the same part of `I`, then `∑ J ∈ π₁.boxes, f J = ∑ J ∈ π₂.boxes, f J`. -/
theorem sum_boxes_congr [Finite ι] (f : ι →ᵇᵃ[I₀] M) (hI : ↑I ≤ I₀) {π₁ π₂ : Prepartition I}
    (h : π₁.iUnion = π₂.iUnion) : ∑ J ∈ π₁.boxes, f J = ∑ J ∈ π₂.boxes, f J
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
@[simp]
theorem eval₂_neg : (-p).eval₂ f g = -p.eval₂ f g
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem val_natCast {n : ℕ} (a : ℕ) : (a : ZMod n).val = a % n
-- Mathlib/LinearAlgebra/BilinearMap.lean
@[simp]
theorem compl₁₂_apply (f : Mₗ →ₗ[R] Nₗ →ₗ[R] Pₗ) (g : Qₗ →ₗ[R] Mₗ) (g' : Qₗ' →ₗ[R] Nₗ) (x : Qₗ)
    (y : Qₗ') : f.compl₁₂ g g' x y = f (g x) (g' y)
-- Mathlib/Data/Fintype/Card.lean
theorem card_congr {α β} [Fintype α] [Fintype β] (f : α ≃ β) : card α = card β
-- Mathlib/Data/Set/Sigma.lean
@[simp]
theorem singleton_sigma : ({i} : Set ι).sigma t = Sigma.mk i '' t i
-- Mathlib/Data/ENNReal/Basic.lean
theorem iInf_ne_top [CompleteLattice α] (f : ℝ≥0∞ → α) :
    ⨅ (x) (_ : x ≠ ∞), f x = ⨅ x : ℝ≥0, f x
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
/-- The function `exp(x)/x^n` tends to `+∞` at `+∞`, for any natural number `n` -/
theorem tendsto_exp_div_pow_atTop (n : ℕ) : Tendsto (fun x => exp x / x ^ n) atTop atTop
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem ae_le_of_ae_lt {β : Type*} [Preorder β] {f g : α → β} (h : ∀ᵐ x ∂μ, f x < g x) :
    f ≤ᵐ[μ] g
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval_assoc {τ} (f : σ → MvPolynomial τ R) (g : τ → R) (p : MvPolynomial σ R) :
    eval (eval g ∘ f) p = eval g (eval₂ C f p)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem Monic.natDegree_pos : 0 < natDegree p ↔ p ≠ 1
-- Mathlib/Topology/Inseparable.lean
@[simp]
theorem continuousAt_lift {hf : ∀ x y, (x ~ᵢ y) → f x = f y} :
    ContinuousAt (lift f hf) (mk x) ↔ ContinuousAt f x
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem utf8SetAux_of_valid (c' : Char) (cs cs' : List Char) {i p : Nat} (hp : i + utf8Len cs = p) :
    utf8SetAux c' (cs ++ cs') ⟨i⟩ ⟨p⟩ = cs ++ cs'.modifyHead fun _ => c'
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- `mongePointWeightsWithCircumcenter` sums to 1. -/
@[simp]
theorem sum_mongePointWeightsWithCircumcenter (n : ℕ) :
    ∑ i, mongePointWeightsWithCircumcenter n i = 1
-- Mathlib/Combinatorics/Additive/Corner/Defs.lean
/-- Corners are preserved under `2`-Freiman homomorphisms. --/
lemma IsCorner.image (hf : IsAddFreimanHom 2 s t f) (hAs : (A : Set (G × G)) ⊆ s ×ˢ s)
    (hA : IsCorner A x₁ y₁ x₂ y₂) : IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂)
-- Mathlib/Data/DFinsupp/Order.lean
@[simp, norm_cast]
lemma coe_orderEmbeddingToFun : ⇑(orderEmbeddingToFun (α := α)) = DFunLike.coe
-- Mathlib/Topology/Basic.lean
theorem IsClosed.not : IsClosed { a | p a } → IsOpen { a | ¬p a }
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem srange_eq_map (f : M →ₙ* N) : f.srange = (⊤ : Subsemigroup M).map f
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem withBotCongr_symm (e : α ≃o β) : e.withBotCongr.symm = e.symm.withBotCongr
-- Mathlib/RingTheory/Binomial.lean
theorem choose_smul_choose [NatPowAssoc R] (r : R) (n k : ℕ) (hkn : k ≤ n) :
    (Nat.choose n k) • choose r n = choose r k * choose (r - k) (n - k)
-- Mathlib/Algebra/Lie/Sl2.lean
lemma lie_lie_smul_f (t : IsSl2Triple h e f) : ⁅h, f⁆ = -((2 : R) • f)
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
nonrec theorem HasDerivWithinAt.const_smul (c : R) (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun y => c • f y) (c • f') s x
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem val_le_iff {s₁ s₂ : Finset α} : s₁.1 ≤ s₂.1 ↔ s₁ ⊆ s₂
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem image_mem_functorPushforward (R : Sieve X) {V} {f : V ⟶ X} (h : R f) :
    R.functorPushforward F (F.map f)
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
theorem of_h_eq_intFractPair_seq1_fst_b : (of v).h = (IntFractPair.seq1 v).fst.b
-- Mathlib/SetTheory/Cardinal/Divisibility.lean
theorem le_of_dvd : ∀ {a b : Cardinal}, b ≠ 0 → a ∣ b → a ≤ b
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
@[simp]
theorem Differentiable.div_const (hc : Differentiable 𝕜 c) (d : 𝕜') :
    Differentiable 𝕜 fun x => c x / d
-- Mathlib/Analysis/Normed/Group/Basic.lean
theorem norm_two : ‖(2 : ℝ)‖ = 2
-- Mathlib/Logic/Equiv/List.lean
theorem raise_lower' : ∀ {l n}, (∀ m ∈ l, n ≤ m) → List.Sorted (· < ·) l → raise' (lower' l n) n = l
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_eq_range_sigma (s : α → Set β) : ⋃ i, s i = range fun a : Σi, s i => a.2
-- Mathlib/CategoryTheory/Preadditive/Schur.lean
/-- Part of **Schur's lemma** for `𝕜`-linear categories:
the hom space between two non-isomorphic simple objects is 0-dimensional.
-/
theorem finrank_hom_simple_simple_eq_zero_of_not_iso [HasKernels C] [Linear 𝕜 C] {X Y : C}
    [Simple X] [Simple Y] (h : (X ≅ Y) → False) : finrank 𝕜 (X ⟶ Y) = 0
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.subset {t : Set E} (hf : ConvexOn 𝕜 t f) (hst : s ⊆ t) (hs : Convex 𝕜 s) :
    ConvexOn 𝕜 s f
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[sheaf_restrict]
lemma basicOpen_restrict (i : V ⟶ U) (f : Γ(X, U)) :
    X.basicOpen (f |_ₕ i) ≤ X.basicOpen f
-- Mathlib/Data/Complex/Exponential.lean
theorem isCauSeq_exp (z : ℂ) : IsCauSeq abs fun n => ∑ m ∈ range n, z ^ m / m.factorial
-- Mathlib/LinearAlgebra/FreeProduct/Basic.lean
@[aesop safe destruct] theorem lift_unique
    (f : FreeProduct R A →ₐ[R] B) (h : ∀ i, f ∘ₐ ι R A i = maps) :
    f = lift R A maps
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma shiftFunctorAdd'_add_zero_inv_app (a : A) (X : C) :
    (shiftFunctorAdd' C a 0 a (add_zero a)).inv.app X =
    (shiftFunctorZero C A).hom.app (X⟦a⟧)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem lt_lift_iff {a : Cardinal.{u}} {b : Cardinal.{max u v}} :
    b < lift.{v, u} a ↔ ∃ a', lift.{v, u} a' = b ∧ a' < a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem preimage_mono_ae {s t : Set β} (hf : QuasiMeasurePreserving f μa μb) (h : s ≤ᵐ[μb] t) :
    f ⁻¹' s ≤ᵐ[μa] f ⁻¹' t
-- Mathlib/Topology/ContinuousOn.lean
theorem IsOpen.ite {s s' t : Set α} (hs : IsOpen s) (hs' : IsOpen s')
    (ht : s ∩ frontier t = s' ∩ frontier t) : IsOpen (t.ite s s')
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocMod_sub' (a b : α) : toIocMod hp (a - p) b = toIocMod hp a b - p
-- Mathlib/Data/Set/Subsingleton.lean
theorem subsingleton_of_forall_eq (a : α) (h : ∀ b ∈ s, b = a) : s.Subsingleton
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Ici : (some : α → WithBot α) ⁻¹' Ici a = Ici a
-- Mathlib/Algebra/DirectLimit.lean
theorem lift_of {i} (x) : lift R ι G f g Hg (of R ι G f i x) = g i x
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp 500)]
theorem isUnit_iff : IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a
-- Mathlib/Algebra/BigOperators/Ring/Nat.lean
lemma even_sum_iff_even_card_odd {s : Finset ι} (f : ι → ℕ) :
    Even (∑ i ∈ s, f i) ↔ Even (s.filter fun x ↦ Odd (f x)).card
-- Mathlib/Probability/Process/Filtration.lean
@[norm_cast]
theorem coeFn_sup {f g : Filtration ι m} : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g
-- Mathlib/Data/Finset/SMulAntidiagonal.lean
@[to_additive]
theorem IsPWO.smul [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P]
    {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s • t)
-- Mathlib/Algebra/Quaternion.lean
nonrec theorem self_add_star' : a + star a = ↑(2 * a.re)
-- Mathlib/SetTheory/Game/Basic.lean
theorem inv_one_equiv : (1⁻¹ : PGame) ≈ 1
-- Mathlib/Data/Sym/Sym2.lean
/-- `Sym2.map` as an embedding. -/
@[simps]
def _root_.Function.Embedding.sym2Map (f : α ↪ β) : Sym2 α ↪ Sym2 β
-- Mathlib/LinearAlgebra/Span.lean
lemma _root_.LinearMap.range_domRestrict_eq_range_iff {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M} :
    LinearMap.range (f.domRestrict S) = LinearMap.range f ↔ S ⊔ (LinearMap.ker f) = ⊤
-- Mathlib/Data/Set/Function.lean
lemma bijOn_of_subsingleton [Subsingleton α] (f : α → α) (s : Set α) : BijOn f s s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem continuousAt_arctan {x : ℝ} : ContinuousAt arctan x
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma exact_of_isZero_X₂ (h : IsZero S.X₂) : S.Exact
-- Mathlib/Logic/Denumerable.lean
@[simp]
theorem prod_nat_ofNat : ofNat (ℕ × ℕ) = unpair
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive (attr := simp)]
theorem prod_pi_mulSingle' [DecidableEq α] (a : α) (x : β) (s : Finset α) :
    ∏ a' ∈ s, Pi.mulSingle a x a' = if a ∈ s then x else 1
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
@[simps!]
instance : Category (SimplicialObject C)
-- Mathlib/Data/List/Join.lean
/-- See `List.length_join` for the corresponding statement using `List.sum`. -/
lemma length_join' (L : List (List α)) : length (join L) = Nat.sum (map length L)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem coe_bot : ((⊥ : NonUnitalSubring R) : Set R) = {0}
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem map_setToSimpleFunc (T : Set α → F →L[ℝ] F') (h_add : FinMeasAdditive μ T) {f : α →ₛ G}
    (hf : Integrable f μ) {g : G → F} (hg : g 0 = 0) :
    (f.map g).setToSimpleFunc T = ∑ x ∈ f.range, T (f ⁻¹' {x}) (g x)
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem stabilizer_eq_centralizer (g : G) :
    stabilizer (ConjAct G) g = centralizer (zpowers (toConjAct g) : Set (ConjAct G))
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_emetric_closedBall (a : ℝ) (r : ℝ≥0∞) : volume (EMetric.closedBall a r) = 2 * r
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem intrinsicFrontier_singleton (x : P) : intrinsicFrontier 𝕜 ({x} : Set P) = ∅
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem mk_ordinal_out (o : Ordinal) : #o.out.α = o.card
-- Mathlib/CategoryTheory/Preadditive/Schur.lean
theorem finrank_hom_simple_simple_eq_zero_iff (X Y : C) [FiniteDimensional 𝕜 (X ⟶ X)]
    [FiniteDimensional 𝕜 (X ⟶ Y)] [Simple X] [Simple Y] :
    finrank 𝕜 (X ⟶ Y) = 0 ↔ IsEmpty (X ≅ Y)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csInf_mem (hs : s.Nonempty) : sInf s ∈ s
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem sUnion_singleton (s : Set α) : ⋃₀{s} = s
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
theorem Ideal.mk_eq_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R) :
    Ideal.Quotient.mk (I ^ m) (r.val n) = Ideal.Quotient.mk (I ^ m) (r.val m)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive] lemma card_le_card_div_right (ht : t.Nonempty) : s.card ≤ (s / t).card
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem zero_coeff (n : ℕ) : (0 : 𝕎 R).coeff n = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] protected theorem zero_mul : ∀ (n : Nat), 0 * n = 0
-- Mathlib/MeasureTheory/Measure/Restrict.lean
/-- If two measurable sets are ae_eq then any proposition that is almost everywhere true on one
is almost everywhere true on the other -/
theorem ae_restrict_congr_set {s t} (hst : s =ᵐ[μ] t) {p : α → Prop} :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ x ∂μ.restrict t, p x
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_strictMono_of_surjective : StrictMono (comap f)
-- Mathlib/Logic/Basic.lean
theorem congr_arg_refl {α β : Sort*} (f : α → β) (a : α) :
    congr_arg f (Eq.refl a) = Eq.refl (f a)
-- Mathlib/Data/Num/Lemmas.lean
theorem of_to_int' : ∀ n : ZNum, ZNum.ofInt' n = n
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [CoalgHomClass F R A B] (f : F) :
    ⇑(f : A →ₗc[R] B) = f
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- The functor from the arrow category of `C` to `C` itself that maps a morphism to its image
    and a commutative square to the induced morphism on images. -/
@[simps]
def im : Arrow C ⥤ C
-- Mathlib/Analysis/Normed/Group/Completeness.lean
lemma Metric.exists_subseq_summable_dist_of_cauchySeq (u : ℕ → α) (hu : CauchySeq u) :
    ∃ f : ℕ → ℕ, StrictMono f ∧ Summable fun i => dist (u (f (i+1))) (u (f i))
-- Mathlib/GroupTheory/CoprodI.lean
@[elab_as_elim]
theorem induction_left {C : CoprodI M → Prop} (m : CoprodI M) (one : C 1)
    (mul : ∀ {i} (m : M i) x, C x → C (of m * x)) : C m
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp]
protected theorem add_left_inj (i j k : Int) : (k + i = k + j) ↔ i = j
-- Mathlib/Topology/Basic.lean
/-- See also `interior_preimage_subset_preimage_interior`. -/
theorem preimage_interior_subset_interior_preimage {t : Set Y} (hf : Continuous f) :
    f ⁻¹' interior t ⊆ interior (f ⁻¹' t)
-- Mathlib/Algebra/Homology/HomologySequence.lean
@[reassoc (attr := simp)]
lemma homologyι_opcyclesToCycles :
    K.homologyι i ≫ K.opcyclesToCycles i j = 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem Orthonormal.equiv_refl {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v) :
    hv.equiv hv (Equiv.refl ι) = LinearIsometryEquiv.refl 𝕜 E