ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Order/UpperLower.lean
protected theorem Set.OrdConnected.nullMeasurableSet (hs : s.OrdConnected) : NullMeasurableSet s
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma primitiveCharacter_one (hn : n ≠ 0) :
    (1 : DirichletCharacter R n).primitiveCharacter = 1
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem circleMap_not_mem_ball (c : ℂ) (R : ℝ) (θ : ℝ) : circleMap c R θ ∉ ball c R
-- Mathlib/Data/Set/Finite.lean
theorem eq_finite_iUnion_of_finite_subset_iUnion {ι} {s : ι → Set α} {t : Set α} (tfin : t.Finite)
    (h : t ⊆ ⋃ i, s i) :
    ∃ I : Set ι,
      I.Finite ∧
        ∃ σ : { i | i ∈ I } → Set α, (∀ i, (σ i).Finite) ∧ (∀ i, σ i ⊆ s i) ∧ t = ⋃ i, σ i
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- Technical lemma ensuring that the preimage under an extended chart of a neighborhood of the
base point is a neighborhood of the preimage, within a set. -/
theorem extChartAt_preimage_mem_nhdsWithin {x : M} (ht : t ∈ 𝓝[s] x) :
    (extChartAt I x).symm ⁻¹' t ∈ 𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] (extChartAt I x) x
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem minpolyGen_eq (pb : PowerBasis A S) : pb.minpolyGen = minpoly A pb.gen
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- To check whether two maps are coequalized by both maps of a cotrident, it suffices to check it
for the second map -/
theorem Cotrident.coequalizer_ext [Nonempty J] (s : Cotrident f) {W : C} {k l : s.pt ⟶ W}
    (h : s.π ≫ k = s.π ≫ l) : ∀ j : WalkingParallelFamily J, s.ι.app j ≫ k = s.ι.app j ≫ l
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
lemma trim_withDensity {m m0 : MeasurableSpace α} {μ : Measure α}
    (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    (μ.withDensity f).trim hm = (μ.trim hm).withDensity f
-- Mathlib/Order/UpperLower/Basic.lean
theorem OrderEmbedding.image_Ioi (e : α ↪o β) (he : IsUpperSet (range e)) (a : α) :
    e '' Ioi a = Ioi (e a)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrict_eq_zero : μ.restrict s = 0 ↔ μ s = 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem prod_coe {s : Multiset { a : Associates α // Irreducible a }} :
    FactorSet.prod (s : FactorSet α) = (s.map (↑)).prod
-- Mathlib/Analysis/Convex/Radon.lean
/-- **Helly's theorem** for finite sets of convex sets in its classical form.

If `F` is a finite set of convex sets in a vector space of finite dimension `d`, with `n ≥ d + 1`,
and any `d + 1` sets from `F` intersect nontrivially,
then all sets from `F` intersect nontrivially. -/
theorem helly_theorem_set {F : Finset (Set E)}
    (h_card : finrank 𝕜 E + 1 ≤ F.card)
    (h_convex : ∀ X ∈ F, Convex 𝕜 X)
    (h_inter : ∀ G : Finset (Set E), G ⊆ F → G.card = finrank 𝕜 E + 1 → (⋂₀ G : Set E).Nonempty) :
    (⋂₀ (F : Set (Set E))).Nonempty
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp]
theorem nullHomotopicMap_f_of_not_rel_left {k₁ k₀ : ι} (r₁₀ : c.Rel k₁ k₀)
    (hk₀ : ∀ l : ι, ¬c.Rel k₀ l) (hom : ∀ i j, C.X i ⟶ D.X j) :
    (nullHomotopicMap hom).f k₀ = hom k₀ k₁ ≫ D.d k₁ k₀
-- Mathlib/GroupTheory/Perm/Basic.lean
/-- A stronger version of `mul_left_injective` -/
@[simp]
theorem mul_swap_involutive (i j : α) : Function.Involutive (· * Equiv.swap i j)
-- Mathlib/GroupTheory/CoprodI.lean
theorem of_smul_def (i) (w : Word M) (m : M i) :
    of m • w = rcons { equivPair i w with head := m * (equivPair i w).head }
-- Mathlib/CategoryTheory/Monad/EquivMon.lean
/-- To every `Monad C` we associated a monoid object in `C ⥤ C`. -/
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C)
-- Mathlib/GroupTheory/Perm/Support.lean
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support
-- .lake/packages/lean4/src/lean/Init/Data/Option/Instances.lean
@[simp] theorem mem_def {a : α} {b : Option α} : a ∈ b ↔ b = some a
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean
@[reassoc (attr := simp)]
theorem whiskerLeft_naturality_comp (f : a' ⟶ G.obj a) (g : a ⟶ b) (h : b ⟶ c) :
    f ◁ θ.naturality (g ≫ h) ≫ f ◁ θ.app a ◁ H.mapComp g h =
      f ◁ G.mapComp g h ▷ θ.app c ≫
        f ◁ (α_ _ _ _).hom ≫
          f ◁ G.map g ◁ θ.naturality h ≫
            f ◁ (α_ _ _ _).inv ≫ f ◁ θ.naturality g ▷ H.map h ≫ f ◁ (α_ _ _ _).hom
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma add_cons (v : Fin n.succ → α) (y : α) (w : Fin n → α) :
    v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w)
-- Mathlib/Data/List/InsertNth.lean
theorem insertNth_injective (n : ℕ) (x : α) : Function.Injective (insertNth n x)
-- Mathlib/Combinatorics/Enumerative/Composition.lean
/-- A composition of `n` is a list of positive integers summing to `n`. -/
@[ext]
structure Composition (n : ℕ) where
  /-- List of positive integers summing to `n`-/
  blocks : List ℕ
  /-- Proof of positivity for `blocks`-/
  blocks_pos : ∀ {i}, i ∈ blocks → 0 < i
  /-- Proof that `blocks` sums to `n`-/
  blocks_sum : blocks.sum = n
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem smeval_commute (hc : Commute x y) : Commute (p.smeval x) (q.smeval y)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fmod_eq_emod (a : Int) {b : Int} (hb : 0 ≤ b) : fmod a b = a % b
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
lemma quot_mk_eq_iff [Mono f] (a b : X₁ ⊕ X₂) :
    (Quot.mk _ a : Pushout f g) = Quot.mk _ b ↔ Rel' f g a b
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeriesOfIdeal_mono {I J : LieIdeal R L} (h : I ≤ J) (k : ℕ) : D k I ≤ D k J
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem forall_fin_one {p : Fin 1 → Prop} : (∀ i, p i) ↔ p 0
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem id_hom' (M : Mon_ C) : (𝟙 M : Hom M M).hom = 𝟙 M.X
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoDiv_sub_eq_toIcoDiv_add (a b c : α) :
    toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b
-- Mathlib/Order/Partition/Finpartition.lean
theorem parts_nonempty (P : Finpartition a) (ha : a ≠ ⊥) : P.parts.Nonempty
-- Mathlib/LinearAlgebra/LinearPMap.lean
protected theorem sup_le {f g h : E →ₗ.[R] F}
    (H : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) (fh : f ≤ h) (gh : g ≤ h) :
    f.sup g H ≤ h
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem L1.setToFun_eq_setToL1 (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E) :
    setToFun μ T hT f = L1.setToL1 hT f
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c
-- Mathlib/Topology/Order/LowerUpperTopology.lean
@[simp] lemma ofLower_toLower (a : α) : ofLower (toLower a) = a
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_lt_one_of_one_lt_of_neg {x : ℝ≥0∞} {z : ℝ} (hx : 1 < x) (hz : z < 0) : x ^ z < 1
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
@[simp]
theorem Sphere.coe_mk (c : P) (r : ℝ) : ↑(⟨c, r⟩ : Sphere P) = Metric.sphere c r
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem divInt_mul_left {a : Int} (a0 : a ≠ 0) : (a * n) /. (a * d) = n /. d
-- Mathlib/Topology/UniformSpace/Equiv.lean
@[simp]
theorem uniformEquiv_mk_coe_symm (a : Equiv α β) (b c) :
    ((UniformEquiv.mk a b c).symm : β → α) = a.symm
-- Mathlib/Algebra/Ring/Hom/Defs.lean
/-- Ring homomorphisms preserve subtraction. -/
protected theorem map_sub [NonAssocRing α] [NonAssocRing β] (f : α →+* β) (x y : α) :
    f (x - y) = f x - f y
-- Mathlib/Data/Quot.lean
theorem nonempty_quotient_iff (s : Setoid α) : Nonempty (Quotient s) ↔ Nonempty α
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
/-- Adding a bitvector to its own complement yields the all ones bitpattern -/
@[simp] theorem add_not_self (x : BitVec w) : x + ~~~x = allOnes w
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t
-- Mathlib/Data/Multiset/Basic.lean
lemma map_filter' {f : α → β} (hf : Injective f) (s : Multiset α)
    [DecidablePred fun b => ∃ a, p a ∧ f a = b] :
    (s.filter p).map f = (s.map f).filter fun b => ∃ a, p a ∧ f a = b
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.indep (hB : M.Base B) : M.Indep B
-- Mathlib/Order/Interval/Finset/Box.lean
@[simp] lemma mem_box : ∀ {n}, x ∈ box n ↔ max x.1.natAbs x.2.natAbs = n
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem codisjoint_inf_left : Codisjoint (a ⊓ b) c ↔ Codisjoint a c ∧ Codisjoint b c
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
lemma neg_hom (α : Ext X Y n) : (-α).hom = -α.hom
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- If two functions coincide in a neighborhood of `x` within a set `s` and at `x`, then their
iterated differentials within this set at `x` coincide. -/
theorem Filter.EventuallyEq.iteratedFDerivWithin_eq (h : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x)
    (n : ℕ) : iteratedFDerivWithin 𝕜 n f₁ s x = iteratedFDerivWithin 𝕜 n f s x
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma isRightKanExtension_iff_precomp (α : L ⋙ F' ⟶ F) :
    F'.IsRightKanExtension α ↔
      F'.IsRightKanExtension ((Functor.associator _ _ _).hom ≫ whiskerLeft G α)
-- Mathlib/InformationTheory/Hamming.lean
/-- Corresponds to `dist_ne_zero`. -/
theorem hammingDist_ne_zero {x y : ∀ i, β i} : hammingDist x y ≠ 0 ↔ x ≠ y
-- Mathlib/Order/Category/BoolAlg.lean
/-- The powerset functor. `Set` as a contravariant functor. -/
@[simps]
def typeToBoolAlgOp : Type u ⥤ BoolAlgᵒᵖ
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
@[simp]
theorem spectralRadius_zero : spectralRadius 𝕜 (0 : A) = 0
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
nonrec theorem ContinuousWithinAt.rpow_const (hf : ContinuousWithinAt f s x) (h : f x ≠ 0 ∨ 0 ≤ p) :
    ContinuousWithinAt (fun x => f x ^ p) s x
-- Mathlib/Data/Sum/Lattice.lean
@[simp] lemma inl_sup (a₁ a₂ : α) : (inlₗ (a₁ ⊔ a₂) : α ⊕ β) = inlₗ a₁ ⊔ inlₗ a₂
-- Mathlib/Computability/Primrec.lean
theorem tail {n f} (hf : @Primrec' n f) : @Primrec' n.succ fun v => f v.tail
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
/-- (Implementation). Given a hom between the pullbacks of two sheaves, we can whisker it with
`coyoneda` to obtain a hom between the pullbacks of the sheaves of maps from `X`.
-/
@[simps!]
def homOver {ℱ : Dᵒᵖ ⥤ A} {ℱ' : Sheaf K A} (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) (X : A) :
    G.op ⋙ ℱ ⋙ coyoneda.obj (op X) ⟶ G.op ⋙ (sheafOver ℱ' X).val
-- Mathlib/Data/Finset/Fold.lean
/-- A weaker version of `Finset.fold_ite'`,
relying on typeclass idempotency over the whole type,
instead of solely on the seed element.
However, this is easier to use because it does not generate side goals. -/
theorem fold_ite [Std.IdempotentOp op] {g : α → β} (p : α → Prop) [DecidablePred p] :
    Finset.fold op b (fun i => ite (p i) (f i) (g i)) s =
      op (Finset.fold op b f (s.filter p)) (Finset.fold op b g (s.filter fun i => ¬p i))
-- Mathlib/Dynamics/PeriodicPts.lean
@[to_additive (attr := simp)]
theorem pow_add_period_smul (n : ℕ) (m : M) (a : α) :
    m ^ (n + period m a) • a = m ^ n • a
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
theorem val_eq_coe (n : ℝ≥0) : n.val = n
-- Mathlib/Data/Fintype/Basic.lean
theorem eq_univ_of_forall : (∀ x, x ∈ s) → s = univ
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive (attr := simp)]
theorem const_eq_one : const ι a = 1 ↔ a = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
theorem hasProducts_of_limit_fans (lf : ∀ {J : Type w} (f : J → C), Fan f)
    (lf_isLimit : ∀ {J : Type w} (f : J → C), IsLimit (lf f)) : HasProducts.{w} C
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.of_dvd_right (h : IsRelPrime z y) (dvd : x ∣ y) : IsRelPrime z x
-- Mathlib/Algebra/Ring/Commute.lean
lemma neg_one_pow_eq_or : ∀ n : ℕ, (-1 : R) ^ n = 1 ∨ (-1 : R) ^ n = -1
-- Mathlib/Order/SupClosed.lean
lemma infClosure_mono : Monotone (infClosure : Set α → Set α)
-- Mathlib/Data/Matrix/Hadamard.lean
@[simp]
theorem zero_hadamard : (0 : Matrix m n α) ⊙ A = 0
-- Mathlib/Data/Nat/Count.lean
@[simp]
theorem count_zero : count p 0 = 0
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lift_comp_map (i : P →ₗ[R] Q →ₗ[R] Q') (f : M →ₗ[R] P) (g : N →ₗ[R] Q) :
    (lift i).comp (map f g) = lift ((i.comp f).compl₂ g)
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem aux_pid_of_ufd_of_unique_irreducible (R : Type u) [CommRing R] [IsDomain R]
    [UniqueFactorizationMonoid R] (h₁ : ∃ p : R, Irreducible p)
    (h₂ : ∀ ⦃p q : R⦄, Irreducible p → Irreducible q → Associated p q) :
    IsPrincipalIdealRing R
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem subtypeCongrHom_injective (p : α → Prop) [DecidablePred p] :
    Function.Injective (subtypeCongrHom p)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem?_concat_length (since := "2024-06-12")]
theorem get?_concat_length (l : List α) (a : α) : (l ++ [a]).get? l.length = some a
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_zero : ⇑(0 : α →ₙ+* β) = 0
-- Mathlib/SetTheory/Game/PGame.lean
theorem lt_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ < y₁) : x₂ < y₂
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean
/-- `cyclotomic n ℚ` is the minimal polynomial of a primitive `n`-th root of unity `μ`. -/
theorem cyclotomic_eq_minpoly_rat {n : ℕ} {K : Type*} [Field K] {μ : K} (h : IsPrimitiveRoot μ n)
    (hpos : 0 < n) [CharZero K] : cyclotomic n ℚ = minpoly ℚ μ
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem ι_comp_lift (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = 0) :
    (lift R ⟨f, cond⟩).toLinearMap.comp (ι R) = f
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiableOn.congr_mono (h : MDifferentiableOn I I' f s) (h' : ∀ x ∈ t, f₁ x = f x)
    (h₁ : t ⊆ s) : MDifferentiableOn I I' f₁ t
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem coe_foldr (f : α → β → β) (H : LeftCommutative f) (b : β) (l : List α) :
    foldr f H b l = l.foldr f b
-- Mathlib/Order/Basic.lean
theorem gt_or_eq_of_le [PartialOrder α] {a b : α} (h : a ≤ b) : a < b ∨ b = a
-- Mathlib/Data/Multiset/Sort.lean
@[simp]
theorem coe_sort (l : List α) : sort r l = mergeSort r l
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- For any natural `k` and a real `r > 1` we have `n ^ k = o(r ^ n)` as `n → ∞`. -/
theorem isLittleO_pow_const_const_pow_of_one_lt {R : Type*} [NormedRing R] (k : ℕ) {r : ℝ}
    (hr : 1 < r) : (fun n ↦ (n : R) ^ k : ℕ → R) =o[atTop] fun n ↦ r ^ n
-- Mathlib/Data/Part.lean
@[simp]
theorem getOrElse_some (a : α) (d : α) [Decidable (some a).Dom] : getOrElse (some a) d = a
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem val_succEmb : ⇑(succEmb n) = Fin.succ
-- Mathlib/Order/LiminfLimsup.lean
theorem sup_liminf (a : α) : a ⊔ liminf u f = liminf (fun x => a ⊔ u x) f
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- When a function has a limit at infinity, and its derivative is nonpositive, then the derivative
is automatically integrable on `(a, +∞)`. Version assuming differentiability
on `[a, +∞)`. -/
theorem integrableOn_Ioi_deriv_of_nonpos' (hderiv : ∀ x ∈ Ici a, HasDerivAt g (g' x) x)
    (g'neg : ∀ x ∈ Ioi a, g' x ≤ 0) (hg : Tendsto g atTop (𝓝 l)) : IntegrableOn g' (Ioi a)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
lemma add_eq_of_lt {q r : ℚ} (hqr : q + r ≠ 0)
    (hq : q ≠ 0) (hr : r ≠ 0) (hval : padicValRat p q < padicValRat p r) :
    padicValRat p (q + r) = padicValRat p q
-- Mathlib/Analysis/Convex/EGauge.lean
lemma div_le_egauge_closedBall (r : ℝ≥0) (x : E) : ‖x‖₊ / r ≤ egauge 𝕜 (closedBall 0 r) x
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
/-- This lemma expresses the vanishing of
`(P q).f (n+1) ≫ X.δ k : X _[n+1] ⟶ X _[n]` when `k≠0` and `k≥n-q+2` -/
theorem of_P : ∀ q n : ℕ, HigherFacesVanish q ((P q).f (n + 1) : X _[n + 1] ⟶ X _[n + 1])
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
/-- A vector with coprime entries, right-multiplied by a matrix in `SL(2, R)`, has
coprime entries. -/
lemma vecMulSL {v : Fin 2 → R} (hab : IsCoprime (v 0) (v 1)) (A : SL(2, R)) :
    IsCoprime ((v ᵥ* A.1) 0) ((v ᵥ* A.1) 1)
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₁_eq_zero_of_mono₂ (h : Mono T.mor₂) : T.mor₁ = 0
-- Mathlib/Data/Set/Function.lean
theorem _root_.Function.leftInvOn_invFunOn_of_subset_image_image [Nonempty α]
    (h : s ⊆ (invFunOn f s) '' (f '' s)) : LeftInvOn (invFunOn f s) f s
-- Mathlib/Algebra/BigOperators/Pi.lean
/-- An 'unapplied' analogue of `Finset.prod_apply`. -/
@[to_additive "An 'unapplied' analogue of `Finset.sum_apply`."]
theorem Finset.prod_fn {α : Type*} {β : α → Type*} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
    (g : γ → ∀ a, β a) : ∏ c ∈ s, g c = fun a ↦ ∏ c ∈ s, g c a
-- Mathlib/CategoryTheory/Limits/Lattice.lean
/-- The binary product in the category of a `SemilatticeInf` with `OrderTop` is the same as the
infimum.
-/
@[simp]
theorem prod_eq_inf [SemilatticeInf α] [OrderTop α] (x y : α) : Limits.prod x y = x ⊓ y
-- Mathlib/Algebra/Group/FiniteSupport.lean
@[to_additive (attr := simp)]
lemma mulSupport_along_fiber_finite_of_finite (f : α × β → γ) (a : α) (h : (mulSupport f).Finite) :
    (mulSupport fun b ↦ f (a, b)).Finite
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : Finset α)
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem candidatesB_nonempty : (candidatesB X Y).Nonempty
-- Mathlib/Combinatorics/Colex.lean
lemma insert_le_insert (ha : a ∉ s) (hb : b ∉ s) :
    toColex (insert a s) ≤ toColex (insert b s) ↔ a ≤ b
