ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Compactness/Compact.lean
/-- If `s : Set S` belongs to `l ⊓ 𝓝 x` for all `x` from a compact set `K`,
then it belongs to `l ⊓ (𝓝ˢ K)`,
i.e., there exist `T ∈ l` and an open `U ⊇ K` such that `T ∩ U ⊆ s`. -/
theorem IsCompact.mem_inf_nhdsSet_of_forall {K : Set X} {l : Filter X} {s : Set X}
    (hK : IsCompact K) (hs : ∀ y ∈ K, s ∈ l ⊓ 𝓝 y) : s ∈ l ⊓ 𝓝ˢ K
-- Mathlib/Topology/Algebra/Module/CharacterSpace.lean
/-- An element of the character space of a unital algebra, as an algebra homomorphism. -/
@[simps]
def toAlgHom (φ : characterSpace 𝕜 A) : A →ₐ[𝕜] 𝕜
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderSpecialization_iff_Union_eq {s : Set X} :
    StableUnderSpecialization s ↔ (⋃ x ∈ s, closure {x}) = s
-- Mathlib/CategoryTheory/Sites/Sieves.lean
lemma mem_ofObjects_iff {I : Type*} (Y : I → C) {Z X : C} (g : Z ⟶ X) :
    ofObjects Y X g ↔ ∃ (i : I), Nonempty (Z ⟶ Y i)
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem le_natTrailingDegree_mul (h : p * q ≠ 0) :
    p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree
