ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem gradient_const : ∇ (fun _ => c) x = 0
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt32.le_antisymm_iff {x y : UInt32} : x = y ↔ x ≤ y ∧ y ≤ x
-- Mathlib/Topology/Algebra/Order/Floor.lean
/-- A special case of `ContinuousOn.comp_fract`. -/
theorem ContinuousOn.comp_fract'' {f : α → β} (h : ContinuousOn f I) (hf : f 0 = f 1) :
    Continuous (f ∘ fract)
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
theorem Pi.lift_π {β : Type w} {f : β → C} [HasProduct f] {P : C} (p : ∀ b, P ⟶ f b) (b : β) :
    Pi.lift p ≫ Pi.π f b = p b
-- Mathlib/Topology/MetricSpace/Bounded.lean
/-- The distance between two points in a set is controlled by the diameter of the set. -/
theorem dist_le_diam_of_mem' (h : EMetric.diam s ≠ ⊤) (hx : x ∈ s) (hy : y ∈ s) :
    dist x y ≤ diam s
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem closedBall_mem_nhds (x : α) {ε : ℝ≥0∞} (ε0 : 0 < ε) : closedBall x ε ∈ 𝓝 x
-- Mathlib/Topology/Compactness/Lindelof.lean
@[simp]
theorem Filter.coLindelof_eq_bot [LindelofSpace X] : Filter.coLindelof X = ⊥
-- Mathlib/Probability/Martingale/Basic.lean
protected theorem integrable (hf : Martingale f ℱ μ) (i : ι) : Integrable (f i) μ
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isNat_natMod : {a b : ℕ} → {a' b' c : ℕ} →
    IsNat a a' → IsNat b b' → Nat.mod a' b' = c → IsNat (a % b) c
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_inter_subset_right : s ○ (t₁ ∩ t₂) ⊆ s ○ t₁ ∩ s ○ t₂
-- Mathlib/Algebra/Star/Basic.lean
/-- A `*`-additive monoid `R` is an additive monoid with an involutive `star` operation which
preserves addition.  -/
class StarAddMonoid (R : Type u) [AddMonoid R] extends InvolutiveStar R where
  /-- `star` commutes with addition -/
  star_add : ∀ r s : R, star (r + s) = star r + star s
-- Mathlib/CategoryTheory/Shift/Basic.lean
theorem shift_equiv_triangle (n : A) (X : C) :
    (shiftShiftNeg X n).inv⟦n⟧' ≫ (shiftNegShift (X⟦n⟧) n).hom = 𝟙 (X⟦n⟧)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem shiftLeft_add {w : Nat} (x : BitVec w) (n m : Nat) :
    x <<< (n + m) = (x <<< n) <<< m
-- Mathlib/Order/Hom/Set.lean
/-- We can regard an order embedding as an order isomorphism to its range. -/
@[simps! apply]
noncomputable def OrderEmbedding.orderIso [LE α] [LE β] {f : α ↪o β} :
    α ≃o Set.range f
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
@[simp]
theorem AffineEquiv.coe_toHomeomorphOfFiniteDimensional_symm (f : PE ≃ᵃ[𝕜] PF) :
    ⇑f.toHomeomorphOfFiniteDimensional.symm = f.symm
-- Mathlib/Algebra/CharP/Basic.lean
theorem ringChar_ne_zero_of_finite [Finite R] : ringChar R ≠ 0
-- Mathlib/NumberTheory/PrimesCongruentOne.lean
/-- For any positive `k : ℕ` there are infinitely many primes `p` such that `p ≡ 1 [MOD k]`. -/
theorem infinite_setOf_prime_modEq_one {k : ℕ} (hk0 : k ≠ 0) :
    Set.Infinite {p : ℕ | Nat.Prime p ∧ p ≡ 1 [MOD k]}
