ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Partition/Equipartition.lean
theorem IsEquipartition.card_parts_eq_average (hP : P.IsEquipartition) (ht : t ∈ P.parts) :
    t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
-- Mathlib/Analysis/NormedSpace/IndicatorFunction.lean
theorem norm_indicator_le_of_subset (h : s ⊆ t) (f : α → E) (a : α) :
    ‖indicator s f a‖ ≤ ‖indicator t f a‖
-- Mathlib/Data/Complex/Exponential.lean
theorem sin_sub : sin (x - y) = sin x * cos y - cos x * sin y
-- Mathlib/LinearAlgebra/TensorProduct/Pi.lean
@[simp]
lemma piScalarRight_apply (x : N ⊗[R] (ι → R)) :
    piScalarRight R S N ι x = piScalarRightHom R S N ι x
-- Mathlib/GroupTheory/Commutator.lean
theorem commutator_le_map_commutator {f : G →* G'} {K₁ K₂ : Subgroup G'} (h₁ : K₁ ≤ H₁.map f)
    (h₂ : K₂ ≤ H₂.map f) : ⁅K₁, K₂⁆ ≤ ⁅H₁, H₂⁆.map f
-- Mathlib/Data/List/Basic.lean
theorem monotone_filter_left (p : α → Bool) ⦃l l' : List α⦄ (h : l ⊆ l') :
    filter p l ⊆ filter p l'
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem union_eq_right {s t : Set α} : s ∪ t = t ↔ s ⊆ t
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem seq_pure (f : Filter (α → β)) (a : α) : seq f (pure a) = map (fun g : α → β => g a) f
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem left_distrib (x y z : X q) : x * (y + z) = x * y + x * z
-- Mathlib/Data/PNat/Defs.lean
@[simp, norm_cast]
theorem coe_le_coe (n k : ℕ+) : (n : ℕ) ≤ k ↔ n ≤ k
-- Mathlib/Data/Nat/Defs.lean
lemma div_eq_self : m / n = m ↔ m = 0 ∨ n = 1
-- Mathlib/Topology/List.lean
theorem continuousAt_eraseIdx {n : ℕ} {i : Fin (n + 1)} :
    ∀ {l : Vector α (n + 1)}, ContinuousAt (Vector.eraseIdx i) l
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_dvd_gcd_mul_left_right [GCDMonoid α] (m n k : α) : gcd m n ∣ gcd m (k * n)
-- Mathlib/RingTheory/LaurentSeries.lean
@[simp]
theorem coe_X : ((X : RatFunc F) : LaurentSeries F) = single 1 1
-- Mathlib/Order/Monotone/Monovary.lean
theorem monovary_const_right (f : ι → α) (b : β) : Monovary f (const ι b)
-- Mathlib/RingTheory/Ideal/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff {a : M} {S : Ideal R} {x : R} : a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Algebra/Order/Ring/WithTop.lean
lemma bot_mul' : ∀ (b : WithBot α), ⊥ * b = if b = 0 then 0 else ⊥
-- Mathlib/Algebra/Homology/Single.lean
@[ext]
lemma from_single_hom_ext {K : HomologicalComplex V c} {j : ι} {A : V}
    {f g : (single V c j).obj A ⟶ K} (hfg : f.f j = g.f j) : f = g
-- Mathlib/Deprecated/Ring.lean
@[simp]
theorem coe_of {f : α → β} (hf : IsSemiringHom f) : ⇑(of hf) = f
-- Mathlib/Data/List/MinMax.lean
@[simp]
theorem foldl_argAux_eq_none : l.foldl (argAux r) o = none ↔ l = [] ∧ o = none
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem sum_bool (f : Bool → Measure α) : sum f = f true + f false
-- Mathlib/Order/Filter/Basic.lean
theorem mem_kernMap {s : Set β} : s ∈ kernMap m f ↔ ∃ t ∈ f, kernImage m t = s
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[simp]
lemma of_comul {X : Type v} [AddCommGroup X] [Module R X] [Coalgebra R X] :
    Coalgebra.comul (A := of R X) = Coalgebra.comul (R := R) (A := X)