-- Mathlib/CategoryTheory/ComposableArrows.lean
/-- Constructor for isomorphisms in `ComposableArrows C 2`. -/
@[simps]
def isoMk₂ {f g : ComposableArrows C 2}
    (app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
    (w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
    (w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2) : f ≅ g
-- Mathlib/Data/List/Sublists.lean
theorem sublistsLen_sublist_sublists' :
    ∀ (n) (l : List α), sublistsLen n l <+ sublists' l
-- Mathlib/Order/Interval/Set/Disjoint.lean
theorem iUnion_Iic_of_not_bddAbove_range (hf : ¬ BddAbove (range f)) : ⋃ i, Iic (f i) = univ
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_Ixx {Ixx : α → α → Set α} {p : α → α → Prop}
    (Hne : ∀ {a b}, (Ixx a b).Nonempty → p a b)
    (Hi : ∀ {a₁ b₁ a₂ b₂}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)) (f : ι → α)
    (g : ι' → α) : @IsPiSystem α { S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S }
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem toAddSubgroup_injective :
    Function.Injective (toAddSubgroup : NonUnitalSubring R → AddSubgroup R)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem pred_eq_iff_not_succ' {o} : pred o = o ↔ ∀ a, o ≠ succ a
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem lift_apply (F : G →* A) (f : MonoidAlgebra k G) :
    lift k G A F f = f.sum fun a b => b • F a
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem adjoin_le_equalizer {s : Set A} (h : s.EqOn f g) : adjoin R s ≤ StarAlgHom.equalizer f g
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_comp_comm' (L : E →L[𝕜] F) {K} (hL : AntilipschitzWith K L) (φ : X → E) :
    ∫ x, L (φ x) ∂μ = L (∫ x, φ x ∂μ)
-- Mathlib/Data/Quot.lean
@[simp]
protected theorem liftOn'_mk'' (f : α → φ) (h) (x : α) :
    Quotient.liftOn' (@Quotient.mk'' _ s₁ x) f h = f x
-- Mathlib/Topology/Algebra/Group/Basic.lean
/-- A typeclass saying that `p : G × G ↦ p.1 / p.2` is a continuous function. This property
automatically holds for topological groups. Lemmas using this class have primes.
The unprimed version is for `GroupWithZero`. -/
@[to_additive existing]
class ContinuousDiv (G : Type*) [TopologicalSpace G] [Div G] : Prop where
  continuous_div' : Continuous fun p : G × G => p.1 / p.2
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
theorem Gamma0_is_congruence (N : ℕ+) : IsCongruenceSubgroup (Gamma0 N)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_insert_left (h : a ≤ b) : insert a (Ioc a b) = Icc a b
-- Mathlib/Topology/Instances/Complex.lean
/-- Let `K` a subfield of `ℂ` and let `ψ : K →+* ℂ` a ring homomorphism. Assume that `ψ` is uniform
continuous, then `ψ` is either the inclusion map or the composition of the inclusion map with the
complex conjugation. -/
theorem Complex.uniformContinuous_ringHom_eq_id_or_conj (K : Subfield ℂ) {ψ : K →+* ℂ}
    (hc : UniformContinuous ψ) : ψ.toFun = K.subtype ∨ ψ.toFun = conj ∘ K.subtype
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem swap_smul_involutive [MulAction (Perm α) β] (i j : α) :
    Function.Involutive (swap i j • · : β → β)
-- Mathlib/SetTheory/ZFC/Basic.lean
protected theorem Equiv.rfl {x} : Equiv x x
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive]
theorem Commute.function_commute_mul_left (h : Commute a b) :
    Function.Commute (a * ·) (b * ·)
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem iterate_derivative_at_1_eq_zero_of_lt (n : ℕ) {ν k : ℕ} :
    k < n - ν → (Polynomial.derivative^[k] (bernsteinPolynomial R n ν)).eval 1 = 0
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma lambda_not_dvd_X : ¬ λ ∣ S.X
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
@[simp]
theorem lintegral_zero_measure {m : MeasurableSpace α} (f : α → ℝ≥0∞) :
    ∫⁻ a, f a ∂(0 : Measure α) = 0
-- Mathlib/CategoryTheory/Quotient.lean
protected theorem sound {a b : C} {f₁ f₂ : a ⟶ b} (h : r f₁ f₂) :
    (functor r).map f₁ = (functor r).map f₂
-- Mathlib/Order/Max.lean
@[simp]
theorem isBot_toDual_iff : IsBot (toDual a) ↔ IsTop a
-- Mathlib/CategoryTheory/Preadditive/Generator.lean
theorem Preadditive.isSeparating_iff (𝒢 : Set C) :
    IsSeparating 𝒢 ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = 0) → f = 0
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma unmop_tensorHom {X₁ Y₁ X₂ Y₂ : Cᴹᵒᵖ} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g).unmop = g.unmop ⊗ f.unmop
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
theorem mkContinuous₂_norm_le (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G) {C : ℝ} (h0 : 0 ≤ C)
    (hC : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) : ‖f.mkContinuous₂ C hC‖ ≤ C
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
@[simp]
theorem unitization_apply (x : Unitization R s) : unitization s x = algebraMap R A x.fst + x.snd
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_map_iff {p : β → Prop} {μ : Measure α} : (∀ᵐ x ∂μ.map f, p x) ↔ ∀ᵐ x ∂μ, p (f x)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem source_inter_preimage_inv_preimage (s : Set X) :
    e.source ∩ e ⁻¹' (e.symm ⁻¹' s) = e.source ∩ s
