ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
/-- `P⁺` is always separated. -/
theorem sep {X : C} (P : Cᵒᵖ ⥤ D) (S : J.Cover X) (x y : (J.plusObj P).obj (op X))
    (h : ∀ I : S.Arrow, (J.plusObj P).map I.f.op x = (J.plusObj P).map I.f.op y) : x = y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma dblZ_ne_zero_of_Y_ne [NoZeroDivisors R] {P Q : Fin 3 → R} (hP : W'.Equation P)
    (hQ : W'.Equation Q) (hPz : P z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2)
    (hy : P y * Q z ^ 3 ≠ Q y * P z ^ 3) : W'.dblZ P ≠ 0
-- Mathlib/Topology/Instances/ENNReal.lean
@[fun_prop]
theorem continuous_coe : Continuous ((↑) : ℝ≥0 → ℝ≥0∞)
-- Mathlib/SetTheory/Game/PGame.lean
/-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later. -/
theorem le_def {x y : PGame} :
    x ≤ y ↔
      (∀ i, (∃ i', x.moveLeft i ≤ y.moveLeft i') ∨ ∃ j, (x.moveLeft i).moveRight j ≤ y) ∧
        ∀ j, (∃ i, x ≤ (y.moveRight j).moveLeft i) ∨ ∃ j', x.moveRight j' ≤ y.moveRight j
-- Mathlib/Data/Finset/Sups.lean
theorem sups_left_comm : s ⊻ (t ⊻ u) = t ⊻ (s ⊻ u)
-- Mathlib/SetTheory/Game/PGame.lean
@[trans]
theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_left_left : IsRelPrime (y * z + x) y
-- Mathlib/Order/CompleteLattice.lean
theorem down_sSup [SupSet α] (s : Set (ULift.{v} α)) : (sSup s).down = sSup (ULift.up ⁻¹' s)
-- Mathlib/Logic/Basic.lean
theorem congr_fun_rfl {α β : Sort*} (f : α → β) (a : α) : congr_fun (Eq.refl f) a = Eq.refl (f a)
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
theorem Ici_add_bij : BijOn (· + d) (Ici a) (Ici (a + d))
-- Mathlib/Data/Set/Function.lean
theorem range_restrictPreimage : range (t.restrictPreimage f) = Subtype.val ⁻¹' range f
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem invRev_surjective : Function.Surjective (@invRev α)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem neighborSet_subgraphOfAdj [DecidableEq V] {u v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet u =
    (if u = v then {w} else ∅) ∪ if u = w then {v} else ∅
-- Mathlib/Tactic/PushNeg.lean
theorem not_and_or_eq : (¬ (p ∧ q)) = (¬ p ∨ ¬ q)
-- Mathlib/Order/Filter/Basic.lean
theorem map_swap_eq_comap_swap {f : Filter (α × β)} : Prod.swap <$> f = comap Prod.swap f
-- Mathlib/Combinatorics/Colex.lean
/-- For finsets of naturals, the colexicographic order is equivalent to the order induced by the
`n`-ary expansion. -/
lemma geomSum_le_geomSum_iff_toColex_le_toColex (hn : 2 ≤ n) :
    ∑ k ∈ s, n ^ k ≤ ∑ k ∈ t, n ^ k ↔ toColex s ≤ toColex t
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem isSuccLimit_zero : IsSuccLimit (0 : Ordinal)
-- Mathlib/CategoryTheory/Monoidal/Linear.lean
/-- A category is `MonoidalLinear R` if tensoring is `R`-linear in both factors.
-/
class MonoidalLinear [MonoidalPreadditive C] : Prop where
  whiskerLeft_smul : ∀ (X : C) {Y Z : C} (r : R) (f : Y ⟶ Z) , X ◁ (r • f) = r • (X ◁ f) := by
    aesop_cat
  smul_whiskerRight : ∀ (r : R) {Y Z : C} (f : Y ⟶ Z) (X : C), (r • f) ▷ X = r • (f ▷ X) := by
    aesop_cat
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem roots_def [DecidableEq R] (p : R[X]) [Decidable (p = 0)] :
    p.roots = if h : p = 0 then ∅ else Classical.choose (exists_multiset_roots h)
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[ext]
lemma hom_ext {X Y : HopfAlgebraCat.{v} R} (f g : X ⟶ Y) (h : f.toBialgHom = g.toBialgHom) :
    f = g
-- Mathlib/Data/Set/Image.lean
theorem compl_image : image (compl : Set α → Set α) = preimage compl
-- Mathlib/CategoryTheory/Triangulated/TStructure/Basic.lean
lemma GE_antitone : Antitone t.GE
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem MultilinearMap.curry_uncurryRight
    (f : MultilinearMap R (fun i : Fin n => M (castSucc i)) (M (last n) →ₗ[R] M₂)) :
    f.uncurryRight.curryRight = f
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem mul_div_eq_iff_isRoot : (X - C a) * (p / (X - C a)) = p ↔ IsRoot p a
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem le_nfp (f a) : a ≤ nfp f a
-- Mathlib/Analysis/Calculus/Monotone.lean
/-- A monotone real function is differentiable Lebesgue-almost everywhere. -/
theorem Monotone.ae_differentiableAt {f : ℝ → ℝ} (hf : Monotone f) :
    ∀ᵐ x, DifferentiableAt ℝ f x
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem leadingCoeff_of_ne {x : HahnSeries Γ R} (hx : x ≠ 0) :
    x.leadingCoeff = x.coeff (x.isWF_support.min (support_nonempty_iff.2 hx))
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_inf (p p' : Subfield K) : ((p ⊓ p' : Subfield K) : Set K) = p.carrier ∩ p'.carrier
-- Mathlib/Data/Matrix/Basic.lean
theorem vecMul_mulVec [Fintype m] [Fintype n] (A : Matrix m n α) (B : Matrix m o α) (x : n → α) :
    (A *ᵥ x) ᵥ* B = x ᵥ* (Aᵀ * B)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem biUnion_le_iff {πi : ∀ J, Prepartition J} {π' : Prepartition I} :
    π.biUnion πi ≤ π' ↔ ∀ J ∈ π, πi J ≤ π'.restrict J
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem comap_coe_nhdsWithin_Ioi_of_Ioo_subset (ha : s ⊆ Ioi a)
    (hs : s.Nonempty → ∃ b > a, Ioo a b ⊆ s) : comap ((↑) : s → α) (𝓝[>] a) = atBot
-- Mathlib/Data/List/Sort.lean
protected theorem Sorted.nodup {r : α → α → Prop} [IsIrrefl α r] {l : List α} (h : Sorted r l) :
    Nodup l
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
@[reassoc]
lemma mapLeftHomologyIso_hom_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    leftHomologyMap (F.mapShortComplex.map φ) ≫ (S₂.mapLeftHomologyIso F).hom =
      (S₁.mapLeftHomologyIso F).hom ≫ F.map (leftHomologyMap φ)
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[simp]
theorem KernelFork.ι_ofι {X Y P : C} (f : X ⟶ Y) (ι : P ⟶ X) (w : ι ≫ f = 0) :
    Fork.ι (KernelFork.ofι ι w) = ι
-- Mathlib/CategoryTheory/Opposites.lean
/-- Given a natural transformation `α : F ⟶ G`, for `F G : Cᵒᵖ ⥤ D`,
taking `op` of each component gives a natural transformation `G.rightOp ⟶ F.rightOp`.
-/
@[simps]
protected def rightOp (α : F ⟶ G) : G.rightOp ⟶ F.rightOp
-- Mathlib/Data/NNReal/Basic.lean
theorem coe_nsmul (r : ℝ≥0) (n : ℕ) : ↑(n • r) = n • (r : ℝ)
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
lemma dotProduct_nonneg_of_nonneg {v w : n → R} (hv : 0 ≤ v) (hw : 0 ≤ w) : 0 ≤ dotProduct v w
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
lemma measurableSet_bddAbove_range {ι} [Countable ι] {f : ι → δ → α} (hf : ∀ i, Measurable (f i)) :
    MeasurableSet {b | BddAbove (range (fun i ↦ f i b))}
-- Mathlib/Analysis/Complex/ReImTopology.lean
@[simp]
theorem frontier_setOf_im_le (a : ℝ) : frontier { z : ℂ | z.im ≤ a } = { z | z.im = a }
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem isOpen_preimage (h : X ≃ₜ Y) {s : Set Y} : IsOpen (h ⁻¹' s) ↔ IsOpen s
-- Mathlib/Data/DFinsupp/NeLocus.lean
theorem zipWith_neLocus_eq_left [∀ a, DecidableEq (N a)] [∀ a, DecidableEq (P a)]
    {F : ∀ a, M a → N a → P a} (F0 : ∀ a, F a 0 0 = 0) (f : Π₀ a, M a) (g₁ g₂ : Π₀ a, N a)
    (hF : ∀ a f, Function.Injective fun g ↦ F a f g) :
    (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) = g₁.neLocus g₂
-- Mathlib/Data/Finsupp/Fin.lean
theorem tail_apply : tail t i = t i.succ
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast] lemma coe_eq_one : (r : ℝ) = 1 ↔ r = 1
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[to_additive (attr := simp) pi_norm_const]
lemma pi_norm_const' [Nonempty ι] (a : E) : ‖fun _i : ι => a‖ = ‖a‖
-- Mathlib/RingTheory/Localization/InvSubmonoid.lean
theorem finiteType_of_monoid_fg [Monoid.FG M] : Algebra.FiniteType R S
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- In the case that `n = ∞` we don't need the continuity assumption in
`HasFTaylorSeriesUpTo`. -/
theorem hasFTaylorSeriesUpTo_top_iff' :
    HasFTaylorSeriesUpTo ∞ f p ↔
      (∀ x, (p x 0).uncurry0 = f x) ∧
        ∀ (m : ℕ) (x), HasFDerivAt (fun y => p y m) (p x m.succ).curryLeft x
-- Mathlib/Data/Set/Lattice.lean
theorem image2_iUnion₂_left (s : ∀ i, κ i → Set α) (t : Set β) :
    image2 f (⋃ (i) (j), s i j) t = ⋃ (i) (j), image2 f (s i j) t
-- Mathlib/Topology/Category/TopCat/Basic.lean
lemma hom_apply {X Y : TopCat} (f : X ⟶ Y) (x : X) : f x = ContinuousMap.toFun f x
-- Mathlib/Topology/Homotopy/Product.lean
/-- The product of homotopies `F` and `G`,
  where `F` takes `f₀` to `f₁` and `G` takes `g₀` to `g₁` -/
@[simps]
def Homotopy.prod (F : Homotopy f₀ f₁) (G : Homotopy g₀ g₁) :
    Homotopy (ContinuousMap.prodMk f₀ g₀) (ContinuousMap.prodMk f₁ g₁)
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- If a vector space has a finite basis, then it is finite-dimensional. -/
theorem of_fintype_basis {ι : Type w} [Finite ι] (h : Basis ι K V) : FiniteDimensional K V
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem swap_smul_self_smul [MulAction (Perm α) β] (i j : α) (x : β) :
    swap i j • swap i j • x = x
-- Mathlib/Order/Bounds/Basic.lean
lemma mem_upperBounds_iff_subset_Iic : a ∈ upperBounds s ↔ s ⊆ Iic a
-- Mathlib/Data/Nat/Log.lean
@[mono]
theorem clog_anti_left {b c n : ℕ} (hc : 1 < c) (hb : c ≤ b) : clog b n ≤ clog c n
-- Mathlib/NumberTheory/DiophantineApproximation.lean
private theorem aux₃ :
    |(fract ξ)⁻¹ - v / (u - ⌊ξ⌋ * v)| < (((u : ℝ) - ⌊ξ⌋ * v) * (2 * (u - ⌊ξ⌋ * v) - 1))⁻¹
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc (attr := simp)]
lemma inlX_desc_f (i j : ι) (hjk : c.Rel j i) :
    inlX φ i j hjk ≫ (desc φ α hα).f j = hα.hom i j
-- Mathlib/CategoryTheory/Limits/Shapes/SplitCoequalizer.lean
/--
The pair `f,g` is a split pair if there is an `h : Y ⟶ Z` so that `f, g, h` forms a split
coequalizer in `C`.
-/
class HasSplitCoequalizer : Prop where
  /-- There is some split coequalizer -/
  splittable : ∃ (Z : C) (h : Y ⟶ Z), Nonempty (IsSplitCoequalizer f g h)
-- Mathlib/Data/NNReal/Basic.lean
theorem div_le_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a / r ≤ b ↔ a ≤ b * r
-- Mathlib/Topology/List.lean
theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
lemma map_smul_of_iInf_genEigenspace_ne_bot [NoZeroSMulDivisors R M]
    {L F : Type*} [SMul R L] [FunLike F L (End R M)] [MulActionHomClass F R L (End R M)] (f : F)
    (μ : L → R) (h_ne : ⨅ x, ⨆ k, (f x).genEigenspace (μ x) k ≠ ⊥)
    (t : R) (x : L) :
    μ (t • x) = t • μ x
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/TensorProduct.lean
lemma PrimeSpectrum.embedding_tensorProductTo_of_surjectiveOnStalks :
    Embedding (tensorProductTo R S T)
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
@[simp]
theorem divOf_zero (x : k[G]) : x /ᵒᶠ 0 = x
-- Mathlib/Data/Int/Bitwise.lean
theorem bitwise_xor : bitwise xor = Int.xor
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Ici_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ici a = Iic (a / c)
-- Mathlib/Topology/UniformSpace/Basic.lean
@[simp]
theorem mem_idRel {a b : α} : (a, b) ∈ @idRel α ↔ a = b
-- Mathlib/Algebra/Module/LocalizedModule.lean
@[simp]
theorem zero_mk (s : S) : mk (0 : M) s = 0
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem coe_zero : ((0 : A →⋆ₙ+* B) : A → B) = 0
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem comap_strictMono_of_surjective : StrictMono (comap f)
-- Mathlib/Data/PNat/Prime.lean
theorem coe_pnat_injective : Function.Injective ((↑) : Nat.Primes → ℕ+)
-- Mathlib/Data/Nat/Cast/Order/Ring.lean
/-- See also `Nat.ofNat_pos`, specialised for an `OrderedSemiring`. -/
-- See note [no_index around OfNat.ofNat]
@[simp low]
theorem ofNat_pos' {n : ℕ} [n.AtLeastTwo] : 0 < (no_index (OfNat.ofNat n : α))
-- Mathlib/Data/Nat/PartENat.lean
theorem get_eq_iff_eq_coe {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = b
-- Mathlib/Deprecated/Subgroup.lean
theorem Additive.isAddSubgroup_iff {s : Set G} : @IsAddSubgroup (Additive G) _ s ↔ IsSubgroup s
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem card_interedges_finpartition [DecidableEq α] [DecidableEq β] (P : Finpartition s)
    (Q : Finpartition t) :
    (interedges r s t).card = ∑ ab ∈ P.parts ×ˢ Q.parts, (interedges r ab.1 ab.2).card
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem hasNext_cons_addChar (c : Char) (cs : List Char) (i : Pos) :
    hasNext ⟨⟨c :: cs⟩, i + c⟩ = hasNext ⟨⟨cs⟩, i⟩
-- Mathlib/Algebra/RingQuot.lean
theorem Rel.sub_right {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r b c) :
    Rel r (a - b) (a - c)
-- Mathlib/Data/Nat/ModEq.lean
protected theorem comm : a ≡ b [MOD n] ↔ b ≡ a [MOD n]
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem adjugate_reindex (e : m ≃ n) (A : Matrix m m α) :
    adjugate (reindex e e A) = reindex e e (adjugate A)
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive (attr := simp)]
theorem mulIndicator_self_mul_compl (s : Set α) (f : α → M) :
    mulIndicator s f * mulIndicator sᶜ f = f
-- Mathlib/CategoryTheory/Limits/EssentiallySmall.lean
theorem hasCoproductsOfShape_of_small (β : Type w₂) [Small.{w₁} β] [HasCoproducts.{w₁} C] :
    HasCoproductsOfShape β C
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
theorem Filter.Tendsto.rpow {l : Filter α} {f g : α → ℝ} {x y : ℝ} (hf : Tendsto f l (𝓝 x))
    (hg : Tendsto g l (𝓝 y)) (h : x ≠ 0 ∨ 0 < y) : Tendsto (fun t => f t ^ g t) l (𝓝 (x ^ y))
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem mono_pre (m : Set X → ℝ≥0∞) {r r' : ℝ≥0∞} (h : r ≤ r') : pre m r' ≤ pre m r
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem dual_comp (g : SupHom β γ) (f : SupHom α β) :
    SupHom.dual (g.comp f) = (SupHom.dual g).comp (SupHom.dual f)
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem leadingCoeff_add_eq_left {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x.orderTop < y.orderTop) : (x + y).leadingCoeff = x.leadingCoeff
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem principalUnitGroupEquiv_apply (a : A.principalUnitGroup) :
    (((principalUnitGroupEquiv A a : Aˣ) : A) : K) = (a : Kˣ)
-- Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
@[simp] theorem ofBaseChangeAux_ι (Q : QuadraticForm R V) (v : V) :
    ofBaseChangeAux A Q (ι Q v) = ι (Q.baseChange A) (1 ⊗ₜ v)
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[simp]
theorem reindex_refl : reindex R s (Equiv.refl ι) = LinearEquiv.refl R _
-- Mathlib/CategoryTheory/EqToHom.lean
theorem dcongr_arg {ι : Type*} {F G : ι → C} (α : ∀ i, F i ⟶ G i) {i j : ι} (h : i = j) :
    α i = eqToHom (congr_arg F h) ≫ α j ≫ eqToHom (congr_arg G h.symm)
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
lemma homMk'_comp (f : StructuredArrow S T) (g : f.right ⟶ Y') (g' : Y' ⟶ Y'') :
    homMk' f (g ≫ g') = homMk' f g ≫ homMk' (mk (f.hom ≫ T.map g)) g' ≫ eqToHom (by simp)
-- Mathlib/RingTheory/WittVector/InitTail.lean
theorem select_add_select_not : ∀ x : 𝕎 R, select P x + select (fun i => ¬P i) x = x
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
theorem piIsoPi_inv_π_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : ∀ i, α i) :
    (Pi.π α i : _) ((piIsoPi α).inv x) = x i
