ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Basic.lean
/-- If a predicate is true in a neighbourhood of `x`, then for `y` sufficiently close
to `x` this predicate is true in a neighbourhood of `y`. -/
theorem Filter.Eventually.eventually_nhds {p : X → Prop} (h : ∀ᶠ y in 𝓝 x, p y) :
    ∀ᶠ y in 𝓝 x, ∀ᶠ x in 𝓝 y, p x
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_ofNat (n : ℕ) [n.AtLeastTwo] : ⌊no_index (OfNat.ofNat n : α)⌋₊ = n
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem limZero_sub_rev {f g : CauSeq β abv} (hfg : LimZero (f - g)) : LimZero (g - f)
-- Mathlib/Data/Rat/Lemmas.lean
@[norm_cast, simp]
theorem isSquare_natCast_iff {n : ℕ} : IsSquare (n : ℚ) ↔ IsSquare n
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem lt_of_tsub_lt_tsub_left_of_le [ContravariantClass α α (· + ·) (· < ·)]
    (hb : AddLECancellable b) (hca : c ≤ a) (h : a - b < a - c) : c < b
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
lemma HasFDerivWithinAt.hasLineDerivWithinAt (hf : HasFDerivWithinAt f L s x) (v : E) :
    HasLineDerivWithinAt 𝕜 f (L v) s x v
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem and_congr_left (h : c → (a ↔ b)) : a ∧ c ↔ b ∧ c
-- Mathlib/SetTheory/Ordinal/Topology.lean
theorem isClosed_iff_bsup :
    IsClosed s ↔
      ∀ {o : Ordinal}, o ≠ 0 → ∀ f : ∀ a < o, Ordinal,
        (∀ i hi, f i hi ∈ s) → bsup.{u, u} o f ∈ s
-- Mathlib/Computability/DFA.lean
@[simp]
theorem evalFrom_comap (f : α' → α) (s : σ) (x : List α') :
    (M.comap f).evalFrom s x = M.evalFrom s (x.map f)
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- The inner product of two vectors given with `weightedVSub`, in
terms of the pairwise distances. -/
theorem inner_weightedVSub {ι₁ : Type*} {s₁ : Finset ι₁} {w₁ : ι₁ → ℝ} (p₁ : ι₁ → P)
    (h₁ : ∑ i ∈ s₁, w₁ i = 0) {ι₂ : Type*} {s₂ : Finset ι₂} {w₂ : ι₂ → ℝ} (p₂ : ι₂ → P)
    (h₂ : ∑ i ∈ s₂, w₂ i = 0) :
    ⟪s₁.weightedVSub p₁ w₁, s₂.weightedVSub p₂ w₂⟫ =
      (-∑ i₁ ∈ s₁, ∑ i₂ ∈ s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) /
        2
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
theorem Associates.finprod_ne_zero (I : Ideal R) :
    Associates.mk (∏ᶠ v : HeightOneSpectrum R, v.maxPowDividing I) ≠ 0
-- Mathlib/Analysis/Convex/Between.lean
theorem wbtw_comm {x y z : P} : Wbtw R x y z ↔ Wbtw R z y x
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem contMDiffWithinAt_proj {s : Set (TotalSpace F E)} {p : TotalSpace F E} :
    ContMDiffWithinAt (IB.prod 𝓘(𝕜, F)) IB n (π F E) s p
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem union_ae_eq_univ_of_ae_eq_univ_right (h : t =ᵐ[μ] univ) : (s ∪ t : Set α) =ᵐ[μ] univ
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
lemma prod_Iio_mul_eq_prod_Iic (a : α) : (∏ x ∈ Iio a, f x) * f a = ∏ x ∈ Iic a, f x
-- Mathlib/Algebra/Group/UniqueProds.lean
@[to_additive]
theorem iff_existsUnique (aA : a0 ∈ A) (bB : b0 ∈ B) :
    UniqueMul A B a0 b0 ↔ ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean
lemma hasFiniteLimits_of_hasLimitsOfSize [HasLimitsOfSize.{v', u'} C] :
    HasFiniteLimits C