-- Mathlib/Data/List/InsertNth.lean
@[simp, deprecated get_insertNth_self (since := "2023-01-05")]
theorem nthLe_insertNth_self (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length)
    (hn' : n < (insertNth n x l).length := (by rwa [length_insertNth _ _ hn, Nat.lt_succ_iff])) :
    (insertNth n x l).nthLe n hn' = x
-- Mathlib/Topology/Instances/ENNReal.lean
/-- In an emetric ball, the distance between points is everywhere finite -/
theorem edist_ne_top_of_mem_ball {a : β} {r : ℝ≥0∞} (x y : ball a r) : edist x.1 y.1 ≠ ∞
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_add_eq_iff_add_mul_eq_mul {x} {y : M} {z₁ z₂} :
    mk' S x y + z₁ = z₂ ↔ algebraMap R S x + z₁ * algebraMap R S y = z₂ * algebraMap R S y
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
theorem splitLower_le : I.splitLower i x ≤ I
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
lemma equalizerCondition_w' (P : Cᵒᵖ ⥤ Type*) {X B : C} (π : X ⟶ B)
    [HasPullback π π] : P.map π.op ≫ P.map (pullback.fst π π).op =
    P.map π.op ≫ P.map (pullback.snd π π).op
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_iUnion_le {α ι : Type u} (f : ι → Set α) : #(⋃ i, f i) ≤ #ι * ⨆ i, #(f i)
-- Mathlib/Data/Matrix/Rank.lean
theorem rank_le_height [StrongRankCondition R] {m n : ℕ} (A : Matrix (Fin m) (Fin n) R) :
    A.rank ≤ m
-- Mathlib/Algebra/MonoidAlgebra/ToDirectSum.lean
/-- The ring version of `AddMonoidAlgebra.addMonoidAlgebraEquivDirectSum`.  -/
@[simps (config := .asFn)]
def addMonoidAlgebraRingEquivDirectSum [DecidableEq ι] [AddMonoid ι] [Semiring M]
    [∀ m : M, Decidable (m ≠ 0)] : AddMonoidAlgebra M ι ≃+* ⨁ _ : ι, M
-- Mathlib/RingTheory/IsTensorProduct.lean
@[simp]
theorem IsTensorProduct.equiv_symm_apply (h : IsTensorProduct f) (x₁ : M₁) (x₂ : M₂) :
    h.equiv.symm (f x₁ x₂) = x₁ ⊗ₜ x₂
-- Mathlib/Logic/Basic.lean
theorem iff_not_comm : (a ↔ ¬b) ↔ (b ↔ ¬a)
-- Mathlib/Algebra/Associated/Basic.lean
theorem Prime.dvd_of_pow_dvd_pow_mul_pow_of_square_not_dvd [CancelCommMonoidWithZero α] {p a b : α}
    {n : ℕ} (hp : Prime p) (hpow : p ^ n.succ ∣ a ^ n.succ * b ^ n) (hb : ¬p ^ 2 ∣ b) : p ∣ a
-- Mathlib/Analysis/Calculus/FDeriv/RestrictScalars.lean
theorem DifferentiableAt.fderiv_restrictScalars (h : DifferentiableAt 𝕜' f x) :
    fderiv 𝕜 f x = (fderiv 𝕜' f x).restrictScalars 𝕜
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem coe_ne_top (x : ℝ) : (x : EReal) ≠ ⊤
-- Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean
@[simp]
theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
    pushout.inl _ _ ≫ (pushoutZeroZeroIso X Y).hom = coprod.inl
-- Mathlib/Data/FunLike/Basic.lean
theorem ext (f g : F) (h : ∀ x : α, f x = g x) : f = g
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem mem_neg {g : M} {S : Submodule R M} : g ∈ -S ↔ -g ∈ S
-- Mathlib/NumberTheory/LSeries/Convergence.lean
/-- If `‖f n‖` is bounded by a constant times `n^x`, then the abscissa of absolute convergence
of `f` is bounded by `x + 1`. -/
lemma LSeries.abscissaOfAbsConv_le_of_le_const_mul_rpow {f : ℕ → ℂ} {x : ℝ}
    (h : ∃ C, ∀ n ≠ 0, ‖f n‖ ≤ C * n ^ x) : abscissaOfAbsConv f ≤ x + 1
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma exists_isNilRegular [Infinite R] : ∃ x : L, IsNilRegular φ x
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
theorem equivSubtypeMap_symm_apply {p : Submodule R M} {q : Submodule R p} (x : q.map p.subtype) :
    ((p.equivSubtypeMap q).symm x : M) = x
-- Mathlib/Data/Sum/Interval.lean
theorem sumLift₂_mono (h₁ : ∀ a b, f₁ a b ⊆ g₁ a b) (h₂ : ∀ a b, f₂ a b ⊆ g₂ a b) :
    ∀ a b, sumLift₂ f₁ f₂ a b ⊆ sumLift₂ g₁ g₂ a b
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul {p : ℕ} (p_prime : Prime p) {m n k l : ℕ}
    (hpm : p ^ k ∣ m) (hpn : p ^ l ∣ n) (hpmn : p ^ (k + l + 1) ∣ m * n) :
    p ^ (k + 1) ∣ m ∨ p ^ (l + 1) ∣ n
-- Mathlib/Order/Fin/Tuple.lean
@[simp] lemma strictMono_vecEmpty : StrictMono ![a]
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem map_subtype_embedding_Ioi : (Ioi a).map (Embedding.subtype p) = (Ioi a : Finset α)
-- Mathlib/Data/Vector/MapLemmas.lean
theorem mapAccumr_bisim {f₁ : α → σ₁ → σ₁ × β} {f₂ : α → σ₂ → σ₂ × β} {s₁ : σ₁} {s₂ : σ₂}
    (R : σ₁ → σ₂ → Prop) (h₀ : R s₁ s₂)
    (hR : ∀ {s q} a, R s q → R (f₁ a s).1 (f₂ a q).1 ∧ (f₁ a s).2 = (f₂ a q).2) :
    R (mapAccumr f₁ xs s₁).fst (mapAccumr f₂ xs s₂).fst
    ∧ (mapAccumr f₁ xs s₁).snd = (mapAccumr f₂ xs s₂).snd
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
@[simp]
theorem coe_zero_linearMap : ↑(0 : LieDerivation R L M) = (0 : L →ₗ[R] M)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[simp]
theorem id_comp (f : X →ₑ[φ] Y) :
    (MulActionHom.id N).comp f = f
-- Mathlib/GroupTheory/Torsion.lean
lemma IsTorsionFree.of_noZeroSMulDivisors {M : Type*} [AddMonoid M] [NoZeroSMulDivisors ℕ M] :
    AddMonoid.IsTorsionFree M
-- Mathlib/Analysis/BoundedVariation.lean
theorem MonotoneOn.eVariationOn_le {f : α → ℝ} {s : Set α} (hf : MonotoneOn f s) {a b : α}
    (as : a ∈ s) (bs : b ∈ s) : eVariationOn f (s ∩ Icc a b) ≤ ENNReal.ofReal (f b - f a)
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem coeff_inj {x y : HahnSeries Γ R} : x.coeff = y.coeff ↔ x = y
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem circleMap_mem_sphere (c : ℂ) {R : ℝ} (hR : 0 ≤ R) (θ : ℝ) :
    circleMap c R θ ∈ sphere c R
-- Mathlib/NumberTheory/Divisors.lean
/-- See also `Nat.mem_properDivisors`. -/
lemma mem_properDivisors_iff_exists {m n : ℕ} (hn : n ≠ 0) :
    m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k
-- Mathlib/Order/Bounds/Basic.lean
theorem IsLeast.lowerBounds_eq (h : IsLeast s a) : lowerBounds s = Iic a
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem ofMapRelIff_coe (f : α → β) [IsAntisymm α r] [IsRefl β s]
    (hf : ∀ a b, s (f a) (f b) ↔ r a b) :
    (ofMapRelIff f hf : r ↪r s) = f
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem mapRange.linearEquiv_trans (f : M ≃ₗ[R] N) (f₂ : N ≃ₗ[R] P) :
    (mapRange.linearEquiv (f.trans f₂) : (α →₀ _) ≃ₗ[R] _) =
      (mapRange.linearEquiv f).trans (mapRange.linearEquiv f₂)
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. The minimum of a measurable function is smaller than its integral. -/
theorem exists_le_lintegral (hf : AEMeasurable f μ) : ∃ x, f x ≤ ∫⁻ a, f a ∂μ
-- Mathlib/Data/Set/Defs.lean
@[simp, mfld_simps]
theorem mem_preimage {f : α → β} {s : Set β} {a : α} : a ∈ f ⁻¹' s ↔ f a ∈ s
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem iso_symm_apply_aux (m : M') :
    (iso S f).symm m =
      LocalizedModule.mk (IsLocalizedModule.surj S f m).choose.1
        (IsLocalizedModule.surj S f m).choose.2
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem isEquiv_iff_val_lt_one [LinearOrderedCommGroupWithZero Γ₀]
    [LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    v.IsEquiv v' ↔ ∀ {x : K}, v x < 1 ↔ v' x < 1
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
@[gcongr]
theorem logb_lt_logb (hx : 0 < x) (hxy : x < y) : logb b x < logb b y
-- Mathlib/Order/Filter/AtTopBot.lean
/-- The `atBot` filter for an open interval `Iio a` comes from the `atBot` filter in the ambient
order. -/
@[simp]
theorem map_val_Iio_atBot [SemilatticeInf α] [NoMinOrder α] (a : α) :
    map ((↑) : Iio a → α) atBot = atBot
-- Mathlib/Topology/Bornology/Basic.lean
theorem IsCobounded.all (s : Set α) : IsCobounded s
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem exists_pos_lt_mul {a : α} (h : 0 < a) (b : α) : ∃ c : α, 0 < c ∧ b < c * a
-- Mathlib/Algebra/CharP/Two.lean
theorem sum_mul_self (s : Finset ι) (f : ι → R) :
    ((∑ i ∈ s, f i) * ∑ i ∈ s, f i) = ∑ i ∈ s, f i * f i
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
theorem quasispectrumRestricts_iff_spectrumRestricts {R S A : Type*} [Semifield R] [Semifield S]
    [Ring A] [Algebra R S] [Algebra R A] [Algebra S A] {a : A} {f : S → R} :
    QuasispectrumRestricts a f ↔ SpectrumRestricts a f
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem expand_char (f : R[X]) : map (frobenius R p) (expand R p f) = f ^ p
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem nat_find_mem_find {p : Fin n → Prop} [DecidablePred p]
    (h : ∃ i, ∃ hin : i < n, p ⟨i, hin⟩) :
    (⟨Nat.find h, (Nat.find_spec h).fst⟩ : Fin n) ∈ find p
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem monomial_mul_monomial (m n : σ →₀ ℕ) (a b : R) :
    monomial R m a * monomial R n b = monomial R (m + n) (a * b)
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
@[simp]
protected theorem zero : smoothTransition 0 = 0
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictAntiOn.lt_iff_lt (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a < f b ↔ b < a
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem uniformContinuous_mk : UniformContinuous (mk : α → SeparationQuotient α)
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
@[simp]
theorem isHenstock_single_iff (hJ : J ≤ I) (h : x ∈ Box.Icc I) :
    IsHenstock (single I J hJ x h) ↔ x ∈ Box.Icc J
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem uniformEmbedding_subtypeEmb (p : α → Prop) {e : α → β} (ue : UniformEmbedding e)
    (de : DenseEmbedding e) : UniformEmbedding (DenseEmbedding.subtypeEmb p e)
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
theorem mem_support_bindOnSupport_iff (b : β) :
    b ∈ (p.bindOnSupport f).support ↔ ∃ (a : α) (h : a ∈ p.support), b ∈ (f a h).support
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem coe_normUnit_of_ne_zero [DecidableEq R] (hp : p ≠ 0) :
    (normUnit p : R[X]) = C p.leadingCoeff⁻¹
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
theorem of_rightInvOn (h₁ : Function.LeftInverse f (algebraMap R S))
    (h₂ : (spectrum S a).RightInvOn f (algebraMap R S)) : SpectrumRestricts a f
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
lemma whiskerRightIso_refl (X W : C) :
    whiskerRightIso (Iso.refl X) W = Iso.refl (X ⊗ W)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem I_re : I.re = 0
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integrableOn_iUnion_of_summable_integral_norm {f : X → E} {s : ι → Set X}
    (hs : ∀ i : ι, MeasurableSet (s i)) (hi : ∀ i : ι, IntegrableOn f (s i) μ)
    (h : Summable fun i : ι => ∫ x : X in s i, ‖f x‖ ∂μ) : IntegrableOn f (iUnion s) μ
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- `cyclotomic n R` can be expressed as a product in a fraction field of `R[X]`
  using Möbius inversion. -/
theorem cyclotomic_eq_prod_X_pow_sub_one_pow_moebius {n : ℕ} (R : Type*) [CommRing R]
    [IsDomain R] : algebraMap _ (RatFunc R) (cyclotomic n R) =
      ∏ i ∈ n.divisorsAntidiagonal, algebraMap R[X] _ (X ^ i.snd - 1) ^ μ i.fst
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
@[simp]
theorem union_right_iff : AEDisjoint μ s (t ∪ u) ↔ AEDisjoint μ s t ∧ AEDisjoint μ s u
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_const_mul_iff {c : 𝕜} (hc : IsUnit c) (f : α → 𝕜) :
    Integrable (fun x => c * f x) μ ↔ Integrable f μ
-- Mathlib/RingTheory/SurjectiveOnStalks.lean
lemma surjectiveOnStalks_iff_forall_ideal :
    f.SurjectiveOnStalks ↔
      ∀ I : Ideal S, I ≠ ⊤ → ∀ s : S, ∃ x r : R, ∃ c ∉ I, f r ∉ I ∧ c * f r * s = c * f x
-- Mathlib/Data/Nat/Hyperoperation.lean
theorem hyperoperation_ge_three_one (n : ℕ) : ∀ k : ℕ, hyperoperation (n + 3) 1 k = 1
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwise_insert :
    (insert a s).Pairwise r ↔ s.Pairwise r ∧ ∀ b ∈ s, a ≠ b → r a b ∧ r b a
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
@[simp] lemma left_mem_uIoc : a ∈ Ι a b ↔ b < a
-- Mathlib/Data/Sigma/Basic.lean
lemma exists' {p : ∀ a, β a → Prop} : (∃ a b, p a b) ↔ ∃ x : Σ a, β a, p x.1 x.2
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
nonrec theorem HasStrictDerivAt.const_smul (c : R) (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun y => c • f y) (c • f') x
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
lemma piTensorHomMap_tprod_eq_map (f : Π i, s i →ₗ[R] t i) :
    piTensorHomMap (tprod R f) = map f
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Arctan.lean
@[measurability]
theorem measurable_arctan : Measurable arctan
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma coe_inv_variableChange_Δ' : (E.variableChange C).Δ'⁻¹ = C.u ^ 12 * E.Δ'⁻¹
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem toSubring_injective : Function.Injective (toSubring : ValuationSubring K → Subring K)
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem zip_eq_zip_take_min : ∀ (l₁ : List α) (l₂ : List β),
    zip l₁ l₂ = zip (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
-- Mathlib/Logic/Function/Basic.lean
theorem rightInverse_invFun (hf : Surjective f) : RightInverse (invFun f) f
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma le_inv_smul_iff_of_pos [PosSMulMono α β] [PosSMulReflectLE α β] (ha : 0 < a) :
    b₁ ≤ a⁻¹ • b₂ ↔ a • b₁ ≤ b₂
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem mem_irrefl (x : Class) : x ∉ x
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem xor_true : ∀ (x : Bool), xor x true = !x
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
theorem pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x
-- Mathlib/Data/Int/Order/Units.lean
theorem units_pow_eq_pow_mod_two (u : ℤˣ) (n : ℕ) : u ^ n = u ^ (n % 2)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.le_set' {f o} (H : IsNormal f) (p : Set α) (p0 : p.Nonempty) (g : α → Ordinal) (b)
    (H₂ : ∀ o, b ≤ o ↔ ∀ a ∈ p, g a ≤ o) : f b ≤ o ↔ ∀ a ∈ p, f (g a) ≤ o
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
theorem toAffineMap_injective : Injective (toAffineMap : (P →ᵃⁱ[𝕜] P₂) → P →ᵃ[𝕜] P₂)
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem SeparatingLeft.toMatrix₂ {B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁} (h : B.SeparatingLeft)
    (b : Basis ι R₁ M₁) : (toMatrix₂ b b B).Nondegenerate
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem floor_eq_self_of_mem (m : E) (h : m ∈ span ℤ (Set.range b)) : (floor b m : E) = m
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct/Isometries.lean
theorem comp_tensorRId_eq (Q₁ : QuadraticForm R M₁) :
    Q₁.comp (TensorProduct.rid R M₁) = Q₁.tmul (sq (R := R))
-- Mathlib/Order/Ideal.lean
theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x ∉ I
-- Mathlib/CategoryTheory/Limits/Types.lean
@[simp]
theorem limitEquivSections_symm_apply (x : F.sections) (j : J) :
    limit.π F j ((limitEquivSections F).symm x) = (x : ∀ j, F.obj j) j
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
theorem cospan_map_id {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (w : WalkingCospan) :
    (cospan f g).map (WalkingCospan.Hom.id w) = 𝟙 _
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem nfp_lt_ord_of_isRegular {f : Ordinal → Ordinal} {c} (hc : IsRegular c) (hc' : c ≠ ℵ₀)
    (hf : ∀ i < c.ord, f i < c.ord) {a} : a < c.ord → nfp f a < c.ord
-- Mathlib/Topology/PartialHomeomorph.lean
theorem image_eq (h : e.IsImage s t) : e '' (e.source ∩ s) = e.target ∩ t
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
@[simp]
theorem indexEquiv_apply_ofIsReal (w : {w : InfinitePlace K // IsReal w}) :
    (indexEquiv K) (Sum.inl w) = w.val.embedding
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mulPosMono_iff_mulPosReflectLT : MulPosMono α ↔ MulPosReflectLT α
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem iff_symm_preimage_eq : e.IsImage s t ↔ e.target ∩ e.symm ⁻¹' s = e.target ∩ t
-- Mathlib/Order/SuccPred/IntervalSucc.lean
/-- If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `Set.Ioc (f Order.pred n) (f n)` are pairwise disjoint. -/
theorem pairwise_disjoint_on_Ioc_pred [PredOrder α] [Preorder β] {f : α → β} (hf : Monotone f) :
    Pairwise (Disjoint on fun n => Ioc (f (pred n)) (f n))
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc (attr := simp)]
theorem inr_comp_pushoutSymmetry_hom [HasPushout f g] :
    pushout.inr _ _ ≫ (pushoutSymmetry f g).hom = pushout.inl _ _
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem ite_same (t s : Set α) : t.ite s s = s
-- Mathlib/Data/Finset/Lattice.lean
theorem exists_next_right {x : α} {s : Finset α} (h : ∃ y ∈ s, x < y) :
    ∃ y ∈ s, x < y ∧ ∀ z ∈ s, x < z → y ≤ z
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropWithinAt_inter' (ht : t ∈ 𝓝[s] x) :
    LiftPropWithinAt P g (s ∩ t) x ↔ LiftPropWithinAt P g s x
-- Mathlib/Topology/Order/MonotoneContinuity.lean
/-- If a function `f` with a densely ordered codomain is strictly monotone on a left neighborhood of
`a` and the image of this neighborhood under `f` is a left neighborhood of `f a`, then `f` is
continuous at `a` from the left. -/
theorem StrictMonoOn.continuousWithinAt_left_of_image_mem_nhdsWithin [DenselyOrdered β] {f : α → β}
    {s : Set α} {a : α} (h_mono : StrictMonoOn f s) (hs : s ∈ 𝓝[≤] a) (hfs : f '' s ∈ 𝓝[≤] f a) :
    ContinuousWithinAt f (Iic a) a
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive (attr := push_cast, simp)]
theorem coe_one_interval : ((1 : NonemptyInterval α) : Interval α) = 1
-- Mathlib/Data/Seq/Computation.lean
theorem exists_of_mem_map {f : α → β} {b : β} {s : Computation α} (h : b ∈ map f s) :
    ∃ a, a ∈ s ∧ f a = b
-- Mathlib/CategoryTheory/Limits/FinallySmall.lean
theorem hasColimitsOfShape_of_finallySmall (J : Type u) [Category.{v} J] [FinallySmall.{w} J]
    (C : Type u₁) [Category.{v₁} C] [HasColimitsOfSize.{w, w} C] : HasColimitsOfShape J C
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem exists_ne_forall_mem_nhds_pos_measure_preimage {β} [TopologicalSpace β] [T1Space β]
    [SecondCountableTopology β] [Nonempty β] {f : α → β} (h : ∀ b, ∃ᵐ x ∂μ, f x ≠ b) :
    ∃ a b : β, a ≠ b ∧ (∀ s ∈ 𝓝 a, 0 < μ (f ⁻¹' s)) ∧ ∀ t ∈ 𝓝 b, 0 < μ (f ⁻¹' t)
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem swap_swap (x : M ∗ N) : swap N M (swap M N x) = x
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- A continuous function with compact support on a product space is strongly measurable for the
product sigma-algebra. The subtlety is that we do not assume that the spaces are separable, so the
product of the Borel sigma algebras might not contain all open sets, but still it contains enough
of them to approximate compactly supported continuous functions. -/
lemma _root_.HasCompactSupport.stronglyMeasurable_of_prod {X Y : Type*} [Zero α]
    [TopologicalSpace X] [TopologicalSpace Y] [MeasurableSpace X] [MeasurableSpace Y]
    [OpensMeasurableSpace X] [OpensMeasurableSpace Y] [TopologicalSpace α] [PseudoMetrizableSpace α]
    {f : X × Y → α} (hf : Continuous f) (h'f : HasCompactSupport f) :
    StronglyMeasurable f
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem countP_filter (l : List α) :
    countP p (filter q l) = countP (fun a => p a ∧ q a) l
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_closedBall' : y ∈ closedBall x ε ↔ dist x y ≤ ε
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem of_nonneg_disjoint_union_eq_zero {s : SignedMeasure α} {A B : Set α} (h : Disjoint A B)
    (hA₁ : MeasurableSet A) (hB₁ : MeasurableSet B) (hA₂ : 0 ≤ s A) (hB₂ : 0 ≤ s B)
    (hAB : s (A ∪ B) = 0) : s A = 0
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem liftHom_of {x : R} : liftHom f a hfx (of f x) = algebraMap _ _ x
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
@[reassoc]
lemma liftCycles_shift_homologyπ
    (K : CochainComplex C ℤ) {A : C} {n i : ℤ} (f : A ⟶ (K⟦n⟧).X i) (j : ℤ)
    (hj : (up ℤ).next i = j) (hf : f ≫ (K⟦n⟧).d i j = 0) (i' : ℤ) (hi' : n + i = i') (j' : ℤ)
    (hj' : (up ℤ).next i' = j') :
    (K⟦n⟧).liftCycles f j hj hf ≫ (K⟦n⟧).homologyπ i =
      K.liftCycles (f ≫ (K.shiftFunctorObjXIso n i i' (by omega)).hom) j' hj' (by
        simp only [next] at hj hj'
        obtain rfl : i' = i + n := by omega
        obtain rfl : j' = j + n := by omega
        dsimp at hf ⊢
        simp only [Linear.comp_units_smul] at hf
        apply (one_smul (M := ℤˣ) _).symm.trans _
        rw [← Int.units_mul_self n.negOnePow, mul_smul, comp_id, hf, smul_zero]) ≫
        K.homologyπ i' ≫
          ((HomologicalComplex.homologyFunctor C (up ℤ) 0).shiftIso n i i' hi').inv.app K
-- Mathlib/CategoryTheory/EqToHom.lean
@[reassoc (attr := simp)]
theorem eqToHom_trans {X Y Z : C} (p : X = Y) (q : Y = Z) :
    eqToHom p ≫ eqToHom q = eqToHom (p.trans q)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem sInter_empty : ⋂₀ (∅ : ZFSet) = ∅
-- Mathlib/Data/Multiset/Range.lean
theorem range_add (a b : ℕ) : range (a + b) = range a + (range b).map (a + ·)
-- Mathlib/Data/Set/Finite.lean
/-- Finite product of finite sets is finite -/
theorem Finite.pi (ht : ∀ i, (t i).Finite) : (pi univ t).Finite
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
/-- Two nonzero vectors go to the same point in projective space if and only if one is
a scalar multiple of the other. -/
theorem mk_eq_mk_iff' (v w : V) (hv : v ≠ 0) (hw : w ≠ 0) :
    mk K v hv = mk K w hw ↔ ∃ a : K, a • w = v
-- Mathlib/Analysis/Complex/Basic.lean
theorem equivRealProd_apply_le (z : ℂ) : ‖equivRealProd z‖ ≤ abs z
-- Mathlib/Data/Finset/Pi.lean
@[simp] lemma card_piDiag (s : Finset α) (ι : Type*) [DecidableEq (ι → α)] [Nonempty ι] :
    (s.piDiag ι).card = s.card
-- Mathlib/Data/Set/Function.lean
/-- This lemma is a special case of `rightInvOn_invFunOn.image_image'`; it may make more sense
to use the other lemma directly in an application. -/
theorem SurjOn.image_invFunOn_image_of_subset [Nonempty α] {r : Set β} (hf : SurjOn f s t)
    (hrt : r ⊆ t) : f '' (f.invFunOn s '' r) = r
-- Mathlib/Data/Fintype/Lattice.lean
/-- A special case of `Finset.inf_eq_iInf` that omits the useless `x ∈ univ` binder. -/
theorem inf_univ_eq_iInf [CompleteLattice β] (f : α → β) : Finset.univ.inf f = iInf f
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem erase_add (a : α) (f f' : α →₀ M) : erase a (f + f') = erase a f + erase a f'
-- Mathlib/Algebra/Order/Ring/Abs.lean
@[simp]
theorem abs_dvd (a b : α) : |a| ∣ b ↔ a ∣ b
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
theorem prod_map_pre_app_comp_ev (f : B ⟶ A) [Exponentiable B] (X : C) :
    Limits.prod.map (𝟙 B) ((pre f).app X) ≫ (exp.ev B).app X =
      Limits.prod.map f (𝟙 (A ⟹ X)) ≫ (exp.ev A).app X
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
theorem xgcdAux_rec {r s t r' s' t' : R} (h : r ≠ 0) :
    xgcdAux r s t r' s' t' = xgcdAux (r' % r) (s' - r' / r * s) (t' - r' / r * t) r s t
-- Mathlib/NumberTheory/Dioph.lean
theorem lt_dioph : Dioph {v | f v < g v}
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem smul_toNNReal (a : ℝ≥0) (b : ℝ≥0∞) : (a • b).toNNReal = a * b.toNNReal
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem deleteEdges_eq_inter_edgeSet (s : Set (Sym2 V)) :
    G.deleteEdges s = G.deleteEdges (s ∩ G.edgeSet)
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl)
Construct the limiting coalgebra from the map `λ : L ⟶ TL` given by `lambda`. We are required to
show it satisfies the two coalgebra laws, which follow from the coalgebra laws for the image of `D`
and our `commuting` lemma.
-/
@[simps]
def conePoint : Coalgebra T