-- Mathlib/NumberTheory/Divisors.lean
theorem mem_divisors_self (n : ℕ) (h : n ≠ 0) : n ∈ n.divisors
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[ext]
theorem ext ⦃f g : ArithmeticFunction R⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/Order/FixedPoints.lean
theorem lfp_le {a : α} (h : f a ≤ a) : lfp f ≤ a
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem map_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
    (map I f x).val n = f.reduceModIdeal (I ^ n) (x.val n)
-- Mathlib/Data/Finset/Pointwise.lean
theorem vsub_mem_vsub : b ∈ s → c ∈ t → b -ᵥ c ∈ s -ᵥ t
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem volume_subtype_coe_eq_zero_of_volume_eq_zero (hu : NullMeasurableSet u) {t : Set u}
    (ht : volume t = 0) : volume (((↑) : u → δ) '' t) = 0
-- Mathlib/Topology/PartitionOfUnity.lean
/-- If `X` is a paracompact normal topological space and `U` is an open covering of a closed set
`s`, then there exists a `BumpCovering ι X s` that is subordinate to `U`. This version assumes that
`p : (X → ℝ) → Prop` is a predicate that satisfies Urysohn's lemma, and provides a
`BumpCovering` such that each function of the covering satisfies `p`. -/
theorem exists_isSubordinate_of_prop [NormalSpace X] [ParacompactSpace X] (p : (X → ℝ) → Prop)
    (h01 : ∀ s t, IsClosed s → IsClosed t → Disjoint s t →
      ∃ f : C(X, ℝ), p f ∧ EqOn f 0 s ∧ EqOn f 1 t ∧ ∀ x, f x ∈ Icc (0 : ℝ) 1)
    (hs : IsClosed s) (U : ι → Set X) (ho : ∀ i, IsOpen (U i)) (hU : s ⊆ ⋃ i, U i) :
    ∃ f : BumpCovering ι X s, (∀ i, p (f i)) ∧ f.IsSubordinate U
-- Mathlib/Data/Set/Finite.lean
theorem finite_range (f : ι → α) [Finite ι] : (range f).Finite