-- Mathlib/Data/Finset/Sort.lean
theorem orderIsoOfFin_symm_apply (s : Finset α) {k : ℕ} (h : s.card = k) (x : s) :
    ↑((s.orderIsoOfFin h).symm x) = (s.sort (· ≤ ·)).indexOf ↑x
-- Mathlib/CategoryTheory/Action.lean
@[simp]
theorem π_obj (p : ActionCategory M X) : (π M X).obj p = SingleObj.star M
-- Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean
theorem hasBasis_nhds_zero_of_basis {ι : Type*} {p : ι → Prop} {b : ι → Set F}
    (h : (𝓝 (0 : F)).HasBasis p b) :
    (𝓝 (0 : ContinuousMultilinearMap 𝕜 E F)).HasBasis
      (fun Si : Set (Π i, E i) × ι => IsVonNBounded 𝕜 Si.1 ∧ p Si.2)
      fun Si => { f | MapsTo f Si.1 (b Si.2) }
-- Mathlib/FieldTheory/KrullTopology.lean
/-- This lemma says that `Gal(L/K) = L ≃ₐ[K] L` -/
theorem IntermediateField.fixingSubgroup.bot {K L : Type*} [Field K] [Field L] [Algebra K L] :
    IntermediateField.fixingSubgroup (⊥ : IntermediateField K L) = ⊤
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
protected theorem HasFDerivWithinAt.fderivWithin (h : HasFDerivWithinAt f f' s x)
    (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 f s x = f'
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The balancing properties of the `balLeft` function. -/
protected theorem Balanced.balLeft (hl : l.RedRed True n) (hr : r.Balanced cr (n + 1)) :
    (balLeft l v r).RedRed (cr = red) (n + 1)
-- Mathlib/Data/Set/Basic.lean
@[gcongr]
theorem diff_subset_diff_right {s t u : Set α} (h : t ⊆ u) : s \ u ⊆ s \ t
-- Mathlib/RingTheory/Flat/Basic.lean
/-- The `lTensor`-variant of `iff_rTensor_injective`. . -/
theorem iff_lTensor_injective :
    Module.Flat R M ↔ ∀ ⦃I : Ideal R⦄ (_ : I.FG), Function.Injective (lTensor M I.subtype)
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem cosh_log {x : ℝ} (hx : 0 < x) : cosh (log x) = (x + x⁻¹) / 2
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Strict inequality case of the Rearrangement Inequality**: Pointwise multiplication of
`f` and `g`, which monovary together, is strictly decreased by a permutation if and only if
`f` and `g ∘ σ` do not monovary together. Stated by permuting the entries of `g`. -/
theorem Monovary.sum_mul_comp_perm_lt_sum_mul_iff (hfg : Monovary f g) :
    ∑ i, f i * g (σ i) < ∑ i, f i * g i ↔ ¬Monovary f (g ∘ σ)
-- Mathlib/Data/Nat/Defs.lean
lemma or_exists_succ : p 0 ∨ (∃ n, p (n + 1)) ↔ ∃ n, p n
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem AddMonoidHom.toIntLinearMap_injective [AddCommGroup M] [AddCommGroup M₂] :
    Function.Injective (@AddMonoidHom.toIntLinearMap M M₂ _ _)
-- Mathlib/Data/Multiset/Basic.lean
theorem countP_congr {s s' : Multiset α} (hs : s = s')
    {p p' : α → Prop} [DecidablePred p] [DecidablePred p']
    (hp : ∀ x ∈ s, p x = p' x) : s.countP p = s'.countP p'
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- An orthogonal family of subspaces of `E` satisfies `DirectSum.IsInternal` (that is,
they provide an internal direct sum decomposition of `E`) if and only if their span has trivial
orthogonal complement. -/
theorem OrthogonalFamily.isInternal_iff [DecidableEq ι] [FiniteDimensional 𝕜 E]
    {V : ι → Submodule 𝕜 E} (hV : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    DirectSum.IsInternal V ↔ (iSup V)ᗮ = ⊥
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem StructureGroupoid.chart_mem_maximalAtlas [HasGroupoid M G] (x : M) :
    chartAt H x ∈ G.maximalAtlas M
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma map_eq {X Y : C} (φ : W.LeftFraction X Y) (L : C ⥤ D) [L.IsLocalization W] :
    φ.map L (Localization.inverts L W) =
      L.map φ.f ≫ (Localization.isoOfHom L W φ.s φ.hs).inv
-- Mathlib/CategoryTheory/Adhesive.lean
/-- A category is adhesive if it has pushouts and pullbacks along monomorphisms,
and such pushouts are van Kampen. -/
class Adhesive (C : Type u) [Category.{v} C] : Prop where
  [hasPullback_of_mono_left : ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [Mono f], HasPullback f g]
  [hasPushout_of_mono_left : ∀ {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
  van_kampen : ∀ {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [Mono f]
    (H : IsPushout f g h i), H.IsVanKampen
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem normalize_testAgainstNN (nonzero : μ ≠ 0) (f : Ω →ᵇ ℝ≥0) :
    μ.normalize.toFiniteMeasure.testAgainstNN f = μ.mass⁻¹ * μ.testAgainstNN f
-- Mathlib/SetTheory/Cardinal/Divisibility.lean
theorem dvd_of_le_of_aleph0_le (ha : a ≠ 0) (h : a ≤ b) (hb : ℵ₀ ≤ b) : a ∣ b
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
/-- See `FiniteDimensional.finrank_zero_iff`
  for the stronger version with `NoZeroSMulDivisors R M`. -/
theorem FiniteDimensional.finrank_eq_zero_iff :
    finrank R M = 0 ↔ ∀ x : M, ∃ a : R, a ≠ 0 ∧ a • x = 0
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.trans_sbtw_left [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Wbtw R w y z)
    (h₂ : Sbtw R w x y) : Sbtw R w x z
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
@[reassoc]
lemma mapRightHomologyIso_hom_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    rightHomologyMap (F.mapShortComplex.map φ) ≫ (S₂.mapRightHomologyIso F).hom =
      (S₁.mapRightHomologyIso F).hom ≫ F.map (rightHomologyMap φ)
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem mem_filterMap {b : β} : b ∈ s.filterMap f f_inj ↔ ∃ a ∈ s, f a = some b
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem xor_assoc (x y z : BitVec w) :
    x ^^^ y ^^^ z = x ^^^ (y ^^^ z)
-- Mathlib/Computability/Halting.lean
theorem rice₂ (C : Set Code) (H : ∀ cf cg, eval cf = eval cg → (cf ∈ C ↔ cg ∈ C)) :
    (ComputablePred fun c => c ∈ C) ↔ C = ∅ ∨ C = Set.univ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
@[simp]
theorem range_sin : Set.range sin = Set.univ
-- Mathlib/Probability/Kernel/CondDistrib.lean
/-- For almost every `a : α`, the `condDistrib Y X μ` kernel applied to `X a` and a measurable set
`s` is equal to the conditional expectation of the indicator of `Y ⁻¹' s`. -/
theorem condDistrib_ae_eq_condexp (hX : Measurable X) (hY : Measurable Y) (hs : MeasurableSet s) :
    (fun a => (condDistrib Y X μ (X a) s).toReal) =ᵐ[μ] μ⟦Y ⁻¹' s|mβ.comap X⟧
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
@[simp] theorem add_mod_left (x z : Nat) : (x + z) % x = z % x
-- Mathlib/RingTheory/MvPolynomial/Basic.lean
@[simp]
theorem coe_basisMonomials :
    (basisMonomials σ R : (σ →₀ ℕ) → MvPolynomial σ R) = fun s => monomial s 1
-- Mathlib/NumberTheory/MulChar/Basic.lean
theorem ofUnitHom_coe (f : Rˣ →* R'ˣ) (a : Rˣ) : ofUnitHom f ↑a = f a
-- Mathlib/CategoryTheory/PathCategory.lean
@[simp]
theorem composePath_comp {X Y Z : C} (f : Path X Y) (g : Path Y Z) :
    composePath (f.comp g) = composePath f ≫ composePath g
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem disjoint_ker_aeval_of_coprime (f : M →ₗ[R] M) {p q : R[X]} (hpq : IsCoprime p q) :
    Disjoint (LinearMap.ker (aeval f p)) (LinearMap.ker (aeval f q))
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp] lemma prob_compl_eq_one_iff (hs : MeasurableSet s) : μ sᶜ = 1 ↔ μ s = 0
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem div_rpow (x y : ℝ≥0) (z : ℝ) : (x / y) ^ z = x ^ z / y ^ z
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
/-- If `f : R → ℝ` is a nonnegative, multiplicatively bounded function, then
  `seminormFromBounded' f 1 ≤ 1`. -/
theorem seminormFromBounded_one_le (f_nonneg : 0 ≤ f)
    (f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y) :
    seminormFromBounded' f 1 ≤ 1
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem measurePreserving_piCongrLeft (f : ι' ≃ ι) :
    MeasurePreserving (MeasurableEquiv.piCongrLeft α f)
      (Measure.pi fun i' => μ (f i')) (Measure.pi μ)
-- Mathlib/SetTheory/Game/PGame.lean
/-- Definition of `x ⧏ y` on pre-games built using the constructor. -/
@[simp]
theorem mk_lf_mk {xl xr xL xR yl yr yL yR} :
    mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR
-- Mathlib/Topology/Separation.lean
@[elab_as_elim]
protected lemma inductionOn₂ [TopologicalSpace Y] {motive : t2Quotient X → t2Quotient Y → Prop}
    (q : t2Quotient X) (q' : t2Quotient Y) (h : ∀ x y, motive (mk x) (mk y)) : motive q q'
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem set_nil_succ : set [] (i+1) y = 0 :: set [] i y
-- Mathlib/Order/Disjoint.lean
theorem of_eq (h₁ : x ⊓ y = ⊥) (h₂ : x ⊔ y = ⊤) : IsCompl x y
-- Mathlib/RingTheory/Nilpotent/Defs.lean
lemma pow_nilpotencyClass (hx : IsNilpotent x) : x ^ (nilpotencyClass x) = 0
-- Mathlib/LinearAlgebra/Projection.lean
theorem eq_conj_prod_map' {f : E →ₗ[R] E} (h : IsProj p f) :
    f = (p.prodEquivOfIsCompl (ker f) h.isCompl).toLinearMap ∘ₗ
        prodMap id 0 ∘ₗ (p.prodEquivOfIsCompl (ker f) h.isCompl).symm.toLinearMap
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Topology/Basic.lean
@[mono, gcongr]
theorem interior_mono (h : s ⊆ t) : interior s ⊆ interior t
-- Mathlib/Data/Bundle.lean
/-- A trivial bundle is equivalent to the product `B × F`. -/
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem le_leftLim (h : x ≤ y) : f y ≤ leftLim f x
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem union_ae_eq_right_of_ae_eq_empty (h : s =ᵐ[μ] (∅ : Set α)) : (s ∪ t : Set α) =ᵐ[μ] t
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_congr (h : ∀ a ∈ s, ∀ b ∈ t, f a b = f' a b) : image₂ f s t = image₂ f' s t
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
@[simp]
theorem zeroth_conv'_eq_h : g.convs' 0 = g.h
-- Mathlib/Topology/Sheaves/Skyscraper.lean
theorem fromStalk_to_skyscraper {𝓕 : Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c) :
    fromStalk p₀ (toSkyscraperPresheaf _ f) = f
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_embedding_eq_zero_iff_lift_lt : #(α ↪ β') = 0 ↔ lift.{u} #β' < lift.{v} #α
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp] theorem measurableSet_setOf : MeasurableSet {a | p a} ↔ Measurable p
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- The orthogonal projection is symmetric. -/
theorem orthogonalProjection_isSymmetric [HasOrthogonalProjection K] :
    (K.subtypeL ∘L orthogonalProjection K : E →ₗ[𝕜] E).IsSymmetric
-- Mathlib/Topology/Basic.lean
theorem IsOpen.closure_inter (h : IsOpen t) : closure s ∩ t ⊆ closure (s ∩ t)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem diff_cons (l₁ l₂ : List α) (a : α) : l₁.diff (a :: l₂) = (l₁.erase a).diff l₂
-- Mathlib/Topology/Basic.lean
theorem IsClosed.preimage (hf : Continuous f) {t : Set Y} (h : IsClosed t) :
    IsClosed (f ⁻¹' t)
-- Mathlib/LinearAlgebra/SModEq.lean
theorem smul (hxy : x ≡ y [SMOD U]) (c : R) : c • x ≡ c • y [SMOD U]
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
/-- An auxiliary structure that witnesses the fact that `f` factors through an image object of `G`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure Presieve.CoverByImageStructure (G : C ⥤ D) {V U : D} (f : V ⟶ U) where
  obj : C
  lift : V ⟶ G.obj obj
  map : G.obj obj ⟶ U
  fac : lift ≫ map = f := by aesop_cat
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arccos_eq_pi {x} : arccos x = π ↔ x ≤ -1
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem smul_apply (n : M) (f : CentroidHom α) (a : α) : (n • f) a = n • f a
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem isUnit_gcd_one_left [GCDMonoid α] (a : α) : IsUnit (gcd 1 a)
-- Mathlib/GroupTheory/GroupAction/Basic.lean
/-- If the stabilizer of `x` is `S`, then the stabilizer of `g +ᵥ x` is `g + S + (-g)`. -/
theorem stabilizer_vadd_eq_stabilizer_map_conj (g : G) (a : α) :
    stabilizer G (g +ᵥ a) = (stabilizer G a).map (AddAut.conj g).toAddMonoidHom
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem lt_aleph0_of_finite (α : Type u) [Finite α] : #α < ℵ₀
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mem_prod {x y z : ZFSet.{u}} : z ∈ prod x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = pair a b
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp] lemma induceHomOfLE_toHom :
    (G.induceHomOfLE h).toHom = induceHom (.id : G →g G) ((Set.mapsTo_id s).mono_right h)
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_union (s : ι → Set β) (t : Set β) : (⋂ i, s i) ∪ t = ⋂ i, s i ∪ t
-- Mathlib/Topology/ContinuousOn.lean
theorem continuous_if' {p : α → Prop} {f g : α → β} [∀ a, Decidable (p a)]
    (hpf : ∀ a ∈ frontier { x | p x }, Tendsto f (𝓝[{ x | p x }] a) (𝓝 <| ite (p a) (f a) (g a)))
    (hpg : ∀ a ∈ frontier { x | p x }, Tendsto g (𝓝[{ x | ¬p x }] a) (𝓝 <| ite (p a) (f a) (g a)))
    (hf : ContinuousOn f { x | p x }) (hg : ContinuousOn g { x | ¬p x }) :
    Continuous fun a => ite (p a) (f a) (g a)
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem transpose_circulant [AddGroup n] (v : n → α) :
    (circulant v)ᵀ = circulant fun i => v (-i)
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- The functor sending an arrow to its source. -/
@[simps!]
def leftFunc : Arrow C ⥤ C
-- Mathlib/Data/Set/Basic.lean
@[simp] lemma inter_eq_left : s ∩ t = s ↔ s ⊆ t
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- The `vectorSpan` of an indexed family of `n + 1` points has
dimension at most `n`. -/
theorem finrank_vectorSpan_range_le [Fintype ι] (p : ι → P) {n : ℕ} (hc : Fintype.card ι = n + 1) :
    finrank k (vectorSpan k (Set.range p)) ≤ n
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive (attr := simp) abs_pos] lemma one_lt_mabs : 1 < |a|ₘ ↔ a ≠ 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem intersperse_nil (sep : α) : ([] : List α).intersperse sep = []
-- Mathlib/CategoryTheory/Adjunction/Limits.lean
/-- The unit for the adjunction for `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)`.

Auxiliary definition for `functorialityIsLeftAdjoint`.
-/
@[simps]
def functorialityUnit :
    𝟭 (Cocone K) ⟶ Cocones.functoriality _ F ⋙ functorialityRightAdjoint adj K
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem one_apply_ne {i j} : i ≠ j → (1 : Matrix n n α) i j = 0
-- Mathlib/Analysis/Seminorm.lean
theorem ball_sup (p : Seminorm 𝕜 E) (q : Seminorm 𝕜 E) (e : E) (r : ℝ) :
    ball (p ⊔ q) e r = ball p e r ∩ ball q e r
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem mul_snd (a b : 𝓜(𝕜, A)) : (a * b).snd = b.snd * a.snd
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis.iUnion_basis_iUnion {ι : Type _} (X I : ι → Set α) (hI : ∀ i, M.Basis (I i) (X i))
    (h_ind : M.Indep (⋃ i, I i)) : M.Basis (⋃ i, I i) (⋃ i, X i)
-- Mathlib/CategoryTheory/Monoidal/Mod_.lean
@[ext]
lemma hom_ext {M N : Mod_ A} (f₁ f₂ : M ⟶ N) (h : f₁.hom = f₂.hom) : f₁ = f₂
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
/-- For `f : Lp E p μ`, we can define an element of `Lp E p (μ.restrict s)` by
`(Lp.memℒp f).restrict s).toLp f`. This map is additive. -/
theorem Lp_toLp_restrict_add (f g : Lp E p μ) (s : Set X) :
    ((Lp.memℒp (f + g)).restrict s).toLp (⇑(f + g)) =
      ((Lp.memℒp f).restrict s).toLp f + ((Lp.memℒp g).restrict s).toLp g
-- Mathlib/Data/Nat/Defs.lean
protected lemma eq_div_of_mul_eq_right (hc : c ≠ 0) (h : c * a = b) : a = b / c
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem incidenceSet_inter_incidenceSet_subset (h : a ≠ b) :
    G.incidenceSet a ∩ G.incidenceSet b ⊆ {s(a, b)}
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem isClosed_ball_top : IsClosed (ball x ⊤)
-- Mathlib/Order/Max.lean
theorem IsTop.prod_mk (ha : IsTop a) (hb : IsTop b) : IsTop (a, b)
-- Mathlib/Order/Atoms.lean
theorem isStronglyAtomic_dual_iff_is_stronglyCoatomic :
    IsStronglyAtomic αᵒᵈ ↔ IsStronglyCoatomic α
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
theorem elem_cons [BEq α] {a : α} :
    (b::bs).elem a = match a == b with | true => true | false => bs.elem a
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp) zero_zsmul] theorem zpow_zero (a : G) : a ^ (0 : ℤ) = 1
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem tendsto_IicSnd_atTop {s : Set α} (hs : MeasurableSet s) :
    Tendsto (fun r : ℚ ↦ ρ.IicSnd r s) atTop (𝓝 (ρ.fst s))
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem root_X_sub_C : IsRoot (X - C a) b ↔ a = b
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
lemma c_iso' {V : Opens Y} (U : Opens X) (h : V = (opensFunctor f).obj U) :
    IsIso (f.c.app (Opposite.op V))
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
@[simp]
lemma shift_add (a : ℤ) :
    (γ₁ + γ₂).shift a = γ₁.shift a + γ₂.shift a
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
@[simp]
theorem coe_toContinuousLinearEquiv' (e : E ≃ₗ[𝕜] F) : (e.toContinuousLinearEquiv : E → F) = e
-- Mathlib/Data/Finsupp/Basic.lean
theorem _root_.IsSMulRegular.finsupp [Zero M] [SMulZeroClass R M] {k : R}
    (hk : IsSMulRegular M k) : IsSMulRegular (α →₀ M) k
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem exists_eq_right_right : (∃ (a : α), p a ∧ q a ∧ a = a') ↔ p a' ∧ q a'
-- Mathlib/Data/SetLike/Basic.lean
protected theorem «forall» {q : p → Prop} : (∀ x, q x) ↔ ∀ (x : B) (h : x ∈ p), q ⟨x, ‹_›⟩
-- Mathlib/SetTheory/Game/PGame.lean
/-- A small set of pre-games is bounded below. -/
lemma bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s
-- Mathlib/Order/Filter/ModEq.lean
theorem frequently_odd : ∃ᶠ m : ℕ in atTop, Odd m
-- Mathlib/Data/Set/NAry.lean
/-- Symmetric statement to `Set.image2_image_left_comm`. -/
theorem image_image2_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (image2 f s t).image g = image2 f' (s.image g') t
-- Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
theorem nonarchimedean : @NonarchimedeanRing A _ hB.topology
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
theorem op_adjoin (s : Set A) :
    (Algebra.adjoin R s).op = Algebra.adjoin R (MulOpposite.unop ⁻¹' s)
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
theorem ofEq_symm (h : p = q) : (ofEq p q h).symm = ofEq q p h.symm
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
/-- `toSimpleFunc f` satisfies the predicate `Memℒp`. -/
protected theorem memℒp (f : Lp.simpleFunc E p μ) : Memℒp (toSimpleFunc f) p μ
-- Mathlib/Algebra/Group/Commute/Units.lean
@[to_additive]
theorem units_of_val : Commute (u₁ : M) u₂ → Commute u₁ u₂
-- Mathlib/Data/ENNReal/Inv.lean
theorem mul_le_of_le_div (h : a ≤ b / c) : a * c ≤ b
-- Mathlib/Data/Set/Function.lean
theorem MapsTo.mono_left (hf : MapsTo f s₁ t) (hs : s₂ ⊆ s₁) : MapsTo f s₂ t
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[simp]
theorem apply_one [DecidableEq E] (x : E) :
    (1 : NonarchAddGroupNorm E) x = if x = 0 then 0 else 1
-- Mathlib/Data/PFun.lean
@[simp]
theorem dom_mk (p : α → Prop) (f : ∀ a, p a → β) : (PFun.Dom fun x => ⟨p x, f x⟩) = { x | p x }
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem measure_inter_eq_zero_of_restrict (h : μ.restrict s t = 0) : μ (t ∩ s) = 0
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
protected theorem map_smul (r : R) : (r • p).map f = f r • p.map f
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem projIic_eq_self : projIic b x = ⟨b, le_rfl⟩ ↔ b ≤ x
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem IccExtend_of_right_le (f : Icc a b → β) (hx : b ≤ x) :
    IccExtend h f x = f ⟨b, right_mem_Icc.2 h⟩
-- Mathlib/GroupTheory/Commutator.lean
theorem commutator_def (H₁ H₂ : Subgroup G) :
    ⁅H₁, H₂⁆ = closure { g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g }
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_inter_subset_left : (s₁ ∩ s₂) ○ t ⊆ s₁ ○ t ∩ s₂ ○ t
-- Mathlib/Data/Complex/Exponential.lean
theorem cos_two_mul' : cos (2 * x) = cos x ^ 2 - sin x ^ 2
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
/-- The forgetful functor from `PresheafedSpace` to `TopCat`. -/
@[simps]
def forget : PresheafedSpace C ⥤ TopCat
-- Mathlib/Topology/Maps/Basic.lean
protected theorem continuous (hf : Inducing f) : Continuous f
-- Mathlib/Data/List/Basic.lean
theorem foldr_ext (f g : α → β → β) (b : β) {l : List α} (H : ∀ a ∈ l, ∀ b : β, f a b = g a b) :
    foldr f b l = foldr g b l
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem pred_eval (v) : pred.eval v = pure [v.headI.pred]
-- Mathlib/Topology/Compactness/Compact.lean
protected theorem IsCompact.insert (hs : IsCompact s) (a) : IsCompact (insert a s)
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_eq_if {p : Prop} [Decidable p] (a : α) : ⨆ _ : p, a = if p then a else ⊥
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]  -- @[simp] -- Porting note (#10618): simp can prove this
theorem to_nat_to_int (n : Num) : ((n : ℕ) : ℤ) = n
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
lemma _root_.Real.spectralRadius_mem_spectrum_or {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] {a : A} (ha : (spectrum ℝ a).Nonempty) :
    (spectralRadius ℝ a).toReal ∈ spectrum ℝ a ∨ -(spectralRadius ℝ a).toReal ∈ spectrum ℝ a