ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Group/ULift.lean
@[simp, norm_cast]
theorem up_intCast [IntCast α] (n : ℤ) : up (n : α) = n
-- Mathlib/FieldTheory/IntermediateField.lean
/-- The range of an algebra homomorphism, as an intermediate field. -/
@[simps toSubalgebra]
def fieldRange : IntermediateField K L'
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.congr_mono {f g : α → β} {s s₁ : Set α} {x : α}
    (h : ContinuousWithinAt f s x) (h' : EqOn g f s₁) (h₁ : s₁ ⊆ s) (hx : g x = f x) :
    ContinuousWithinAt g s₁ x
-- Mathlib/Analysis/Convex/Cone/InnerDual.lean
/-- This is a stronger version of the Hahn-Banach separation theorem for closed convex cones. This
is also the geometric interpretation of Farkas' lemma. -/
theorem ConvexCone.hyperplane_separation_of_nonempty_of_isClosed_of_nmem (K : ConvexCone ℝ H)
    (ne : (K : Set H).Nonempty) (hc : IsClosed (K : Set H)) {b : H} (disj : b ∉ K) :
    ∃ y : H, (∀ x : H, x ∈ K → 0 ≤ ⟪x, y⟫_ℝ) ∧ ⟪y, b⟫_ℝ < 0
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Ico_mem_nhdsSet_Icc (h : a < b) (h' : c < d) : Ico a d ∈ 𝓝ˢ (Icc b c)
-- Mathlib/Computability/Primrec.lean
theorem prim_iff₂ {f : ℕ → ℕ → ℕ} : (@Primrec' 2 fun v => f v.head v.tail.head) ↔ Primrec₂ f
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem basicOpen_mul (f g : R) : basicOpen (f * g) = basicOpen f ⊓ basicOpen g
-- Mathlib/Topology/Instances/EReal.lean
theorem openEmbedding_coe : OpenEmbedding ((↑) : ℝ → EReal)
-- Mathlib/CategoryTheory/Galois/GaloisObjects.lean
/-- `autMap` is surjective, if the source is also Galois. -/
lemma autMap_surjective_of_isGalois {A B : C} [IsGalois A] [IsGalois B] (f : A ⟶ B) :
    Function.Surjective (autMap f)
-- Mathlib/MeasureTheory/Covering/OneDim.lean
theorem Icc_mem_vitaliFamily_at_right {x y : ℝ} (hxy : x < y) :
    Icc x y ∈ (vitaliFamily (volume : Measure ℝ) 1).setsAt x
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma integral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∫ x, density κ ν a x s ∂(ν a) = (κ a (univ ×ˢ s)).toReal
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- Radon-Nikodym derivative of the scalar multiple of a measure.
See also `rnDeriv_smul_left'`, which requires sigma-finite `ν` and `μ`. -/
theorem rnDeriv_smul_left (ν μ : Measure α) [IsFiniteMeasure ν]
    [ν.HaveLebesgueDecomposition μ] (r : ℝ≥0) :
    (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ
-- Mathlib/Order/Interval/Set/Pi.lean
theorem image_update_Ico_right (f : ∀ i, α i) (i : ι) (b : α i) :
    update f i '' Ico (f i) b = Ico f (update f i b)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
/-- The special-value formula `Γ(1/2) = √π`, which is equivalent to the Gaussian integral. -/
theorem Real.Gamma_one_half_eq : Real.Gamma (1 / 2) = √π
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean
@[reassoc (attr := simp)]
theorem whiskerRight_naturality_id (f : G.obj a ⟶ a') :
    η.naturality (𝟙 a) ▷ f ≫ (α_ _ _ _).hom ≫ η.app a ◁ G.mapId a ▷ f =
    F.mapId a ▷ η.app a ▷ f ≫ (λ_ (η.app a)).hom ▷ f ≫ (ρ_ (η.app a)).inv ▷ f ≫ (α_ _ _ _).hom
-- Mathlib/Data/Stream/Init.lean
theorem take_succ' {s : Stream' α} : ∀ n, s.take (n+1) = s.take n ++ [s.get n]
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem map_add₂ (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (x₁ x₂ y) : f (x₁ + x₂) y = f x₁ y + f x₂ y
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
@[simp]
theorem iteratedDeriv_one : iteratedDeriv 1 f = deriv f
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem sumArrowLequivProdArrow_apply_fst {α β} (f : α ⊕ β → M) (a : α) :
    (sumArrowLequivProdArrow α β R M f).1 a = f (Sum.inl a)
-- Mathlib/Data/Finmap.lean
@[simp]
theorem ext_iff' {s t : Finmap β} : s.entries = t.entries ↔ s = t
-- Mathlib/Data/Real/Hyperreal.lean
theorem st_eq_sSup {x : ℝ*} : st x = sSup { y : ℝ | (y : ℝ*) < x }
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem nndist_midpoint_right (p₁ p₂ : P) :
    nndist (midpoint 𝕜 p₁ p₂) p₂ = ‖(2 : 𝕜)‖₊⁻¹ * nndist p₁ p₂
-- Mathlib/Data/Real/Archimedean.lean
theorem add_neg_lt_sSup {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : ε < 0) :
    ∃ a ∈ s, sSup s + ε < a
-- Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean
@[to_additive]
theorem smul_Lp_neg (c : Mᵈᵐᵃ) (f : Lp E p μ) : c • (-f) = -(c • f)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem embDomain_mul [NonUnitalNonAssocSemiring R] (f : Γ ↪o Γ')
    (hf : ∀ x y, f (x + y) = f x + f y) (x y : HahnSeries Γ R) :
    embDomain f (x * y) = embDomain f x * embDomain f y
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
theorem comp_eval (p : R[X]) (q : PolynomialModule R M) (r : R) :
    eval r (comp p q) = eval (p.eval r) q
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma liftCycles_comp_cyclesMap (φ : S ⟶ S₁) [S₁.HasLeftHomology] :
    S.liftCycles k hk ≫ cyclesMap φ =
      S₁.liftCycles (k ≫ φ.τ₂) (by rw [assoc, φ.comm₂₃, reassoc_of% hk, zero_comp])
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem mem_cyclicPermutations_iff : l ∈ cyclicPermutations l' ↔ l ~r l'
-- Mathlib/NumberTheory/NumberField/Units/Regulator.lean
theorem regulator_ne_zero : regulator K ≠ 0
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
theorem tensorRightHomEquiv_naturality {X Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⊗ Y ⟶ Z)
    (g : Z ⟶ Z') :
    (tensorRightHomEquiv X Y Y' Z') (f ≫ g) = (tensorRightHomEquiv X Y Y' Z) f ≫ g ▷ Y'
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem coe_fst_eventuallyEq_proj (ex : x ∈ e.source) : Prod.fst ∘ e =ᶠ[𝓝 x] proj
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem toNat_lt {n : Nat} {z : Int} (h : 0 ≤ z) : z.toNat < n ↔ z < (n : Int)
-- Mathlib/Order/BoundedOrder.lean
theorem not_isMin_top : ¬IsMin (⊤ : α)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metrizable.lean
theorem aemeasurable_of_tendsto_metrizable_ae {ι} {μ : Measure α} {f : ι → α → β} {g : α → β}
    (u : Filter ι) [hu : NeBot u] [IsCountablyGenerated u] (hf : ∀ n, AEMeasurable (f n) μ)
    (h_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))) : AEMeasurable g μ
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
nonrec theorem FarFromTriangleFree.mono (hε : G.FarFromTriangleFree ε) (h : δ ≤ ε) :
    G.FarFromTriangleFree δ
-- Mathlib/Topology/Connected/Clopen.lean
/-- A continuous map from a connected space to a disjoint union `Σ i, π i` can be lifted to one of
the components `π i`. See also `ContinuousMap.exists_lift_sigma` for a version with bundled
`ContinuousMap`s. -/
theorem Continuous.exists_lift_sigma [ConnectedSpace α] [∀ i, TopologicalSpace (π i)]
    {f : α → Σ i, π i} (hf : Continuous f) :
    ∃ (i : ι) (g : α → π i), Continuous g ∧ f = Sigma.mk i ∘ g
-- Mathlib/Data/List/Sort.lean
theorem rel_of_sorted_cons {a : α} {l : List α} : Sorted r (a :: l) → ∀ b ∈ l, r a b
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
@[simp]
theorem algebraMap_eq_C : algebraMap K (RatFunc K) = C
-- Mathlib/Data/Set/Function.lean
theorem exists_injOn_iff_injective [Nonempty β] :
    (∃ f : α → β, InjOn f s) ↔ ∃ f : s → β, Injective f
-- Mathlib/MeasureTheory/Measure/Portmanteau.lean
/-- One implication of the portmanteau theorem:
Weak convergence of probability measures implies that if the boundary of a Borel set
carries no probability mass under the limit measure, then the limit of the measures of the set
equals the measure of the set under the limit probability measure.

A version with coercions to ordinary `ℝ≥0∞`-valued measures is
`MeasureTheory.ProbabilityMeasure.tendsto_measure_of_null_frontier_of_tendsto'`.
-/
theorem ProbabilityMeasure.tendsto_measure_of_null_frontier_of_tendsto {Ω ι : Type*} {L : Filter ι}
    [MeasurableSpace Ω] [PseudoEMetricSpace Ω] [OpensMeasurableSpace Ω] [HasOuterApproxClosed Ω]
    {μ : ProbabilityMeasure Ω} {μs : ι → ProbabilityMeasure Ω} (μs_lim : Tendsto μs L (𝓝 μ))
    {E : Set Ω} (E_nullbdry : μ (frontier E) = 0) : Tendsto (fun i => μs i E) L (𝓝 (μ E))
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
theorem eLpNorm_le_eLpNorm_mul_rpow_measure_univ {p q : ℝ≥0∞} (hpq : p ≤ q)
    (hf : AEStronglyMeasurable f μ) :
    eLpNorm f p μ ≤ eLpNorm f q μ * μ Set.univ ^ (1 / p.toReal - 1 / q.toReal)
-- Mathlib/Probability/Kernel/Disintegration/Unique.lean
lemma Kernel.apply_eq_measure_condKernel_of_compProd_eq
    {ρ : Kernel α (β × Ω)} [IsFiniteKernel ρ] {κ : Kernel (α × β) Ω} [IsFiniteKernel κ]
    (hκ : Kernel.fst ρ ⊗ₖ κ = ρ) (a : α) :
    (fun b ↦ κ (a, b)) =ᵐ[Kernel.fst ρ a] (ρ a).condKernel
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_eq_one_iff_of_lt_of_lt {x : ℝ} (hx₁ : -(2 * π) < x) (hx₂ : x < 2 * π) :
    cos x = 1 ↔ x = 0
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem compatible_iff_sieveCompatible (x : FamilyOfElements P (S : Presieve X)) :
    x.Compatible ↔ x.SieveCompatible
-- Mathlib/RingTheory/LaurentSeries.lean
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_mul : ((f * g : PowerSeries R) : LaurentSeries R) = f * g
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Maximal.lean
theorem toPrimeSpectrum_range :
    Set.range (@toPrimeSpectrum R _) = { x | IsClosed ({x} : Set <| PrimeSpectrum R) }
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- An oriented angle is unchanged by replacing the third point by one weakly further away on the
same ray. -/
theorem _root_.Wbtw.oangle_eq_right {p₁ p₂ p₃ p₃' : P} (h : Wbtw ℝ p₂ p₃ p₃') (hp₃p₂ : p₃ ≠ p₂) :
    ∡ p₁ p₂ p₃ = ∡ p₁ p₂ p₃'
-- Mathlib/Data/Sigma/Basic.lean
theorem _root_.sigma_mk_injective {i : α} : Injective (@Sigma.mk α β i)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Eventually.exists_forall_of_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop}
    (h : ∀ᶠ x in atTop, p x) : ∃ a, ∀ b ≥ a, p b
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem filter_neg [∀ i, AddGroup (β i)] (p : ι → Prop) [DecidablePred p] (f : Π₀ i, β i) :
    (-f).filter p = -f.filter p
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_antilipschitzWith_equiv_aux [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    AntilipschitzWith ((2 : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (α × β))
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem mirror_eval_one : p.mirror.eval 1 = p.eval 1
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
@[simp]
theorem card_incidenceFinset_eq_degree [DecidableEq V] :
    (G.incidenceFinset v).card = G.degree v
-- Mathlib/Topology/VectorBundle/Hom.lean
@[simp, mfld_simps]
theorem hom_trivializationAt_target (x₀ : B) :
    (trivializationAt (F₁ →SL[σ] F₂) (fun x => E₁ x →SL[σ] E₂ x) x₀).target =
      ((trivializationAt F₁ E₁ x₀).baseSet ∩ (trivializationAt F₂ E₂ x₀).baseSet) ×ˢ Set.univ
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem map_tail (f : α → β) : ∀ s, map f (tail s) = tail (map f s)
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_to_countable [MeasurableSpace α] [Countable α] [MeasurableSpace β] {f : β → α}
    (h : ∀ y, MeasurableSet (f ⁻¹' {f y})) : Measurable f
-- Mathlib/Data/Finset/Sum.lean
theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr)
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
@[simp]
theorem boundedBy_eq_self (m : OuterMeasure α) : boundedBy m = m
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem GroupSMul.linearMap_apply [Monoid G] [CommSemiring k] (V : Type u₃) [AddCommMonoid V]
    [Module k V] [Module (MonoidAlgebra k G) V] [IsScalarTower k (MonoidAlgebra k G) V] (g : G)
    (v : V) : (GroupSMul.linearMap k V g) v = single g (1 : k) • v
-- Mathlib/ModelTheory/Syntax.lean
@[simp]
theorem relabelAux_sum_inl (k : ℕ) :
    relabelAux (Sum.inl : α → α ⊕ (Fin n)) k = Sum.map id (natAdd n)
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_neg (x : 𝔸) : exp 𝕂 (-x) = (exp 𝕂 x)⁻¹
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_congr (T : Set α → E →L[ℝ] F)
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T) {f g : α →ₛ E}
    (hf : Integrable f μ) (h : f =ᵐ[μ] g) : f.setToSimpleFunc T = g.setToSimpleFunc T
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
@[reassoc (attr := simp)]
theorem pullbackAssoc_inv_fst_snd [HasPullback ((pullback.snd _ _ : Z₁ ⟶ X₂) ≫ f₃) f₄]
    [HasPullback f₁ ((pullback.fst _ _ : Z₂ ⟶ X₂) ≫ f₂)] :
    (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
    pullback.snd _ _ ≫ pullback.fst _ _
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp] theorem decomposeLinearEquiv_symm_comp_lof (i : ι) :
    (decomposeLinearEquiv ℳ).symm ∘ₗ lof R ι (ℳ ·) i = (ℳ i).subtype
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
@[simp]
theorem isoSheafify_hom {P : Cᵒᵖ ⥤ D} (hP : Presheaf.IsSheaf J P) :
    (J.isoSheafify hP).hom = J.toSheafify P
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem map_esymm (n : ℕ) (f : R →+* S) : map f (esymm σ R n) = esymm σ S n
-- Mathlib/Algebra/DirectSum/Decomposition.lean
protected theorem Decomposition.isInternal : DirectSum.IsInternal ℳ
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem continuous (hf : IsBoundedLinearMap 𝕜 f) : Continuous f
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_const_mul_self (c : R) (f : α → R) (l : Filter α) : (fun x => c * f x) =O[l] f
-- Mathlib/Data/Set/Function.lean
theorem BijOn.surjOn (h : BijOn f s t) : SurjOn f s t
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem zero_lt_orderTop_iff {x : HahnSeries Γ R} (hx : x ≠ 0) :
    0 < x.orderTop ↔ 0 < x.order
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.comp' {g : β → γ} {f : α → β} {s : Set α} {t : Set β} {x : α}
    (hg : ContinuousWithinAt g t (f x)) (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (g ∘ f) (s ∩ f ⁻¹' t) x
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem arrows_ext : ∀ {R S : Sieve X}, R.arrows = S.arrows → R = S
-- Mathlib/Algebra/Quandle.lean
theorem conj_swap {G : Type*} [Group G] (x y : Conj G) : x ◃ y = y ↔ y ◃ x = x
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_comp_comm (L : E ≃L[𝕜] F) (φ : X → E) : ∫ x, L (φ x) ∂μ = L (∫ x, φ x ∂μ)
-- .lake/packages/batteries/Batteries/Classes/Order.lean
/-- `TotalBLE le` asserts that `le` has a total order, that is, `le a b ∨ le b a`. -/
class TotalBLE (le : α → α → Bool) : Prop where
  /-- `le` is total: either `le a b` or `le b a`. -/
  total : le a b ∨ le b a
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Iic_Iic {a : α} (b : Iic a) : Subtype.val '' Iic b = Iic b.1
-- Mathlib/Data/Nat/PartENat.lean
protected theorem add_lt_add_iff_right {x y z : PartENat} (hz : z ≠ ⊤) : x + z < y + z ↔ x < y
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem uniformContinuous_coe : UniformContinuous ι
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem le_arch (a : ℤ√d) : ∃ n : ℕ, a ≤ n
-- Mathlib/Data/PFun.lean
theorem preimage_asSubtype (f : α →. β) (s : Set β) :
    f.asSubtype ⁻¹' s = Subtype.val ⁻¹' f.preimage s
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]
theorem le_to_nat {m n : PosNum} : (m : ℕ) ≤ n ↔ m ≤ n
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem MeasurableSet.image_inclusion' {s t : Set α} (h : s ⊆ t) {u : Set s}
    (hs : MeasurableSet (Subtype.val ⁻¹' s : Set t)) (hu : MeasurableSet u) :
    MeasurableSet (inclusion h '' u)
-- Mathlib/Order/Filter/Cofinite.lean
theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finite s
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem LinearIsometry.contDiff (f : E →ₗᵢ[𝕜] F) : ContDiff 𝕜 n f
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_eq_iSup {s : Set α} : sSup s = ⨆ a ∈ s, a
-- Mathlib/Logic/Equiv/Fin.lean
@[simp]
theorem finSumFinEquiv_symm_last : finSumFinEquiv.symm (Fin.last n) = Sum.inr 0
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.not_and_iff_or_not_not' [Decidable b] : ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem MeasurableSet.of_subtype_image {s : Set α} {t : Set s}
    (h : MeasurableSet (Subtype.val '' t)) : MeasurableSet t
-- Mathlib/Order/Category/BddDistLat.lean
/-- `OrderDual` as a functor. -/
@[simps]
def dual : BddDistLat ⥤ BddDistLat
-- Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean
theorem Integrable.withDensityᵥ_eq_iff {f g : α → E} (hf : Integrable f μ) (hg : Integrable g μ) :
    μ.withDensityᵥ f = μ.withDensityᵥ g ↔ f =ᵐ[μ] g
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
@[simp]
theorem lintegral_indicator_one₀ {s : Set α} (hs : NullMeasurableSet s μ) :
    ∫⁻ a, s.indicator 1 a ∂μ = μ s
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem dual_pure (a : α) : dual (pure a) = pure (toDual a)
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem cmp_eq_eq_symm [OrientedCmp cmp] : cmp x y = .eq ↔ cmp y x = .eq
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
theorem Q_is_eventually_constant {q n : ℕ} (hqn : n ≤ q) :
    ((Q (q + 1)).f n : X _[n] ⟶ _) = (Q q).f n
-- Mathlib/Order/Hom/Lattice.lean
/-- Adjoins a `⊥` to the domain and codomain of a `LatticeHom`. -/
@[simps]
protected def withBot (f : LatticeHom α β) : LatticeHom (WithBot α) (WithBot β)
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_lt_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω < i}
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
/-- Forgetting to the underlying type and then building the bundled object returns the original
module. -/
@[simps]
def ofSelfIso (M : ModuleCat R) : ModuleCat.of R M ≅ M
-- Mathlib/Data/PFun.lean
@[simp]
theorem preimage_comp (f : β →. γ) (g : α →. β) (s : Set γ) :
    (f.comp g).preimage s = g.preimage (f.preimage s)
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.coprime_pow_of_not_dvd {p m a : ℕ} (pp : Prime p) (h : ¬p ∣ a) : Coprime a (p ^ m)
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp] theorem nndist_ofDual (a b : Xᵒᵈ) : nndist (ofDual a) (ofDual b) = nndist a b
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
/-- "A special case of `Multipliable.map_iff_of_leftInverse` for convenience" -/
@[to_additive "A special case of `Summable.map_iff_of_leftInverse` for convenience"]
protected theorem Multipliable.map_iff_of_equiv [CommMonoid γ] [TopologicalSpace γ] {G}
    [EquivLike G α γ] [MulEquivClass G α γ] (g : G) (hg : Continuous g)
    (hg' : Continuous (EquivLike.inv g : γ → α)) : Multipliable (g ∘ f) ↔ Multipliable f
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp]
theorem order_one [MulZeroOneClass R] : order (1 : HahnSeries Γ R) = 0
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_indicator_const {s : Set α} (hs : MeasurableSet s) (c : ℝ≥0∞) :
    ∫⁻ a, s.indicator (fun _ => c) a ∂μ = c * μ s
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
@[reassoc (attr := simp)]
lemma s_r (s : S.Splitting) : s.s ≫ s.r = 0
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
theorem Integrable.integral_norm_condKernel {f : α × Ω → F} (hf_int : Integrable f ρ) :
    Integrable (fun x ↦ ∫ y, ‖f (x, y)‖ ∂ρ.condKernel x) ρ.fst
-- Mathlib/Data/NNReal/Basic.lean
theorem _root_.Real.toNNReal_sum_of_nonneg {α} {s : Finset α} {f : α → ℝ}
    (hf : ∀ a, a ∈ s → 0 ≤ f a) :
    Real.toNNReal (∑ a ∈ s, f a) = ∑ a ∈ s, Real.toNNReal (f a)
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upcrossingsBefore_mono (hab : a < b) : Monotone fun N ω => upcrossingsBefore a b f N ω
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem isPWO_iUnion_support_powers [LinearOrderedCancelAddCommMonoid Γ] [Ring R] [IsDomain R]
    {x : HahnSeries Γ R} (hx : 0 < x.orderTop) : (⋃ n : ℕ, (x ^ n).support).IsPWO
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
/-- A space is totally disconnected iff its connected components are subsingletons. -/
theorem totallyDisconnectedSpace_iff_connectedComponent_subsingleton :
    TotallyDisconnectedSpace α ↔ ∀ x : α, (connectedComponent x).Subsingleton
-- Mathlib/Data/Real/EReal.lean
lemma bot_div_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : ⊥ / a = ⊥
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
@[simp] lemma one_lt_exp_iff {a : EReal} : 1 < exp a ↔ 0 < a
-- Mathlib/Order/Filter/Basic.lean
theorem frequently_iff {f : Filter α} {P : α → Prop} :
    (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem binary_fan_fst_toCone (c : BinaryBicone P Q) : BinaryFan.fst c.toCone = c.fst
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_int_mul_pi (n : ℤ) : sin (n * π) = 0
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
theorem tensor_sum {P Q R S : C} {J : Type*} (s : Finset J) (f : P ⟶ Q) (g : J → (R ⟶ S)) :
    (f ⊗ ∑ j ∈ s, g j) = ∑ j ∈ s, f ⊗ g j
-- Mathlib/Algebra/Order/Module/Algebra.lean
lemma algebraMap_nonneg (ha : 0 ≤ a) : 0 ≤ algebraMap α β a
-- Mathlib/Topology/Bases.lean
/-- In a separable space, a family of nonempty disjoint open sets is countable. -/
theorem _root_.Pairwise.countable_of_isOpen_disjoint [SeparableSpace α] {ι : Type*}
    {s : ι → Set α} (hd : Pairwise (Disjoint on s)) (ho : ∀ i, IsOpen (s i))
    (hne : ∀ i, (s i).Nonempty) : Countable ι
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addZ_neg {P : Fin 3 → R} : addZ P (W'.neg P) = 0
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem castSucc_lt_succ_iff {a b : Fin n} : castSucc a < succ b ↔ a ≤ b
-- Mathlib/Order/Ideal.lean
@[simp]
theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem mul_smul (b b' : B) (x : X') : (b * b') • x = b • b' • x
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- When `sInf s < b`, there is an element `a` in `s` with `a < b`, if `s` is nonempty and the order
is a linear order. -/
theorem exists_lt_of_csInf_lt (hs : s.Nonempty) (hb : sInf s < b) : ∃ a ∈ s, a < b
-- Mathlib/FieldTheory/ChevalleyWarning.lean
/-- The **Chevalley–Warning theorem**, unary version.
Let `f` be a multivariate polynomial in finitely many variables (`X s`, `s : σ`)
over a finite field of characteristic `p`.
Assume that the total degree of `f` is less than the cardinality of `σ`.
Then the number of solutions of `f` is divisible by `p`.
See `char_dvd_card_solutions_of_sum_lt` for a version that takes a family of polynomials `f i`. -/
theorem char_dvd_card_solutions {f : MvPolynomial σ K} (h : f.totalDegree < Fintype.card σ) :
    p ∣ Fintype.card { x : σ → K // eval x f = 0 }
-- Mathlib/Data/Complex/Order.lean
theorem nonneg_iff {z : ℂ} : 0 ≤ z ↔ 0 ≤ z.re ∧ 0 = z.im
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp]
theorem mapIso_refl (f : X ⟶ Y) (h) : mapIso f f h = Iso.refl (map _)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem and_cons : (a::l).and = (a && l.and)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem map_not_measurable {f : α → β} (hf : ¬Measurable f) : v.map f = 0
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_eq_bot : degree p = ⊥ ↔ p = 0
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioi_of_Ioi : AECover (μ.restrict (Ioi A)) l fun i ↦ Ioi (a i)
-- Mathlib/Algebra/CharP/ExpChar.lean
/-- The exponential characteristic is positive. -/
theorem expChar_pos (q : ℕ) [ExpChar R q] : 0 < q
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem reverse_surjective {u v : V} : Function.Surjective (reverse : G.Walk u v → _)
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
theorem IsDiag.map [Zero α] [Zero β] {A : Matrix n n α} (ha : A.IsDiag) {f : α → β} (hf : f 0 = 0) :
    (A.map f).IsDiag
-- Mathlib/Algebra/DirectSum/Ring.lean
private nonrec theorem one_mul (x : ⨁ i, A i) : 1 * x = x
-- Mathlib/Data/Sigma/Basic.lean
/-- A version of `Iff.mp Sigma.ext_iff` for functions from a nonempty type to a sigma type. -/
theorem _root_.Function.eq_of_sigmaMk_comp {γ : Type*} [Nonempty γ]
    {a b : α} {f : γ → β a} {g : γ → β b} (h : Sigma.mk a ∘ f = Sigma.mk b ∘ g) :
    a = b ∧ HEq f g
-- Mathlib/Data/Fin/Basic.lean
theorem castpred_succ_le_iff {a b : Fin (n + 1)} (ha : succ a ≠ last (n + 1)) :
    (succ a).castPred ha ≤ b ↔ a < b
-- Mathlib/Topology/Order/DenselyOrdered.lean
/-- The closure of the interval `(a, b]` is the closed interval `[a, b]`. -/
@[simp]
theorem closure_Ioc {a b : α} (hab : a ≠ b) : closure (Ioc a b) = Icc a b