-- Mathlib/Algebra/DirectLimit.lean
nonrec theorem Polynomial.exists_of [Nonempty ι] [IsDirected ι (· ≤ ·)]
    (q : Polynomial (DirectLimit G fun i j h => f' i j h)) :
    ∃ i p, Polynomial.map (of G (fun i j h => f' i j h) i) p = q
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem add_eq_right ⦃x y : Tropical R⦄ (h : y ≤ x) : x + y = y
-- Mathlib/Data/List/Sublists.lean
@[simp]
theorem nodup_sublists' {l : List α} : Nodup (sublists' l) ↔ Nodup l
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
lemma exactAt_iff_isZero_homology [K.HasHomology i] :
    K.ExactAt i ↔ IsZero (K.homology i)
-- Mathlib/NumberTheory/LSeries/Convolution.lean
lemma convolution_def {R : Type*} [Semiring R] (f g : ℕ → R) :
    f ⍟ g = fun n ↦ ∑ p ∈ n.divisorsAntidiagonal, f p.1 * g p.2
-- Mathlib/Data/Multiset/Nodup.lean
theorem not_nodup_pair : ∀ a : α, ¬Nodup (a ::ₘ a ::ₘ 0)
-- Mathlib/GroupTheory/Submonoid/Centralizer.lean
@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M
-- Mathlib/Data/Set/Basic.lean
/-- If `h : a ∈ {x | p x}` then `h.out : p x`. These are definitionally equal, but this can
nevertheless be useful for various reasons, e.g. to apply further projection notation or in an
argument to `simp`. -/
theorem _root_.Membership.mem.out {p : α → Prop} {a : α} (h : a ∈ { x | p x }) : p a
-- Mathlib/LinearAlgebra/Quotient.lean
@[simp]
theorem restrictScalarsEquiv_symm_mk [Ring S] [SMul S R] [Module S M] [IsScalarTower S R M]
    (P : Submodule R M) (x : M) :
    (restrictScalarsEquiv S P).symm ((mk : M → M ⧸ P) x) = (mk : M → M ⧸ P) x
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem nextCoeff_pow (hp : p.Monic) (n : ℕ) : (p ^ n).nextCoeff = n • p.nextCoeff
-- Mathlib/Data/Set/Card.lean
theorem ncard_lt_ncard_iff_ncard_diff_lt_ncard_diff (hs : s.Finite := by toFinite_tac)
    (ht : t.Finite := by toFinite_tac) : s.ncard < t.ncard ↔ (s \ t).ncard < (t \ s).ncard
-- Mathlib/Order/Bounds/Basic.lean
@[simp] theorem isGLB_singleton : IsGLB {a} a
-- Mathlib/Order/WellFounded.lean
@[simp]
theorem argminOn_mem (s : Set α) (hs : s.Nonempty) : argminOn f h s hs ∈ s
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem forall_imp (h : ∀ a, p a → q a) : (∀ a, p a) → ∀ a, q a
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_comap_le : (K.comap f).map f ≤ K
-- Mathlib/Topology/MetricSpace/CantorScheme.lean
protected theorem Antitone.closureAntitone [TopologicalSpace α] (hanti : CantorScheme.Antitone A)
    (hclosed : ∀ l, IsClosed (A l)) : ClosureAntitone A
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.swap' (x y : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) : y :: x :: l₁ ~ x :: y :: l₂
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem iUnion_eq (h : π.IsPartition) : π.iUnion = I
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem AEMeasurable.const_mul [MeasurableMul M] (hf : AEMeasurable f μ) (c : M) :
    AEMeasurable (fun x => c * f x) μ
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_exp_mul_complex {c : ℂ} (hc : c ≠ 0) :
    (∫ x in a..b, Complex.exp (c * x)) = (Complex.exp (c * b) - Complex.exp (c * a)) / c
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
@[simp]
theorem pre_id (A : C) [Exponentiable A] : pre (𝟙 A) = 𝟙 _
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem support_monomial_subset : (monomial s a).support ⊆ {s}
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem _root_.fourierIntegral_gaussian (hb : 0 < b.re) (t : ℂ) :
    ∫ x : ℝ, cexp (I * t * x) * cexp (-b * x ^ 2) =
    (π / b) ^ (1 / 2 : ℂ) * cexp (-t ^ 2 / (4 * b))
-- Mathlib/Probability/Independence/ZeroOne.lean
/-- **Kolmogorov's 0-1 law** : any event in the tail σ-algebra of an independent sequence of
sub-σ-algebras has probability 0 or 1. -/
theorem measure_zero_or_one_of_measurableSet_limsup_atBot (h_le : ∀ n, s n ≤ m0)
    (h_indep : iIndep s μ) {t : Set Ω} (ht_tail : MeasurableSet[limsup s atBot] t) :
    μ t = 0 ∨ μ t = 1
-- Mathlib/RingTheory/Localization/Cardinality.lean
/-- If you do not localize at any zero-divisors, localization preserves cardinality. -/
theorem card (hS : S ≤ R⁰) : #R = #L
-- Mathlib/Order/Basic.lean
theorem instPartialOrder.dual_dual (α : Type*) [H : PartialOrder α] :
    OrderDual.instPartialOrder αᵒᵈ = H
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive zsmul_neg]
lemma inv_zpow (a : α) : ∀ n : ℤ, a⁻¹ ^ n = (a ^ n)⁻¹
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
theorem slope_comm (f : k → PE) (a b : k) : slope f a b = slope f b a
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pullbackConeOfLeftIso_x : (pullbackConeOfLeftIso f g).pt = Y
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
theorem ext {A B : StructuredArrow S T} (f g : A ⟶ B) : f.right = g.right → f = g
-- Mathlib/Order/UpperLower/Basic.lean
theorem prod_sup_prod : s₁ ×ˢ t₁ ⊔ s₂ ×ˢ t₂ = (s₁ ⊔ s₂) ×ˢ (t₁ ⊔ t₂)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem compContinuous_apply {δ : Type*} [TopologicalSpace δ] (f : α →ᵇ β) (g : C(δ, α)) (x : δ) :
    f.compContinuous g x = f (g x)
-- Mathlib/Logic/Function/Basic.lean
theorem Surjective.injective_comp_right (hf : Surjective f) : Injective fun g : β → γ ↦ g ∘ f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
lemma arccos_eq_of_eq_cos (hy₀ : 0 ≤ y) (hy₁ : y ≤ π) (hxy : x = cos y) : arccos x = y
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem continuousAt_extend_symm' {x : E} (h : x ∈ (f.extend I).target) :
    ContinuousAt (f.extend I).symm x
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp] lemma natDegree_mul_X (hp : p ≠ 0) : natDegree (p * X) = natDegree p + 1
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ioo_Ici {a b : α} (c : Ioo a b) : Subtype.val '' Ici c = Ico c.1 b
-- Mathlib/Topology/Instances/ENNReal.lean
/-- If `edist (f n) (f (n+1))` is bounded above by a function `d : ℕ → ℝ≥0∞`,
then the distance from `f 0` to the limit is bounded by `∑'_{k=0}^∞ d k`. -/
theorem edist_le_tsum_of_edist_le_of_tendsto₀ {f : ℕ → α} (d : ℕ → ℝ≥0∞)
    (hf : ∀ n, edist (f n) (f n.succ) ≤ d n) {a : α} (ha : Tendsto f atTop (𝓝 a)) :
    edist (f 0) a ≤ ∑' m, d m
-- Mathlib/Util/Qq.lean
theorem QuotedDefEq.rfl {u : Level} {α : Q(Sort u)} {a : Q($α)} : @QuotedDefEq u α a a
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem disjoint_append_right : Disjoint l (l₁ ++ l₂) ↔ Disjoint l l₁ ∧ Disjoint l l₂
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
/-- An algebraic integer whose conjugates are all of norm one is a root of unity. -/
theorem pow_eq_one_of_norm_eq_one {x : K} (hxi : IsIntegral ℤ x) (hx : ∀ φ : K →+* A, ‖φ x‖ = 1) :
    ∃ (n : ℕ) (_ : 0 < n), x ^ n = 1
-- Mathlib/Combinatorics/Quiver/Path.lean
lemma nil_ne_cons (p : Path a b) (e : b ⟶ a) : Path.nil ≠ p.cons e
-- Mathlib/Data/Set/Pointwise/ListOfFn.lean
@[to_additive]
theorem mem_list_prod {l : List (Set α)} {a : α} :
    a ∈ l.prod ↔
      ∃ l' : List (Σs : Set α, ↥s),
        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem natAbs_dvd_natAbs {a b : Int} : natAbs a ∣ natAbs b ↔ a ∣ b
-- Mathlib/Order/Lattice.lean
@[simp]
theorem mk_inf_mk [Inf α] [Inf β] (a₁ a₂ : α) (b₁ b₂ : β) :
    (a₁, b₁) ⊓ (a₂, b₂) = (a₁ ⊓ a₂, b₁ ⊓ b₂)
-- Mathlib/Algebra/Order/Pointwise.lean
theorem smul_Iic : r • Iic a = Iic (r • a)
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem disjoint_sSup_iff {s : Set α} : Disjoint a (sSup s) ↔ ∀ b ∈ s, Disjoint a b
-- Mathlib/Order/Filter/SmallSets.lean
@[simp]
lemma tendsto_image_smallSets {f : α → β} :
    Tendsto (f '' ·) la.smallSets lb.smallSets ↔ Tendsto f la lb
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Square.lean
lemma IsPushout.map (h : sq.IsPushout) (F : C ⥤ D) [PreservesColimit (span sq.f₁₂ sq.f₁₃) F] :
    (sq.map F).IsPushout
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc (attr := simp)]
lemma inlX_fstX (i j : ι ) (hij : c.Rel j i) :
    inlX φ i j hij ≫ fstX φ j i hij = 𝟙 _
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem coe_mul (x y : S) : (↑(x * y) : A) = ↑x * ↑y
-- Mathlib/CategoryTheory/Skeletal.lean
theorem map_comp_eq (F : E ⥤ D) (G : D ⥤ C) : map (F ⋙ G) = map F ⋙ map G
-- Mathlib/Data/Int/GCD.lean
theorem gcd_eq_right {i j : ℤ} (H : j ∣ i) : gcd i j = natAbs j
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem add_ofFin (x : BitVec n) (y : Fin (2^n)) :
  x + .ofFin y = .ofFin (x.toFin + y)
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem gcd_greatest {a b d : ℕ} (hda : d ∣ a) (hdb : d ∣ b) (hd : ∀ e : ℕ, e ∣ a → e ∣ b → e ∣ d) :
    d = a.gcd b
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- If `f` is integrable, then `∫ x in s, f x ∂μ` is absolutely continuous in `s`: it tends
to zero as `μ s` tends to zero. -/
theorem Integrable.tendsto_setIntegral_nhds_zero {ι} {f : α → G} (hf : Integrable f μ)
    {l : Filter ι} {s : ι → Set α} (hs : Tendsto (μ ∘ s) l (𝓝 0)) :
    Tendsto (fun i => ∫ x in s i, f x ∂μ) l (𝓝 0)
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma map_preNormEDS (n : ℤ) : f (preNormEDS b c d n) = preNormEDS (f b) (f c) (f d) n