ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/PFunctor/Univariate/Basic.lean
@[simp]
protected theorem map_eq (f : α → β) (a : P.A) (g : P.B a → α) :
    P.map f ⟨a, g⟩ = ⟨a, f ∘ g⟩
-- Mathlib/Topology/Bornology/BoundedOperation.lean
/-- A typeclass saying that `(p : R × R) ↦ p.1 + p.2` maps any product of bounded sets to a bounded
set. This property follows from `LipschitzAdd`, and thus automatically holds, e.g., for seminormed
additive groups. -/
class BoundedAdd (R : Type*) [Bornology R] [Add R] : Prop where
  isBounded_add : ∀ {s t : Set R},
    Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s + t)
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed { x | f x = y }
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- If `f : X → Y` is an `Inducing` map, the image `f '' s` of a set `s` is Lindelöf
  if and only if `s` is compact. -/
theorem Inducing.isLindelof_iff {f : X → Y} (hf : Inducing f) :
    IsLindelof s ↔ IsLindelof (f '' s)
-- Mathlib/Data/Seq/Computation.lean
theorem Results.terminates {s : Computation α} {a n} (h : Results s a n) : Terminates s
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem Definable.eq {n} :
    ∀ (s : OfArity ZFSet.{u} ZFSet.{u} n) [H : Definable n s], (@Definable.Resp n s H).eval _ = s
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- A category `IsFiltered` if
1. for every pair of objects there exists another object "to the right",
2. for every pair of parallel morphisms there exists a morphism to the right so the compositions
   are equal, and
3. there exists some object.

See <https://stacks.math.columbia.edu/tag/002V>. (They also define a diagram being filtered.)
-/
class IsFiltered extends IsFilteredOrEmpty C : Prop where
  /-- a filtered category must be non empty -/
  [nonempty : Nonempty C]
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem not_mem_Iio_self {b : α} : b ∉ Iio b
-- Mathlib/Probability/Kernel/Composition.lean
theorem lintegral_swapLeft (κ : Kernel (α × β) γ) (a : β × α) (g : γ → ℝ≥0∞) :
    ∫⁻ c, g c ∂swapLeft κ a = ∫⁻ c, g c ∂κ a.swap
-- Mathlib/Probability/StrongLaw.lean
/-- If a function is integrable, then the integral of its truncated versions converges to the
integral of the whole function. -/
theorem tendsto_integral_truncation {f : α → ℝ} (hf : Integrable f μ) :
    Tendsto (fun A => ∫ x, truncation f A x ∂μ) atTop (𝓝 (∫ x, f x ∂μ))
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_atTop_iff_eventually_exists {α : Type*} [SemilatticeSup α] [Nonempty α]
    {f : α → E} {g : α → F} : f =O[atTop] g ↔ ∀ᶠ n₀ in atTop, ∃ c, ∀ n ≥ n₀, ‖f n‖ ≤ c * ‖g n‖
-- Mathlib/Analysis/ConstantSpeed.lean
theorem HasUnitSpeedOn.union {t : Set ℝ} {x : ℝ} (hfs : HasUnitSpeedOn f s)
    (hft : HasUnitSpeedOn f t) (hs : IsGreatest s x) (ht : IsLeast t x) :
    HasUnitSpeedOn f (s ∪ t)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem mem_inv_pointwise_smul_iff {g : G} {S : ValuationSubring K} {x : K} :
    x ∈ g⁻¹ • S ↔ g • x ∈ S
-- Mathlib/CategoryTheory/Localization/SmallShiftedHom.lean
lemma comp_assoc {X Y Z T : C} {a₁ a₂ a₃ a₁₂ a₂₃ a : M}
    [HasSmallLocalizedShiftedHom.{w} W M X Y] [HasSmallLocalizedShiftedHom.{w} W M X Z]
    [HasSmallLocalizedShiftedHom.{w} W M X T] [HasSmallLocalizedShiftedHom.{w} W M Y Z]
    [HasSmallLocalizedShiftedHom.{w} W M Y T] [HasSmallLocalizedShiftedHom.{w} W M Z T]
    [HasSmallLocalizedShiftedHom.{w} W M Z Z] [HasSmallLocalizedShiftedHom.{w} W M T T]
    (α : SmallShiftedHom.{w} W X Y a₁) (β : SmallShiftedHom.{w} W Y Z a₂)
    (γ : SmallShiftedHom.{w} W Z T a₃)
    (h₁₂ : a₂ + a₁ = a₁₂) (h₂₃ : a₃ + a₂ = a₂₃) (h : a₃ + a₂ + a₁ = a) :
    (α.comp β h₁₂).comp γ (show a₃ + a₁₂ = a by rw [← h₁₂, ← add_assoc, h]) =
      α.comp (β.comp γ h₂₃) (by rw [← h₂₃, h])