-- Mathlib/Order/RelClasses.lean
lemma subset_of_subset_of_eq (hab : a ⊆ b) (hbc : b = c) : a ⊆ c
-- Mathlib/Computability/TuringMachine.lean
theorem stepAux_read (f : Γ → Stmt'₁) (v : σ) (L R : ListBlank Γ) :
    stepAux (read dec f) v (trTape' enc0 L R) = stepAux (f R.head) v (trTape' enc0 L R)
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_neg (x : ℝ≥0∞) (y : ℝ) : x ^ (-y) = (x ^ y)⁻¹
-- Mathlib/CategoryTheory/CommSq.lean
/-- The assertion that a square has a `LiftStruct`. -/
class HasLift : Prop where
  /-- Square has a `LiftStruct`. -/
  exists_lift : Nonempty sq.LiftStruct
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
protected theorem map_add (f : α → β) (x y : FreeAbelianGroup α) :
    f <$> (x + y) = f <$> x + f <$> y
-- Mathlib/Topology/ContinuousFunction/CocompactMap.lean
/-- A *cocompact continuous map* is a continuous function between topological spaces which
tends to the cocompact filter along the cocompact filter. Functions for which preimages of compact
sets are compact always satisfy this property, and the converse holds for cocompact continuous maps
when the codomain is Hausdorff (see `CocompactMap.tendsto_of_forall_preimage` and
`CocompactMap.isCompact_preimage`).

Cocompact maps thus generalise proper maps, with which they correspond when the codomain is
Hausdorff. -/
structure CocompactMap (α : Type u) (β : Type v) [TopologicalSpace α] [TopologicalSpace β] extends
  ContinuousMap α β : Type max u v where
  /-- The cocompact filter on `α` tends to the cocompact filter on `β` under the function -/
  cocompact_tendsto' : Tendsto toFun (cocompact α) (cocompact β)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma natDegree_Ψ₃ (h : (3 : R) ≠ 0) : W.Ψ₃.natDegree = 4
-- Mathlib/Topology/Compactification/OnePoint.lean
@[norm_cast]
theorem coe_eq_coe {x y : X} : (x : OnePoint X) = y ↔ x = y
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
@[simp]
theorem memberSubfamily_nonMemberSubfamily : (𝒜.nonMemberSubfamily a).memberSubfamily a = ∅
-- Mathlib/Topology/Instances/Real.lean
theorem Real.isTopologicalBasis_Ioo_rat :
    @IsTopologicalBasis ℝ _ (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo (a : ℝ) b})
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_biUnion_finset {s : Finset ι} {f : ι → Set α} (hd : PairwiseDisjoint (↑s) f)
    (hm : ∀ b ∈ s, MeasurableSet (f b)) : μ (⋃ b ∈ s, f b) = ∑ p ∈ s, μ (f p)
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem mapAccumr₂_mapAccumr₂_right_left (f₁ : α → γ → σ₁ → σ₁ × φ) (f₂ : α → β → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ xs (mapAccumr₂ f₂ xs ys s₂).snd s₁)
    = let m := mapAccumr₂ (fun x y (s₁, s₂) =>
                let r₂ := f₂ x y s₂
                let r₁ := f₁ x r₂.snd s₁
                ((r₁.fst, r₂.fst), r₁.snd)
              )
            xs ys (s₁, s₂)
    (m.fst.fst, m.snd)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem empty_ssubset : ∅ ⊂ s ↔ s.Nonempty
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem lt_asymm : ∀ {x y : Bool}, x < y → ¬ y < x
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem DifferentiableOn.of_dslope (h : DifferentiableOn 𝕜 (dslope f a) s) :
    DifferentiableOn 𝕜 f s
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepSets.union {s₁ s₂ s' : Set (Set Ω)} (h₁ : IndepSets s₁ s' μ) (h₂ : IndepSets s₂ s' μ) :
    IndepSets (s₁ ∪ s₂) s' μ
-- Mathlib/Topology/ContinuousOn.lean
theorem diff_mem_nhdsWithin_diff {x : α} {s t : Set α} (hs : s ∈ 𝓝[t] x) (t' : Set α) :
    s \ t' ∈ 𝓝[t \ t'] x
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem le_comap_map : I ≤ (I.map f).comap f
-- Mathlib/Data/Rat/Defs.lean
@[simp, norm_cast] lemma den_natCast (n : ℕ) : den n = 1
-- Mathlib/Order/Minimal.lean
theorem mem_maximals_iff : x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, y ∈ s → r x y → x = y
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem small_iff_lift_mk_lt_univ {α : Type u} :
    Small.{v} α ↔ Cardinal.lift.{v+1,_} #α < univ.{v, max u (v + 1)}
-- Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean
theorem N₁Γ₀_inv_app (K : ChainComplex C ℕ) :
    N₁Γ₀.inv.app K = (toKaroubi _).map (Γ₀NondegComplexIso K).inv ≫
        (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.hom
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem range_top_iff_surjective (f : A →ₐ[R] B) :
    f.range = (⊤ : Subalgebra R B) ↔ Function.Surjective f
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem leadingCoeff_isUnit (hp : p.IsUnitTrinomial) : IsUnit p.leadingCoeff
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mul_bot : I * ⊥ = ⊥
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
protected theorem injective (e : α ≃ᵐ β) : Injective e
-- Mathlib/Topology/VectorBundle/Constructions.lean
theorem prod_apply [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] {x : B} (hx₁ : x ∈ e₁.baseSet)
    (hx₂ : x ∈ e₂.baseSet) (v₁ : E₁ x) (v₂ : E₂ x) :
    prod e₁ e₂ ⟨x, (v₁, v₂)⟩ =
      ⟨x, e₁.continuousLinearEquivAt 𝕜 x hx₁ v₁, e₂.continuousLinearEquivAt 𝕜 x hx₂ v₂⟩
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem mk' : ValidFor l r ⟨⟨l.reverse ++ r⟩, ⟨utf8Len l.reverse⟩⟩
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
protected theorem IsClique.finsetMap {f : α ↪ β} {s : Finset α} (h : G.IsClique s) :
    (G.map f).IsClique (s.map f)
-- Mathlib/Topology/Basic.lean
theorem IsClosed.inter (h₁ : IsClosed s₁) (h₂ : IsClosed s₂) : IsClosed (s₁ ∩ s₂)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem le_mex_of_forall {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal}
    (H : ∀ b < a, ∃ i, f i = b) : a ≤ mex.{_, v} f
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem mem_graph_snd_inj (f : E →ₗ.[R] F) {x y : E} {x' y' : F} (hx : (x, x') ∈ f.graph)
    (hy : (y, y') ∈ f.graph) (hxy : x = y) : x' = y'
-- Mathlib/Data/Real/Sqrt.lean
@[simp] lemma sqrt_zero : sqrt 0 = 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem RCLike.inner_apply (x y : 𝕜) : ⟪x, y⟫ = conj x * y
-- Mathlib/CategoryTheory/ComposableArrows.lean
lemma mkOfObjOfMapSucc_map_succ (i : ℕ) (hi : i < n := by valid) :
    (mkOfObjOfMapSucc obj mapSucc).map' i (i + 1) = mapSucc ⟨i, hi⟩
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
/-- Loop from a generalized loop by currying $I^N → X$ into $I → (I^{N\setminus\{j\}} → X)$. -/
@[simps]
def toLoop (i : N) (p : Ω^ N X x) : Ω (Ω^ { j // j ≠ i } X x) const
-- Mathlib/LinearAlgebra/Prod.lean
theorem fst_eq_coprod : fst R M M₂ = coprod LinearMap.id 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem exists_mem_factors {x : α} (hx : x ≠ 0) (h : ¬IsUnit x) : ∃ p, p ∈ factors x
-- Mathlib/Data/Setoid/Partition.lean
/-- A finite setoid partition furnishes a finpartition -/
@[simps]
def IsPartition.finpartition {c : Finset (Set α)} (hc : Setoid.IsPartition (c : Set (Set α))) :
    Finpartition (Set.univ : Set α)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_quadratic_lt_degree_C_mul_X_cb (ha : a ≠ 0) :
    degree (C b * X ^ 2 + C c * X + C d) < degree (C a * X ^ 3)
-- Mathlib/Order/ConditionallyCompleteLattice/Finset.lean
theorem Finset.Nonempty.csInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp, norm_cast]
theorem coe_empty : ↑(∅ : ZFSet.{u}) = (∅ : Class.{u})
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
    Multiplicative.ofAdd '' (AddSubmonoid.multiples x : Set A) =
      Submonoid.powers (Multiplicative.ofAdd x)
-- Mathlib/GroupTheory/Perm/Support.lean
theorem zpow_apply_eq_self_of_apply_eq_self {x : α} (hfx : f x = x) : ∀ n : ℤ, (f ^ n) x = x
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
/-- The good products span all of `LocallyConstant C ℤ` if `C` is closed. -/
theorem GoodProducts.span (hC : IsClosed C) :
    ⊤ ≤ Submodule.span ℤ (Set.range (eval C))
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Ioc_coe_coe : Ioc (a : WithTop α) b = (Ioc a b).map Embedding.some
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem eventually_liminf_le (hf : IsBoundedUnder (· ≥ ·) f u := by isBoundedDefault) :
    ∀ᶠ b in f, f.liminf u ≤ u b
-- Mathlib/LinearAlgebra/Span.lean
theorem coord_self : (coord R M x h) (⟨x, Submodule.mem_span_singleton_self x⟩ : R ∙ x) = 1
-- Mathlib/Data/Finset/Basic.lean
theorem not_mem_mono {s t : Finset α} (h : s ⊆ t) {a : α} : a ∉ t → a ∉ s
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem ContDiffAt.comp_contMDiffAt {g : F → F'} {f : M → F} {x : M} (hg : ContDiffAt 𝕜 n g (f x))
    (hf : ContMDiffAt I 𝓘(𝕜, F) n f x) : ContMDiffAt I 𝓘(𝕜, F') n (g ∘ f) x
-- Mathlib/Data/List/GetD.lean
theorem getI_append_right (l l' : List α) (n : ℕ) (h : l.length ≤ n) :
    (l ++ l').getI n = l'.getI (n - l.length)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
@[simp]
theorem infEdist_iUnion (f : ι → Set α) (x : α) : infEdist x (⋃ i, f i) = ⨅ i, infEdist x (f i)
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem IntegrableOn.continuousOn_mul [T2Space X] (hg : ContinuousOn g K)
    (hg' : IntegrableOn g' K μ) (hK : IsCompact K) : IntegrableOn (fun x => g x * g' x) K μ
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem ι_eq_algebraMap_iff (x : M) (r : R) : ι R x = algebraMap R _ r ↔ x = 0 ∧ r = 0
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem get!_eq_get (s : String) (p : Pos) : get! s p = get s p
-- Mathlib/Algebra/Category/ModuleCat/Projective.lean
/-- Modules that have a basis are projective. -/
theorem projective_of_free {ι : Type u'} (b : Basis ι R M) : Projective M
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_pf_add_overlap
    (_ : a₁ + b₁ = c₁) (_ : a₂ + b₂ = c₂) : (a₁ + a₂ : R) + (b₁ + b₂) = c₁ + c₂
-- Mathlib/Algebra/CharZero/Lemmas.lean
theorem nat_mul_inj {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) : n = 0 ∨ a = b
-- Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean
theorem preimage_inversion_perpBisector_inversion (hR : R ≠ 0) (hy : y ≠ c) :
    inversion c R ⁻¹' perpBisector c (inversion c R y) = sphere y (dist y c) \ {c}
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_Ici_eq_integral_Ioi : ∫ t in Ici x, f t ∂μ = ∫ t in Ioi x, f t ∂μ
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem MeasurableSet.sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
    MeasurableSet (⋂₀ s)
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma rightHomologyι_comp_fromOpcycles :
    S.rightHomologyι ≫ S.fromOpcycles = 0
-- Mathlib/Data/Nat/Defs.lean
protected lemma div_le_self' (m n : ℕ) : m / n ≤ m
-- Mathlib/Data/Real/GoldenRatio.lean
@[simp]
theorem gold_sub_goldConj : φ - ψ = √5
-- Mathlib/RingTheory/IntegralDomain.lean
theorem card_nthRoots_subgroup_units [Fintype G] [DecidableEq G] (f : G →* R) (hf : Injective f)
    {n : ℕ} (hn : 0 < n) (g₀ : G) :
    Finset.card (Finset.univ.filter (fun g ↦ g^n = g₀)) ≤ Multiset.card (nthRoots n (f g₀))
-- Mathlib/RingTheory/ClassGroup.lean
theorem ClassGroup.mk_eq_one_iff {I : (FractionalIdeal R⁰ K)ˣ} :
    ClassGroup.mk I = 1 ↔ (I : Submodule R K).IsPrincipal
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
theorem Left.pow_lt_one_iff [CovariantClass M M (· * ·) (· < ·)] {n : ℕ} {x : M} (hn : 0 < n) :
    x ^ n < 1 ↔ x < 1
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The cartesian product of `C^n` functions on domains is `C^n`. -/
theorem ContDiffOn.prod {s : Set E} {f : E → F} {g : E → G} (hf : ContDiffOn 𝕜 n f s)
    (hg : ContDiffOn 𝕜 n g s) : ContDiffOn 𝕜 n (fun x : E => (f x, g x)) s
-- Mathlib/Topology/Connected/Basic.lean
theorem isPreconnected_iUnion {ι : Sort*} {s : ι → Set α} (h₁ : (⋂ i, s i).Nonempty)
    (h₂ : ∀ i, IsPreconnected (s i)) : IsPreconnected (⋃ i, s i)
-- Mathlib/RingTheory/Flat/Basic.lean
/-- A retract of a flat `R`-module is flat. -/
lemma of_retract [f : Flat R M] (i : N →ₗ[R] M) (r : M →ₗ[R] N) (h : r.comp i = LinearMap.id) :
    Flat R N
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem dvd_of_mul_right_dvd (h : a * b ∣ c) : a ∣ c
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem toSubmodule_eq_top {S : Subalgebra R A} : Subalgebra.toSubmodule S = ⊤ ↔ S = ⊤
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
@[simp]
theorem one_lt_ofNat : 1 < (no_index (OfNat.ofNat n : α))
-- Mathlib/Data/NNReal/Basic.lean
protected theorem coe_two : ((2 : ℝ≥0) : ℝ) = 2
-- Mathlib/CategoryTheory/Abelian/Refinements.lean
lemma ShortComplex.exact_iff_exact_up_to_refinements :
    S.Exact ↔ ∀ ⦃A : C⦄ (x₂ : A ⟶ S.X₂) (_ : x₂ ≫ S.g = 0),
      ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x₁ : A' ⟶ S.X₁), π ≫ x₂ = x₁ ≫ S.f
-- Mathlib/Data/Finset/Grade.lean
lemma covBy_iff : s ⋖ t ↔ ∃ a, a ::ₘ s = t
-- Mathlib/Order/Monotone/Basic.lean
theorem monotone_app (f : β → α → γ) (b : β) (hf : Monotone fun a b ↦ f b a) : Monotone (f b)
-- Mathlib/Data/Set/Function.lean
theorem InjOn.mem_image_iff {x} (hf : InjOn f s) (hs : s₁ ⊆ s) (hx : x ∈ s) :
    f x ∈ f '' s₁ ↔ x ∈ s₁
-- Mathlib/Control/Functor.lean
theorem Functor.map_comp_map (f : α → β) (g : β → γ) :
    ((g <$> ·) ∘ (f <$> ·) : F α → F γ) = ((g ∘ f) <$> ·)
-- Mathlib/Order/SupIndep.lean
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- An algebra of sets is closed by difference. -/
theorem diff_mem (h𝒜 : IsSetAlgebra 𝒜) (s_mem : s ∈ 𝒜) (t_mem : t ∈ 𝒜) :
    s \ t ∈ 𝒜
-- .lake/packages/batteries/Batteries/Classes/Order.lean
/-- Local instance for `TransOrd (ord.on f)`. -/
theorem TransOrd.instOn [ord : Ord β] [TransOrd β] (f : α → β) : @TransOrd _ (ord.on f)
-- Mathlib/Data/Nat/Digits.lean
theorem nine_dvd_iff (n : ℕ) : 9 ∣ n ↔ 9 ∣ (digits 10 n).sum
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
/-- The region between two measurable functions on a measurable set is measurable;
a version for the region together with the graphs of both functions. -/
theorem measurableSet_region_between_cc (hf : Measurable f) (hg : Measurable g)
    (hs : MeasurableSet s) :
    MeasurableSet { p : α × ℝ | p.fst ∈ s ∧ p.snd ∈ Icc (f p.fst) (g p.fst) }
-- Mathlib/MeasureTheory/PiSystem.lean
theorem generatePiSystem_eq {α} {S : Set (Set α)} (h_pi : IsPiSystem S) : generatePiSystem S = S
-- Mathlib/Data/Set/Function.lean
/-- If functions `f'` and `f` are inverse on `s` and `t`, `f` maps `s` into `t`, and `f'` maps `t`
into `s`, then `f` is a bijection between `s` and `t`. The `mapsTo` arguments can be deduced from
`surjOn` statements using `LeftInvOn.mapsTo` and `RightInvOn.mapsTo`. -/
theorem bijOn (h : InvOn f' f s t) (hf : MapsTo f s t) (hf' : MapsTo f' t s) : BijOn f s t
-- Mathlib/Data/List/NatAntidiagonal.lean
/-- The antidiagonal of `0` is the list `[(0, 0)]` -/
@[simp]
theorem antidiagonal_zero : antidiagonal 0 = [(0, 0)]
-- Mathlib/LinearAlgebra/QuadraticForm/Complex.lean
/-- A nondegenerate quadratic form on the complex numbers is equivalent to
the sum of squares, i.e. `weightedSumSquares` with weight `fun (i : ι) => 1`. -/
theorem equivalent_sum_squares {M : Type*} [AddCommGroup M] [Module ℂ M] [FiniteDimensional ℂ M]
    (Q : QuadraticForm ℂ M) (hQ : (associated (R := ℂ) Q).SeparatingLeft) :
    Equivalent Q (weightedSumSquares ℂ (1 : Fin (FiniteDimensional.finrank ℂ M) → ℂ))
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem toReal_pow (a : ℝ≥0∞) (n : ℕ) : (a ^ n).toReal = a.toReal ^ n
-- Mathlib/Data/DFinsupp/Interval.lean
/-- When `t` is supported on `s`, `f ∈ s.dfinsupp t` precisely means that `f` is pointwise in `t`.
-/
@[simp]
theorem mem_dfinsupp_iff_of_support_subset {t : Π₀ i, Finset (α i)} (ht : t.support ⊆ s) :
    f ∈ s.dfinsupp t ↔ ∀ i, f i ∈ t i
-- Mathlib/Order/Basic.lean
lemma const_le_elim_iff {b : β} {v₁ : α₁ → β} {v₂ : α₂ → β} :
    Function.const _ b ≤ Sum.elim v₁ v₂ ↔ Function.const _ b ≤ v₁ ∧ Function.const _ b ≤ v₂
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes right covariance. -/
theorem Right.mul_lt_one_of_le_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (hb : b < 1)
    (b0 : 0 ≤ b) : a * b < 1
-- Mathlib/Data/Set/Function.lean
protected lemma BijOn.extendDomain (h : BijOn g s t) :
    BijOn (g.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t)
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
@[simp]
theorem zpow_neg_natCast (A : M) (n : ℕ) : A ^ (-n : ℤ) = (A ^ n)⁻¹
-- Mathlib/AlgebraicTopology/DoldKan/Faces.lean
theorem induction {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ) :
    HigherFacesVanish (q + 1) (φ ≫ (𝟙 _ + Hσ q).f (n + 1))
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem Tendsto.isLindelof_insert_range_of_coLindelof {f : X → Y} {y}
    (hf : Tendsto f (coLindelof X) (𝓝 y)) (hfc : Continuous f) :
    IsLindelof (insert y (range f))
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem deleteEdges_spanningCoe_eq :
    G'.spanningCoe.deleteEdges s = (G'.deleteEdges s).spanningCoe
-- Mathlib/Data/Fintype/Basic.lean
/-- `Fintype α` means that `α` is finite, i.e. there are only
  finitely many distinct elements of type `α`. The evidence of this
  is a finset `elems` (a list up to permutation without duplicates),
  together with a proof that everything of type `α` is in the list. -/
class Fintype (α : Type*) where
  /-- The `Finset` containing all elements of a `Fintype` -/
  elems : Finset α
  /-- A proof that `elems` contains every element of the type -/
  complete : ∀ x : α, x ∈ elems
-- Mathlib/Computability/ContextFreeGrammar.lean
lemma ContextFreeGrammar.reverse_derives (g : ContextFreeGrammar T) {s : List (Symbol T g.NT)}
    (hgs : g.reverse.Derives [Symbol.nonterminal g.reverse.initial] s) :
    g.Derives [Symbol.nonterminal g.initial] s.reverse
-- Mathlib/MeasureTheory/Integral/Gamma.lean
theorem integral_rpow_mul_exp_neg_rpow {p q : ℝ} (hp : 0 < p) (hq : - 1 < q) :
    ∫ x in Ioi (0 : ℝ), x ^ q * exp (- x ^ p) = (1 / p) * Gamma ((q + 1) / p)
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma desc_f (p q : ℤ) (hpq : p + 1 = q) :
    (desc φ α β eq).f p = (fst φ).1.v p q hpq ≫ α.v q p (by omega) +
      (snd φ).v p p (add_zero p) ≫ β.f p
-- Mathlib/Data/Matrix/Block.lean
theorem vecMul_fromBlocks [Fintype n] [Fintype o] [NonUnitalNonAssocSemiring α] (A : Matrix n l α)
    (B : Matrix n m α) (C : Matrix o l α) (D : Matrix o m α) (x : n ⊕ o → α) :
    x ᵥ* fromBlocks A B C D =
      Sum.elim ((x ∘ Sum.inl) ᵥ* A + (x ∘ Sum.inr) ᵥ* C)
        ((x ∘ Sum.inl) ᵥ* B + (x ∘ Sum.inr) ᵥ* D)
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma fst_zero : fst (0 : Kernel α (β × γ)) = 0
-- Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean
theorem Memℒp.sub {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) : Memℒp (f - g) p μ
-- Mathlib/Data/Int/Lemmas.lean
theorem le_natCast_sub (m n : ℕ) : (m - n : ℤ) ≤ ↑(m - n : ℕ)
-- Mathlib/Order/Basic.lean
theorem Preorder.ext {A B : Preorder α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) : A = B
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.continuousWithinAt_stieltjesFunctionAux_Ici (a : α) (x : ℝ) :
    ContinuousWithinAt (IsMeasurableRatCDF.stieltjesFunctionAux f a) (Ici x) x
-- Mathlib/CategoryTheory/Sites/CoverPreserving.lean
/-- A functor `G : (C, J) ⥤ (D, K)` between sites is *cover-preserving*
if for all covering sieves `R` in `C`, `R.functorPushforward G` is a covering sieve in `D`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure CoverPreserving (G : C ⥤ D) : Prop where
  cover_preserve : ∀ {U : C} {S : Sieve U} (_ : S ∈ J U), S.functorPushforward G ∈ K (G.obj U)
-- Mathlib/Data/Set/Image.lean
theorem Surjective.preimage_subset_preimage_iff {s t : Set β} (hf : Surjective f) :
    f ⁻¹' s ⊆ f ⁻¹' t ↔ s ⊆ t
-- Mathlib/Order/Interval/Multiset.lean
@[simp] lemma mem_Ioo : x ∈ Ioo a b ↔ a < x ∧ x < b
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- `Fin.sigma_eq_of_eq_comp_cast` as an `iff`. -/
theorem sigma_eq_iff_eq_comp_cast {α : Type*} {a b : Σii, Fin ii → α} :
    a = b ↔ ∃ h : a.fst = b.fst, a.snd = b.snd ∘ Fin.cast h
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.congr_deriv (h : HasDerivWithinAt f f' s x) (h' : f' = g') :
    HasDerivWithinAt f g' s x
-- Mathlib/Algebra/IsPrimePow.lean
theorem IsPrimePow.pow {n : R} (hn : IsPrimePow n) {k : ℕ} (hk : k ≠ 0) : IsPrimePow (n ^ k)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableAt_neg_iff : DifferentiableAt 𝕜 (fun y => -f y) x ↔ DifferentiableAt 𝕜 f x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem lt_add_succ (a : Int) (n : Nat) : a < a + Nat.succ n
-- Mathlib/Data/Sym/Sym2.lean
protected theorem exact {p p' : α × α} (h : Sym2.mk p = Sym2.mk p') : Sym2.Rel α p p'
-- Mathlib/Data/NNReal/Basic.lean
theorem inv_le_of_le_mul {r p : ℝ≥0} (h : 1 ≤ r * p) : r⁻¹ ≤ p
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem mul_apply (f g : Perm α) (x) : (f * g) x = f (g x)
-- Mathlib/FieldTheory/IntermediateField.lean
protected theorem pow_mem {x : L} (hx : x ∈ S) (n : ℤ) : x ^ n ∈ S
-- Mathlib/Data/List/MinMax.lean
lemma getD_minimum?_eq_untop'_minimum (l : List α) (d : α) :
    l.minimum?.getD d = l.minimum.untop' d