-- Mathlib/GroupTheory/Coxeter/Basic.lean
/-- Reindex a Coxeter system through a bijection of the indexing sets. -/
@[simps]
protected def reindex (e : B ≃ B') : CoxeterSystem (M.reindex e) W
-- Mathlib/MeasureTheory/Measure/Portmanteau.lean
theorem limsup_measure_le_of_le_liminf_measure_compl {ι : Type*} {L : Filter ι} {μ : Measure Ω}
    {μs : ι → Measure Ω} [IsProbabilityMeasure μ] [∀ i, IsProbabilityMeasure (μs i)] {E : Set Ω}
    (E_mble : MeasurableSet E) (h : μ Eᶜ ≤ L.liminf fun i => μs i Eᶜ) :
    (L.limsup fun i => μs i E) ≤ μ E
-- Mathlib/Algebra/Order/Monoid/NatCast.lean
lemma zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
    (0 : α) ≤ 2
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_commute [Mul G] {a : G} {b : k} (ha : ∀ a', Commute a a') (hb : ∀ b', Commute b b') :
    ∀ f : MonoidAlgebra k G, Commute (single a b) f
-- Mathlib/Order/Interval/Set/WithBotTop.lean
theorem image_coe_Ici : (some : α → WithTop α) '' Ici a = Ico (a : WithTop α) ⊤
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_Ico [DivisionRing α] {x : α} (hx : x ≠ 1) {m n : ℕ} (hmn : m ≤ n) :
    ∑ i ∈ Finset.Ico m n, x ^ i = (x ^ n - x ^ m) / (x - 1)
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem sup_bihimp_bihimp : (a ⊔ b) ⇔ (a ⇔ b) = a ⊓ b
-- Mathlib/Data/Nat/Factorial/Basic.lean
@[simp] lemma one_lt_factorial : 1 < n ! ↔ 1 < n
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem erase_cons_subperm_cons_erase (a b : α) (l : List α) :
    (a :: l).erase b <+~ a :: l.erase b
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
protected theorem Set.Equicontinuous.mono {H H' : Set <| X → α} (h : H.Equicontinuous)
    (hH : H' ⊆ H) : H'.Equicontinuous
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem eq_false_of_le_false : ∀ {x : Bool}, x ≤ false → x = false
-- Mathlib/Data/Multiset/Basic.lean
theorem filter_singleton {a : α} (p : α → Prop) [DecidablePred p] :
    filter p {a} = if p a then {a} else ∅
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] lemma _root_.EquivLike.apply_coe_symm_apply {F} [EquivLike F α β] (e : F) (x : β) :
    e ((e : α ≃ β).symm x) = x
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
/-- A cyclotomic finite extension of a number field is a number field. -/
theorem numberField [h : NumberField K] [Finite S] [IsCyclotomicExtension S K L] : NumberField L
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[norm_cast]
theorem coe_distribMulActionHom_mk (f : A →ₛₙₐ[φ] B) (h₁ h₂ h₃ h₄) :
    ((⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →ₛₙₐ[φ] B) : A →ₑ+[φ] B) = ⟨⟨f, h₁⟩, h₂, h₃⟩
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem enum_nil : enum (nil : Seq α) = nil
-- Mathlib/Data/Multiset/Basic.lean
theorem count_pos {a : α} {s : Multiset α} : 0 < count a s ↔ a ∈ s
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_objs_of_src {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : c ∈ S.objs
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem eq_span_singleton_mul {x : R} (I J : Ideal R) :
    I = span {x} * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I
-- Mathlib/MeasureTheory/PiSystem.lean
theorem piiUnionInter_singleton (π : ι → Set (Set α)) (i : ι) :
    piiUnionInter π {i} = π i ∪ {univ}
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem degree_eq_one_of_irreducible_of_splits {p : K[X]} (hp : Irreducible p)
    (hp_splits : Splits (RingHom.id K) p) : p.degree = 1
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem exists_mem_range : ∃ n : ℕ, n < p ∧ x - n ∈ maximalIdeal ℤ_[p]
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem Differentiable.add_const (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => f y + c
-- Mathlib/Dynamics/Ergodic/Ergodic.lean
/-- See also `Ergodic.ae_empty_or_univ_of_ae_le_preimage`. -/
theorem ae_empty_or_univ_of_ae_le_preimage' (hf : Ergodic f μ) (hs : MeasurableSet s)
    (hs' : s ≤ᵐ[μ] f ⁻¹' s) (h_fin : μ s ≠ ∞) : s =ᵐ[μ] (∅ : Set α) ∨ s =ᵐ[μ] univ
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherian_top_iff : IsNoetherian R (⊤ : Submodule R M) ↔ IsNoetherian R M
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
/-- A monomorphism is injective on pseudoelements. -/
theorem pseudo_injective_of_mono {P Q : C} (f : P ⟶ Q) [Mono f] : Function.Injective f
-- Mathlib/Order/KrullDimension.lean
lemma krullDim_eq_bot_of_isEmpty [IsEmpty α] : krullDim α = ⊥
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem isLocalizedModule_iff_isLocalization {A Aₛ} [CommSemiring A] [Algebra R A] [CommSemiring Aₛ]
    [Algebra A Aₛ] [Algebra R Aₛ] [IsScalarTower R A Aₛ] :
    IsLocalizedModule S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap ↔
      IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ
-- Mathlib/Order/Hom/Lattice.lean
@[simp] theorem comp_id (f : SupBotHom α β) : f.comp (SupBotHom.id α) = f
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
theorem edist_le_mul_of_le (h : LipschitzOnWith K f s) {x y : α} (hx : x ∈ s) (hy : y ∈ s)
    {r : ℝ≥0∞} (hr : edist x y ≤ r) :
    edist (f x) (f y) ≤ K * r
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
protected theorem mapL_smul [DecidableEq ι] (i : ι) (c : 𝕜) (u : E i →L[𝕜] E' i) :
    mapL (update f i (c • u)) = c • mapL (update f i u)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem dvd_iff_emod_eq_zero (a b : Int) : a ∣ b ↔ b % a = 0
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem linear_refl : (refl k P₁).linear = LinearEquiv.refl k V₁
-- Mathlib/Algebra/Lie/Weights/Basic.lean
@[simp]
lemma coe_zero [Nontrivial (weightSpace M (0 : L → R))] : ((0 : Weight R L M) : L → R) = 0
-- Mathlib/Data/DFinsupp/Basic.lean
theorem filter_apply_neg [∀ i, Zero (β i)] {p : ι → Prop} [DecidablePred p] (f : Π₀ i, β i) {i : ι}
    (h : ¬p i) : f.filter p i = 0
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
@[simp]
theorem leInfCone_π_app_none {A : C} (s : Set (Subobject A)) (f : Subobject A)
    (k : ∀ g ∈ s, f ≤ g) : (leInfCone s f k).π.app none = f.arrow
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem symm_symm (e : A ≃⋆ₐ[R] B) : e.symm.symm = e
-- Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
theorem star_def (x : CliffordAlgebra Q) : star x = reverse (involute x)
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_le_sSup_of_subset_insert_bot (h : s ⊆ insert ⊥ t) : sSup s ≤ sSup t
-- Mathlib/LinearAlgebra/Matrix/Orthogonal.lean
/-- `Aᵀ` has orthogonal rows iff `A` has orthogonal columns. -/
@[simp]
theorem transpose_hasOrthogonalRows_iff_hasOrthogonalCols [Fintype m] :
    Aᵀ.HasOrthogonalRows ↔ A.HasOrthogonalCols
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- In a space with the Besicovitch covering property, the ratio of the measure of balls converges
almost surely to the Radon-Nikodym derivative. -/
theorem ae_tendsto_rnDeriv (ρ μ : Measure β) [IsLocallyFiniteMeasure μ] [IsLocallyFiniteMeasure ρ] :
    ∀ᵐ x ∂μ,
      Tendsto (fun r => ρ (closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 (ρ.rnDeriv μ x))
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp]
theorem mul_eq_left₀ (ha : a ≠ 0) : a * b = a ↔ b = 1
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_Ioi_atTop [SemilatticeSup α] {a : α} {f : β → Ioi a} {l : Filter β} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l atTop
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[trans]
theorem IsBigO.trans_eventuallyEq {f : α → E} {g₁ g₂ : α → F} (h : f =O[l] g₁) (hg : g₁ =ᶠ[l] g₂) :
    f =O[l] g₂
-- Mathlib/Computability/Reduce.lean
theorem disjoin_manyOneReducible {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} : p ≤₀ r → q ≤₀ r → (p ⊕' q) ≤₀ r
-- Mathlib/CategoryTheory/Limits/Preserves/Limits.lean
@[reassoc (attr := simp)]
theorem lift_comp_preservesLimitsIso_hom (t : Cone F) :
    G.map (limit.lift _ t) ≫ (preservesLimitIso G F).hom =
    limit.lift (F ⋙ G) (G.mapCone _)
-- Mathlib/Data/Set/Lattice.lean
theorem monotone_preimage {f : α → β} : Monotone (preimage f)
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem monic_geom_sum_X {n : ℕ} (hn : n ≠ 0) : (∑ i ∈ range n, (X : R[X]) ^ i).Monic
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem cons_diff (a : α) (l₁ l₂ : List α) :
    (a :: l₁).diff l₂ = if a ∈ l₂ then l₁.diff (l₂.erase a) else a :: l₁.diff l₂
-- Mathlib/Analysis/PSeries.lean
/-- The harmonic series restricted to a residue class is not summable. -/
lemma Real.not_summable_indicator_one_div_natCast {m : ℕ} (hm : m ≠ 0) (k : ZMod m) :
    ¬ Summable ({n : ℕ | (n : ZMod m) = k}.indicator fun n : ℕ ↦ (1 / n : ℝ))
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem smul_eq_C_mul (f : R⟦X⟧) (a : R) : a • f = C R a * f
-- Mathlib/CategoryTheory/Category/Pointed.lean
@[simp] lemma Hom.id_toFun' (X : Pointed.{u}) : (𝟙 X : X ⟶ X).toFun = _root_.id
-- Mathlib/Algebra/Polynomial/Bivariate.lean
/-- Two equivalent ways to express the evaluation of a bivariate polynomial over `R`
at a point in the affine plane over an `R`-algebra `S`. -/
lemma eval₂RingHom_eval₂RingHom (f : R →+* S) (x y : S) :
    eval₂RingHom (eval₂RingHom f x) y =
      (evalEvalRingHom x y).comp (mapRingHom <| mapRingHom f)
-- Mathlib/Computability/Reduce.lean
theorem OneOneEquiv.congr_right {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv q r) :
    OneOneEquiv p q ↔ OneOneEquiv p r
-- Mathlib/Data/Nat/Hyperoperation.lean
@[simp]
theorem hyperoperation_two : hyperoperation 2 = (· * ·)
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A binary product of proper maps is proper. -/
lemma IsProperMap.prod_map {g : Z → W} (hf : IsProperMap f) (hg : IsProperMap g) :
    IsProperMap (Prod.map f g)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem norm_intCast (n : ℤ) : norm (n : ℤ√d) = n * n
-- Mathlib/FieldTheory/RatFunc/Degree.lean
theorem natDegree_num_mul_right_sub_natDegree_denom_mul_left_eq_intDegree {x : RatFunc K}
    (hx : x ≠ 0) {s : K[X]} (hs : s ≠ 0) :
    ((x.num * s).natDegree : ℤ) - (s * x.denom).natDegree = x.intDegree
-- Mathlib/Order/Filter/Extr.lean
theorem IsMinOn.inf (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊓ g x) s a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem map_singletonSubgraph (f : G →g G') {v : V} :
    Subgraph.map f (G.singletonSubgraph v) = G'.singletonSubgraph (f v)
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
/-- If `f` is a Hölder continuous map with exponent `r > 0`, then the Hausdorff dimension of its
range is at most the Hausdorff dimension of its domain divided by `r`. -/
theorem dimH_range_le (h : HolderWith C r f) (hr : 0 < r) :
    dimH (range f) ≤ dimH (univ : Set X) / r
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem coe_ne_one {x : Ioc (0 : α) 1} : (x : α) ≠ 1 ↔ x ≠ 1
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem toSubalgebra_eq_iff : F.toSubalgebra = E.toSubalgebra ↔ F = E
-- Mathlib/Algebra/Associated/Basic.lean
theorem mk_le_mk_iff_dvd {a b : α} : Associates.mk a ≤ Associates.mk b ↔ a ∣ b
-- Mathlib/Order/Filter/Basic.lean
theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : φ ∘ ψ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : map φ f = g
-- Mathlib/Data/List/Sort.lean
@[simp]
theorem sorted_cons {a : α} {l : List α} : Sorted r (a :: l) ↔ (∀ b ∈ l, r a b) ∧ Sorted r l
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
lemma shiftFunctorAdd_hom_app_f (K : CochainComplex C ℤ) (a b n : ℤ) :
    ((shiftFunctorAdd (CochainComplex C ℤ) a b).hom.app K).f n =
      (K.XIsoOfEq (by dsimp; rw [add_comm a, add_assoc])).hom
-- Mathlib/Order/Bounds/Basic.lean
/-- The image under an antitone function of a set which is bounded below is bounded above. -/
theorem map_bddBelow (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s)
-- Mathlib/Data/Finset/NAry.lean
theorem forall_image₂_iff {p : γ → Prop} :
    (∀ z ∈ image₂ f s t, p z) ↔ ∀ x ∈ s, ∀ y ∈ t, p (f x y)
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem continuum_add_aleph0 : 𝔠 + ℵ₀ = 𝔠
-- Mathlib/Geometry/RingedSpace/SheafedSpace.lean
@[simp]
theorem Γ_obj (X : (SheafedSpace C)ᵒᵖ) : Γ.obj X = (unop X).presheaf.obj (op ⊤)
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiable_snd : MDifferentiable (I.prod I') I' (Prod.snd : M × M' → M')
-- Mathlib/RingTheory/Localization/Basic.lean
theorem isLocalization_of_algEquiv [Algebra R P] [IsLocalization M S] (h : S ≃ₐ[R] P) :
    IsLocalization M P
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem orthogonal_span_singleton_eq_to_lin_ker {B : V →ₗ[K] V →ₛₗ[J] V₂} (x : V) :
    Submodule.orthogonalBilin (K ∙ x) B = LinearMap.ker (B x)
-- Mathlib/Data/Nat/Cast/NeZero.lean
lemma pos_of_neZero_natCast (R) [AddMonoidWithOne R] {n : ℕ} [NeZero (n : R)] : 0 < n
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
lemma δ_rightShift (a n' m' : ℤ) (hn' : n' + a = n) (m : ℤ) (hm' : m' + a = m) :
    δ n' m' (γ.rightShift a n' hn') = a.negOnePow • (δ n m γ).rightShift a m' hm'
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem prodComm_apply (x : α × β) : prodComm α β x = x.swap
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean
@[continuity, fun_prop]
lemma continuous_exp : Continuous exp
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma symm {X Y : C} {z₁ z₂ : W.RightFraction X Y} (h : RightFractionRel z₁ z₂) :
    RightFractionRel z₂ z₁
-- Mathlib/Topology/Covering.lean
protected theorem quotientMap (hf' : Function.Surjective f) : QuotientMap f
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
lemma restrictStalkIso_inv_eq_ofRestrict :
    (X.restrictStalkIso h x).inv = (X.ofRestrict h).stalkMap x
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem range_const_subset (α) [MeasurableSpace α] (b : β) : (const α b).range ⊆ {b}
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_eq_zero_of_dvd_aeval_eq_zero [CommSemiring S] [CommSemiring T] [Algebra S T]
    {p q : S[X]} (h₁ : p ∣ q) {a : T} (h₂ : aeval a p = 0) : aeval a q = 0
-- Mathlib/Data/Finite/Card.lean
theorem card_union_le (s t : Set α) : Nat.card (↥(s ∪ t)) ≤ Nat.card s + Nat.card t
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
protected theorem mdifferentiableOn : MDifferentiableOn I J Φ Φ.source
-- Mathlib/Data/Seq/Computation.lean
@[simp] lemma liftRelAux_inr_inl {b : β} {ca} :
    LiftRelAux R C (Sum.inr ca) (Sum.inl b) = ∃ a, a ∈ ca ∧ R a b
-- Mathlib/Order/Category/FinPartOrd.lean
theorem FinPartOrd_dual_comp_forget_to_partOrd :
    FinPartOrd.dual ⋙ forget₂ FinPartOrd PartOrd =
      forget₂ FinPartOrd PartOrd ⋙ PartOrd.dual
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoDiv_add_zsmul (a b : α) (m : ℤ) : toIcoDiv hp a (b + m • p) = toIcoDiv hp a b + m
-- Mathlib/Data/NNReal/Basic.lean
@[norm_cast]
theorem coe_list_prod (l : List ℝ≥0) : ((l.prod : ℝ≥0) : ℝ) = (l.map (↑)).prod
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem gcd_mul_left [NormalizedGCDMonoid α] (a b c : α) :
    gcd (a * b) (a * c) = normalize a * gcd b c
-- Mathlib/Order/SuccPred/Relation.lean
/-- For `n ≤ m`, `(n, m)` is in the reflexive-transitive closure of `~` if `pred i ~ i`
  for all `i` between `n` and `m`. -/
theorem reflTransGen_of_pred_of_le (r : α → α → Prop) {n m : α} (h : ∀ i ∈ Ioc n m, r (pred i) i)
    (hmn : n ≤ m) : ReflTransGen r n m
-- Mathlib/Topology/PartialHomeomorph.lean
theorem eventually_nhdsWithin {x : X} (p : Y → Prop) {s : Set X}
    (hx : x ∈ e.source) : (∀ᶠ y in 𝓝[e.symm ⁻¹' s] e x, p y) ↔ ∀ᶠ x in 𝓝[s] x, p (e x)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
/-- The map `Cocycle K (L⟦a⟧) n' → Cocycle K L n` when `n' + a = n`. -/
@[simps!]
def rightUnshift {n' a : ℤ} (γ : Cocycle K (L⟦a⟧) n') (n : ℤ) (hn : n' + a = n) :
    Cocycle K L n
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.exchange_base_of_indep (hB : M.Base B) (hf : f ∉ B)
    (hI : M.Indep (insert f (B \ {e}))) : M.Base (insert f (B \ {e}))
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
/-- A null measurable set `t` is Carathéodory measurable: for any `s`, we have
`μ (s ∩ t) + μ (s \ t) = μ s`. -/
theorem measure_inter_add_diff₀ (s : Set α) (ht : NullMeasurableSet t μ) :
    μ (s ∩ t) + μ (s \ t) = μ s
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
@[simp]
theorem toTensor_ι (m : M) : FreeAlgebra.toTensor (FreeAlgebra.ι R m) = TensorAlgebra.ι R m
-- Mathlib/Logic/Relator.lean
lemma BiTotal.rel_exists (h : BiTotal R) :
    ((R ⇒ Iff) ⇒ Iff) (fun p => ∃i, p i) (fun q => ∃i, q i)
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
theorem smul_mem_pointwise_smul (m : M) (a : α) (S : Submodule R M) : m ∈ S → a • m ∈ a • S
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
theorem measurable_of_measurable_nnreal_nnreal [MeasurableSpace β] {f : ℝ≥0∞ × ℝ≥0∞ → β}
    (h₁ : Measurable fun p : ℝ≥0 × ℝ≥0 => f (p.1, p.2)) (h₂ : Measurable fun r : ℝ≥0 => f (∞, r))
    (h₃ : Measurable fun r : ℝ≥0 => f (r, ∞)) : Measurable f
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
theorem coe_decompose_mul_of_right_mem (n) [Decidable (i ≤ n)] (b_mem : b ∈ 𝒜 i) :
    (decompose 𝒜 (a * b) n : A) = if i ≤ n then decompose 𝒜 a (n - i) * b else 0
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_add (f : M →ₗ⁅R,L⁆ N) (x y : M) : f (x + y) = f x + f y
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem map_eq_foldl (as : Array α) (f : α → β) :
    as.map f = as.foldl (fun r a => r.push (f a)) #[]