-- Mathlib/Algebra/Ring/Basic.lean
/-- In a ring, `IsCancelMulZero` and `NoZeroDivisors` are equivalent. -/
lemma isCancelMulZero_iff_noZeroDivisors [NonUnitalNonAssocRing α] :
    IsCancelMulZero α ↔ NoZeroDivisors α
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiableAt_neg :
    MDifferentiableAt I 𝓘(𝕜, E') (-f) z ↔ MDifferentiableAt I 𝓘(𝕜, E') f z
-- Mathlib/Data/List/Destutter.lean
theorem destutter'_sublist (a) : l.destutter' R a <+ a :: l
-- Mathlib/Data/List/Basic.lean
@[deprecated getElem_scanl_zero (since := "2024-06-12")]
theorem get_zero_scanl {h : 0 < (scanl f b l).length} : (scanl f b l).get ⟨0, h⟩ = b
-- Mathlib/Data/Finsupp/Basic.lean
/-- `Finsupp.mapRange.AddMonoidHom` as an equiv. -/
@[simps apply]
def mapRange.addEquiv (f : M ≃+ N) : (α →₀ M) ≃+ (α →₀ N)
-- Mathlib/Topology/SeparatedMap.lean
lemma isSeparatedMap_iff_nhds {f : X → Y} : IsSeparatedMap f ↔
    ∀ x₁ x₂, f x₁ = f x₂ → x₁ ≠ x₂ → ∃ s₁ ∈ 𝓝 x₁, ∃ s₂ ∈ 𝓝 x₂, Disjoint s₁ s₂
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
/-- The generators of the tensor algebra are disjoint from its scalars. -/
theorem ι_range_disjoint_one :
    Disjoint (LinearMap.range (ι R : M →ₗ[R] TensorAlgebra R M))
      (1 : Submodule R (TensorAlgebra R M))
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem attach_insert [DecidableEq α] {a : α} {s : Finset α} :
    attach (insert a s) =
      insert (⟨a, mem_insert_self a s⟩ : { x // x ∈ insert a s })
        ((attach s).image fun x => ⟨x.1, mem_insert_of_mem x.2⟩)
-- Mathlib/MeasureTheory/Constructions/Pi.lean
/-- Boxes formed by π-systems form a π-system. -/
theorem IsPiSystem.pi {C : ∀ i, Set (Set (α i))} (hC : ∀ i, IsPiSystem (C i)) :
    IsPiSystem (pi univ '' pi univ C)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem le_or_eq_of_le_succ {m n : Nat} (h : m ≤ succ n) : m ≤ n ∨ m = succ n
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- Multiplication on the right by a nonzero element of a normed division ring tends to infinity at
infinity. -/
theorem tendsto_mul_right_cobounded {a : α} (ha : a ≠ 0) :
    Tendsto (· * a) (cobounded α) (cobounded α)
-- Mathlib/Data/List/Sigma.lean
theorem dlookup_dedupKeys (a : α) (l : List (Sigma β)) : dlookup a (dedupKeys l) = dlookup a l
-- Mathlib/Data/Nat/Defs.lean
lemma le_succ_iff : m ≤ n.succ ↔ m ≤ n ∨ m = n.succ
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem neg_modByMonic (p mod : R[X]) : (-p) %ₘ mod = - (p %ₘ mod)
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
/-- The image under a monoid hom of the submonoid generated by a set equals the submonoid generated
    by the image of the set. -/
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
      the `AddSubmonoid` generated by the image of the set."]
theorem map_mclosure (f : F) (s : Set M) : (closure s).map f = closure (f '' s)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem image_mem_nhds {x} (hx : x ∈ e.source) {s : Set X} (hs : s ∈ 𝓝 x) : e '' s ∈ 𝓝 (e x)
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem testAgainstNN_eq_mass_mul (f : Ω →ᵇ ℝ≥0) :
    μ.testAgainstNN f = μ.mass * μ.normalize.toFiniteMeasure.testAgainstNN f
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem of_image_eq (h : e '' (e.source ∩ s) = e.target ∩ t) : e.IsImage s t
-- Mathlib/Algebra/Associated/Basic.lean
theorem prime_pow_succ_dvd_mul {α : Type*} [CancelCommMonoidWithZero α] {p x y : α} (h : Prime p)
    {i : ℕ} (hxy : p ^ (i + 1) ∣ x * y) : p ^ (i + 1) ∣ x ∨ p ∣ y
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem length_cyclicPermutations_of_ne_nil (l : List α) (h : l ≠ []) :
    length (cyclicPermutations l) = length l
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc (attr := simp)]
theorem Fork.π_comp_hom {s t : Cofork f g} (f : s ⟶ t) : s.π ≫ f.hom = t.π
-- Mathlib/Algebra/CharZero/Lemmas.lean
lemma support_natCast (hn : n ≠ 0) : support (n : α → M) = univ
-- Mathlib/Algebra/Polynomial/RingDivision.lean
/-- This lemma is useful for working with the `intDegree` of a rational function. -/
theorem natDegree_sub_eq_of_prod_eq {p₁ p₂ q₁ q₂ : R[X]} (hp₁ : p₁ ≠ 0) (hq₁ : q₁ ≠ 0)
    (hp₂ : p₂ ≠ 0) (hq₂ : q₂ ≠ 0) (h_eq : p₁ * q₂ = p₂ * q₁) :
    (p₁.natDegree : ℤ) - q₁.natDegree = (p₂.natDegree : ℤ) - q₂.natDegree
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem sumLexDualAntidistrib_inr :
    sumLexDualAntidistrib α β (toDual (inr b)) = inl (toDual b)
-- Mathlib/Data/PNat/Basic.lean
theorem mul_div_exact {m k : ℕ+} (h : k ∣ m) : k * divExact m k = m
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem smul_sup (a : α) (S T : AddSubmonoid A) : a • (S ⊔ T) = a • S ⊔ a • T
-- Mathlib/Data/ENat/Basic.lean
@[simp, norm_cast]
theorem coe_sub (m n : ℕ) : ↑(m - n) = (m - n : ℕ∞)
-- Mathlib/Data/Sign.lean
@[simp]
theorem sign_neg (ha : a < 0) : sign a = -1
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem Lp.norm_const [NeZero μ] (hp_zero : p ≠ 0) :
    ‖Lp.const p μ c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem Monic.ne_zero_of_ne (h : (0 : R) ≠ 1) {p : R[X]} (hp : p.Monic) : p ≠ 0
-- Mathlib/Topology/Order/Hom/Basic.lean
theorem toFun_eq_coe {f : α →Co β} : f.toFun = (f : α → β)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- The `p`-adic value of a natural is its `p`-adic value as an integer. -/
@[simp]
theorem of_nat {n : ℕ} : padicValInt p n = padicValNat p n
-- Mathlib/Data/Set/Function.lean
theorem InjOn.bijOn_image (h : InjOn f s) : BijOn f s (f '' s)
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma app_eq_appLE {U : Y.Opens} :
    f.app U = f.appLE U _ le_rfl
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem distortion_filter_le (p : Box ι → Prop) : (π.filter p).distortion ≤ π.distortion
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
protected theorem locallyFinite : LocallyFinite fun i => support (fs i)
-- Mathlib/Data/Nat/Factors.lean
theorem mem_primeFactorsList {n p} (hn : n ≠ 0) : p ∈ primeFactorsList n ↔ Prime p ∧ p ∣ n
-- Mathlib/Algebra/Group/Aut.lean
theorem inv_def (e₁ : MulAut M) : e₁⁻¹ = e₁.symm
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBoundedUnder.comp {l : Filter γ} {q : β → β → Prop} {u : γ → α} {v : α → β}
    (hv : ∀ a₀ a₁, r a₀ a₁ → q (v a₀) (v a₁)) : l.IsBoundedUnder r u → l.IsBoundedUnder q (v ∘ u)
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- A measure is invariant under inversion if `μ⁻¹ = μ`. Equivalently, this means that for all
measurable `A` we have `μ (A⁻¹) = μ A`, where `A⁻¹` is the pointwise inverse of `A`. -/
@[to_additive existing]
class IsInvInvariant [Inv G] (μ : Measure G) : Prop where
  inv_eq_self : μ.inv = μ
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableWithinAt_neg_iff :
    DifferentiableWithinAt 𝕜 (fun y => -f y) s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma π_homologyIsoSc'_inv :
    (K.sc' i j k).homologyπ ≫ (K.homologyIsoSc' i j k hi hk).inv =
      (K.cyclesIsoSc' i j k hi hk).inv ≫ K.homologyπ j
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lift_type_le {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
    lift.{max v w} (type r) ≤ lift.{max u w} (type s) ↔ Nonempty (r ≼i s)
-- Mathlib/Data/Complex/Basic.lean
theorem conj_eq_iff_real {z : ℂ} : conj z = z ↔ ∃ r : ℝ, z = r
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Mod.lean
theorem mod_mul {a b x : Nat} : x % (a * b) = x % a + a * (x / a % b)
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
@[simp]
theorem rat_sub_iff : LiouvilleWith p (r - x) ↔ LiouvilleWith p x
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_neg_uIcc : Neg.neg '' [[a, b]] = [[-a, -b]]
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
lemma homogeneousLocalizationToStalk_stalkToFiberRingHom (x z) :
    homogeneousLocalizationToStalk 𝒜 x (stalkToFiberRingHom 𝒜 x z) = z
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.congr_right (h : f =o[l] g₁) (hg : ∀ x, g₁ x = g₂ x) : f =o[l] g₂
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem coeComplex_zero : ((0 : ℂ) : ℍ) = 0
-- Mathlib/Data/Bool/Basic.lean
theorem bool_eq_false {b : Bool} : ¬b → b = false
-- Mathlib/Tactic/CategoryTheory/Coherence.lean
lemma insert_id_lhs {C : Type*} [Category C] {X Y : C} (f g : X ⟶ Y) (w : f ≫ 𝟙 _ = g) :
    f = g
-- Mathlib/Order/Disjointed.lean
@[simp]
theorem disjointedRec_zero {f : ℕ → α} {p : α → Sort*} (hdiff : ∀ ⦃t i⦄, p t → p (t \ f i))
    (h₀ : p (f 0)) : disjointedRec hdiff h₀ = h₀
-- Mathlib/Data/Fintype/Card.lean
theorem Fintype.card_fin_lt_of_le {m n : ℕ} (h : m ≤ n) :
    Fintype.card {i : Fin n // i < m} = m
-- Mathlib/Topology/Sets/Opens.lean
@[simp]
theorem iSup_mk {ι} (s : ι → Set α) (h : ∀ i, IsOpen (s i)) :
    (⨆ i, ⟨s i, h i⟩ : Opens α) = ⟨⋃ i, s i, isOpen_iUnion h⟩
-- Mathlib/Analysis/ODE/PicardLindelof.lean
/-- A time-independent, continuously differentiable ODE satisfies the hypotheses of the
  Picard-Lindelöf theorem. -/
theorem exists_isPicardLindelof_const_of_contDiffAt (hv : ContDiffAt ℝ 1 v x₀) :
    ∃ ε > (0 : ℝ), ∃ L R C, IsPicardLindelof (fun _ => v) (t₀ - ε) t₀ (t₀ + ε) x₀ L R C
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem coe_comp (g : EsakiaHom β γ) (f : EsakiaHom α β) : (g.comp f : α → γ) = g ∘ f
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma rnDerivAux_nonneg (hκη : κ ≤ η) {a : α} {x : γ} : 0 ≤ rnDerivAux κ η a x
-- Mathlib/MeasureTheory/Integral/CircleTransform.lean
theorem circleTransformDeriv_periodic (f : ℂ → E) :
    Periodic (circleTransformDeriv R z w f) (2 * π)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem and_assoc : (a ∧ b) ∧ c ↔ a ∧ (b ∧ c)
-- Mathlib/Topology/Sheaves/Stalks.lean
theorem germ_res_apply (F : X.Presheaf C) {U V : Opens X} (i : U ⟶ V) (x : U) [ConcreteCategory C]
    (s) : germ F x (F.map i.op s) = germ F (i x) s
-- Mathlib/Data/Set/BoolIndicator.lean
theorem preimage_boolIndicator (t : Set Bool) :
    s.boolIndicator ⁻¹' t = univ ∨
      s.boolIndicator ⁻¹' t = s ∨ s.boolIndicator ⁻¹' t = sᶜ ∨ s.boolIndicator ⁻¹' t = ∅
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem wellFounded_characterisations : List.TFAE
    [WellFounded ((· > ·) : α → α → Prop),
      IsSupFiniteCompact α, IsSupClosedCompact α, ∀ k : α, IsCompactElement k]
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_re_symm (x y : E) : re ⟪x, y⟫ = re ⟪y, x⟫
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.mono {f : α → β} {s t : Set α} {x : α} (h : ContinuousWithinAt f t x)
    (hs : s ⊆ t) : ContinuousWithinAt f s x
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiffAt_fst {p : M × N} : ContMDiffAt (I.prod J) I n Prod.fst p
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_eq_left : a ∆ b = a ↔ b = ⊥
-- Mathlib/Order/Atoms.lean
theorem isAtom_iff_isCoatom : IsAtom a ↔ IsCoatom b
-- Mathlib/Probability/Cdf.lean
/-- The cdf tends to 0 at -∞. -/
lemma tendsto_cdf_atBot : Tendsto (cdf μ) atBot (𝓝 0)
-- Mathlib/GroupTheory/Subgroup/Saturated.lean
theorem ker_saturated {A₁ A₂ : Type*} [AddCommGroup A₁] [AddCommGroup A₂] [NoZeroSMulDivisors ℕ A₂]
    (f : A₁ →+ A₂) : f.ker.Saturated
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurableSet_quotient {s : Setoid α} {t : Set (Quotient s)} :
    MeasurableSet t ↔ MeasurableSet (Quotient.mk'' ⁻¹' t)
-- Mathlib/ModelTheory/Fraisse.lean
/-- Sufficient conditions for a class to be the age of a countably-generated structure. -/
theorem exists_cg_is_age_of (hn : K.Nonempty)
    (h : ∀ M N : Bundled.{w} L.Structure, Nonempty (M ≃[L] N) → (M ∈ K ↔ N ∈ K))
    (hc : (Quotient.mk' '' K).Countable)
    (fg : ∀ M : Bundled.{w} L.Structure, M ∈ K → Structure.FG L M) (hp : Hereditary K)
    (jep : JointEmbedding K) : ∃ M : Bundled.{w} L.Structure, Structure.CG L M ∧ L.age M = K
-- Mathlib/Combinatorics/Young/SemistandardTableau.lean
@[ext]
theorem ext {μ : YoungDiagram} {T T' : SemistandardYoungTableau μ} (h : ∀ i j, T i j = T' i j) :
    T = T'
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem Tape.write_self {Γ} [Inhabited Γ] : ∀ T : Tape Γ, T.write T.1 = T
-- Mathlib/RingTheory/TensorProduct/MvPolynomial.lean
lemma coeff_rTensorAlgHom_monomial_tmul
    (e : σ →₀ ℕ) (s : S) (n : N) (d : σ →₀ ℕ) :
    coeff d (rTensorAlgHom (monomial e s ⊗ₜ[R] n)) =
      if e = d then s ⊗ₜ[R] n else 0
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem powerlt_max {a b c : Cardinal} : a ^< max b c = max (a ^< b) (a ^< c)
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_const {s : Finset β} (h : s.Nonempty) (c : α) : (s.sup fun _ => c) = c
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
@[simp]
theorem imageMonoOver_arrow (f : X ⟶ Y) [HasImage f] : (imageMonoOver f).arrow = image.ι f
-- Mathlib/Data/Fin/Tuple/Reflection.lean
@[simp]
theorem seq_eq : ∀ {m} (f : Fin m → α → β) (v : Fin m → α), seq f v = fun i => f i (v i)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem lcm_dvd_lcm_mul_left_right [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm m (k * n)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Tendsto.atTop_of_const_mul {c : α} (hc : 0 < c) (hf : Tendsto (fun x => c * f x) l atTop) :
    Tendsto f l atTop
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem lastFun_subtypeVal {α} (p : α ⟹ «repeat» (n + 1) Prop) :
    lastFun (subtypeVal p) = Subtype.val
-- Mathlib/SetTheory/Game/Basic.lean
/-- A small set of games is bounded above. -/
lemma bddAbove_of_small (s : Set Game.{u}) [Small.{u} s] : BddAbove s
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem constVAdd_nsmul (n : ℕ) (v : V₁) : constVAdd k P₁ (n • v) = constVAdd k P₁ v ^ n
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_eq_comap {p : Submodule R M} :
    (p.map (e : M →ₛₗ[σ₁₂] M₂) : Submodule R₂ M₂) = p.comap (e.symm : M₂ →ₛₗ[σ₂₁] M)
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem eventually_and {p q : α → Prop} {f : Filter α} :
    (∀ᶠ x in f, p x ∧ q x) ↔ (∀ᶠ x in f, p x) ∧ ∀ᶠ x in f, q x
-- Mathlib/MeasureTheory/Integral/Marginal.lean
theorem lmarginal_le_of_subset {f g : (∀ i, π i) → ℝ≥0∞} (hst : s ⊆ t)
    (hf : Measurable f) (hg : Measurable g) (hfg : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ) :
    ∫⋯∫⁻_t, f ∂μ ≤ ∫⋯∫⁻_t, g ∂μ
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
protected theorem IsVonNBounded.vadd (hs : IsVonNBounded 𝕜 s) (x : E) :
    IsVonNBounded 𝕜 (x +ᵥ s)
-- Mathlib/Computability/TMToPartrec.lean
theorem tr_read (q) : tr (Λ'.read q) = goto q
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[reassoc]
theorem curry_natural_right (f : A ⊗ X ⟶ Y) (g : Y ⟶ Y') :
    curry (f ≫ g) = curry f ≫ (ihom _).map g
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_inf_iff : a ∈ s ⊓ t ↔ a ∈ s ∧ a ∈ t
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem _root_.MeasureTheory.Integrable.comp_snd_map_prod_mk
    {Ω} {mΩ : MeasurableSpace Ω} (X : Ω → β) {μ : Measure Ω} {f : Ω → F} (hf_int : Integrable f μ) :
    Integrable (fun x : β × Ω => f x.2) (μ.map fun ω => (X ω, ω))
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem id_apply (a : α) : SupHom.id α a = a
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_insert {α : Type u} {s : Set α} {a : α} (h : a ∉ s) :
    #(insert a s : Set α) = #s + 1
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sdiff_self : a \ a = ⊥
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
/-- Given a linear map `f : M →ₗ[R] A` into an `R`-algebra `A`, which satisfies the condition:
`cond : ∀ m : M, f m * f m = Q(m)`, this is the canonical lift of `f` to a morphism of `R`-algebras
from `CliffordAlgebra Q` to `A`.
-/
@[simps symm_apply]
def lift :
    { f : M →ₗ[R] A // ∀ m, f m * f m = algebraMap _ _ (Q m) } ≃ (CliffordAlgebra Q →ₐ[R] A)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
@[simp]
theorem integral_dirac' [MeasurableSpace α] (f : α → E) (a : α) (hfm : StronglyMeasurable f) :
    ∫ x, f x ∂Measure.dirac a = f a
-- Mathlib/Data/DFinsupp/Basic.lean
theorem not_mem_support_iff {f : Π₀ i, β i} {i : ι} : i ∉ f.support ↔ f i = 0
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- The universal morphism from a colimit cocone to any other cocone. -/
@[simps]
def descCoconeMorphism {t : Cocone F} (h : IsColimit t) (s : Cocone F) : t ⟶ s
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem prod_single [CommSemiring k] [CommMonoid G] {s : Finset ι} {a : ι → G} {b : ι → k} :
    (∏ i ∈ s, single (a i) (b i)) = single (∏ i ∈ s, a i) (∏ i ∈ s, b i)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c
-- Mathlib/Data/Num/Lemmas.lean
theorem divMod_to_nat_aux {n d : PosNum} {q r : Num} (h₁ : (r : ℕ) + d * ((q : ℕ) + q) = n)
    (h₂ : (r : ℕ) < 2 * d) :
    ((divModAux d q r).2 + d * (divModAux d q r).1 : ℕ) = ↑n ∧ ((divModAux d q r).2 : ℕ) < d
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Eq.to_iff : a = b → (a ↔ b)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_comp_comm [CompleteSpace E] (L : E →L[𝕜] F) {φ : X → E} (φ_int : Integrable φ μ) :
    ∫ x, L (φ x) ∂μ = L (∫ x, φ x ∂μ)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
lemma default_singleton (i : α) : ((default : ({i} : Finset α)) : α) = i
-- Mathlib/Order/RelSeries.lean
/--
For two types `α, β` and relation on them `r, s`, if `f : α → β` preserves relation `r`, then an
`r`-series can be pushed out to an `s`-series by
`a₀ -r→ a₁ -r→ ... -r→ aₙ ↦ f a₀ -s→ f a₁ -s→ ... -s→ f aₙ`
-/
@[simps length]
def map (p : RelSeries r) (f : r →r s) : RelSeries s
-- Mathlib/GroupTheory/CommutingProbability.lean
lemma commProb_cons (n : ℕ) (l : List ℕ) :
    commProb (Product (n :: l)) = commProb (DihedralGroup n) * commProb (Product l)
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
protected
theorem neZero' [IsCyclotomicExtension {n} A B] [IsDomain B] : NeZero ((n : ℕ) : A)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem left_mem_Ioo : a ∈ Ioo a b ↔ False
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem final_iff_isIso_colimit_pre : Final F ↔ ∀ G : D ⥤ Type v, IsIso (colimit.pre G F)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem degree_pos_of_ne_zero_of_nonunit (hp0 : p ≠ 0) (hp : ¬IsUnit p) : 0 < degree p
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem star_imJ : (star a).imJ = -a.imJ
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.disjoint_iff_right (h : l.HasBasis p s) :
    Disjoint l' l ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l'
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem card_support_mul_le : (p * q).support.card ≤ p.support.card * q.support.card
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_xor_distrib_right : ∀ (x y z : Bool), (xor x y && z) = xor (x && z) (y && z)
-- Mathlib/Data/DFinsupp/Basic.lean
/-- `DFinsupp.single` as an `AddMonoidHom`. -/
@[simps]
def singleAddHom (i : ι) : β i →+ Π₀ i, β i
-- Mathlib/Geometry/Manifold/Sheaf/Smooth.lean
@[simp, reassoc, elementwise] lemma smoothSheaf.ι_evalHom (x : TopCat.of M) (U) :
    colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M N).val) U ≫
    smoothSheaf.evalHom IM I N x =
    smoothSheaf.evalAt _ _ _ _ _
-- Mathlib/Order/Bounds/Basic.lean
theorem mem_lowerBounds_image : a ∈ upperBounds s → f a ∈ lowerBounds (f '' s)
-- Mathlib/Order/Fin/Basic.lean
/-- Two order embeddings of `Fin n` are equal provided that their ranges are equal. -/
lemma orderEmbedding_eq {f g : Fin n ↪o α} (h : range f = range g) : f = g
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint_comm : Codisjoint a b ↔ Codisjoint b a
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem _root_.Measurable.lintegral_kernel {f : β → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun a => ∫⁻ b, f b ∂κ a
-- Mathlib/Data/Finset/Basic.lean
theorem singleton_injective : Injective (singleton : α → Finset α)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableOn.neg (h : DifferentiableOn 𝕜 f s) : DifferentiableOn 𝕜 (fun y => -f y) s
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem tendsto_of_uniformContinuous_subtype [UniformSpace α] [UniformSpace β] {f : α → β}
    {s : Set α} {a : α} (hf : UniformContinuous fun x : s => f x.val) (ha : s ∈ 𝓝 a) :
    Tendsto f (𝓝 a) (𝓝 (f a))
-- Mathlib/Algebra/AddTorsor.lean
@[simp]
theorem constVAdd_zero : constVAdd P (0 : G) = 1
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
theorem conjugatesOfSet_subset_normalClosure : conjugatesOfSet s ⊆ normalClosure s
-- Mathlib/Data/Fin/Basic.lean
theorem pred_lt_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0) : pred i hi < j ↔ i < succ j