ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepSets.indepSet_of_mem {_m0 : MeasurableSpace Ω} (hs : s ∈ S) (ht : t ∈ T)
    (hs_meas : MeasurableSet s) (ht_meas : MeasurableSet t)
    (κ : Kernel α Ω) (μ : Measure α) [IsMarkovKernel κ]
    (h_indep : IndepSets S T κ μ) :
    IndepSet s t κ μ
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis.exists_base (hI : M.Basis I X) : ∃ B, M.Base B ∧ I = B ∩ X
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem exact {s : Setoid α} {a b : α} : Quotient.mk s a = Quotient.mk s b → a ≈ b
-- Mathlib/Algebra/Module/Submodule/Range.lean
@[simp]
theorem comap_subtype_self : comap p.subtype p = ⊤
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- Appending a one-tuple to the left is the same as `Fin.cons`. -/
theorem append_left_eq_cons {α : Type*} {n : ℕ} (x₀ : Fin 1 → α) (x : Fin n → α) :
    Fin.append x₀ x = Fin.cons (x₀ 0) x ∘ Fin.cast (Nat.add_comm ..)
-- Mathlib/Logic/Equiv/Fin.lean
/-- The equiv version of `Fin.predAbove_zero`. -/
theorem finSuccEquiv'_zero : finSuccEquiv' (0 : Fin (n + 1)) = finSuccEquiv n
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem einfsep_pair (hxy : x ≠ y) : ({x, y} : Set α).einfsep = edist x y
-- Mathlib/Order/Filter/AtTopBot.lean
theorem map_sub_atTop_eq_nat (k : ℕ) : map (fun a => a - k) atTop = atTop
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem coeff_add (m : σ →₀ ℕ) (p q : MvPolynomial σ R) : coeff m (p + q) = coeff m p + coeff m q
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[simp]
theorem toAddSubgroup_eq : p.toAddSubgroup = p'.toAddSubgroup ↔ p = p'
-- Mathlib/GroupTheory/Coset.lean
@[to_additive mem_own_leftAddCoset]
theorem mem_own_leftCoset (a : α) : a ∈ a • (s : Set α)
-- Mathlib/Data/Nat/Cast/Synonym.lean
@[simp]
theorem ofLex_natCast [NatCast α] (n : ℕ) : (ofLex n : α) = n
-- Mathlib/MeasureTheory/Integral/Bochner.lean
nonrec theorem integral_eq_lintegral {f : α →₁ₛ[μ] ℝ} (h_pos : 0 ≤ᵐ[μ] toSimpleFunc f) :
    integral f = ENNReal.toReal (∫⁻ a, ENNReal.ofReal ((toSimpleFunc f) a) ∂μ)
-- Mathlib/Data/Multiset/Nodup.lean
@[simp]
theorem nodup_zero : @Nodup α 0
-- Mathlib/Topology/Homotopy/Equiv.lean
/-- A homotopy equivalence between topological spaces `X` and `Y` are a pair of functions
`toFun : C(X, Y)` and `invFun : C(Y, X)` such that `toFun.comp invFun` and `invFun.comp toFun`
are both homotopic to corresponding identity maps.
-/
@[ext]
structure HomotopyEquiv (X : Type u) (Y : Type v) [TopologicalSpace X] [TopologicalSpace Y] where
  toFun : C(X, Y)
  invFun : C(Y, X)
  left_inv : (invFun.comp toFun).Homotopic (ContinuousMap.id X)
  right_inv : (toFun.comp invFun).Homotopic (ContinuousMap.id Y)
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem continuum_toPartENat : toPartENat continuum = ⊤
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
lemma isUnit_unit {ζ : M} {n} (hn) (hζ : IsPrimitiveRoot ζ n) :
    IsPrimitiveRoot (hζ.isUnit hn).unit n
-- Mathlib/Order/Category/BoolAlg.lean
@[simp]
theorem coe_of (α : Type*) [BooleanAlgebra α] : ↥(of α) = α
-- Mathlib/Topology/LocallyClosed.lean
/--
A set `s` is locally closed if one of the equivalent conditions below hold
1. It is the intersection of some open set and some closed set.
2. The coborder `(closure s \ s)ᶜ` is open.
3. `s` is closed in some neighborhood of `x` for all `x ∈ s`.
4. Every `x ∈ s` has some open neighborhood `U` such that `U ∩ closure s ⊆ s`.
5. `s` is open in the closure of `s`.
-/
lemma isLocallyClosed_tfae (s : Set X) :
    List.TFAE
    [ IsLocallyClosed s,
      IsOpen (coborder s),
      ∀ x ∈ s, ∃ U ∈ 𝓝 x, IsClosed (U ↓∩ s),
      ∀ x ∈ s, ∃ U, x ∈ U ∧ IsOpen U ∧ U ∩ closure s ⊆ s,
      IsOpen (closure s ↓∩ s)]
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α) :
    s.Intersecting ↔ s = ∅
-- Mathlib/GroupTheory/Complement.lean
theorem isComplement'_of_coprime [Finite G]
    (h1 : Nat.card H * Nat.card K = Nat.card G)
    (h2 : Nat.Coprime (Nat.card H) (Nat.card K)) : IsComplement' H K
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem lift_comp_includeRight (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ x y, Commute (f x) (g y)) :
    ((lift f g hfg).restrictScalars R).comp includeRight = g
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean
theorem matPolyEquiv_charmatrix : matPolyEquiv (charmatrix M) = X - C M
-- Mathlib/Topology/SeparatedMap.lean
theorem IsLocallyInjective.isOpen_eqLocus (he : f ∘ g₁ = f ∘ g₂) : IsOpen {a | g₁ a = g₂ a}
-- Mathlib/Algebra/GroupWithZero/Defs.lean
@[simp] lemma mul_inv_cancel (h : a ≠ 0) : a * a⁻¹ = 1
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem mul_div_right_comm : a * b / c = a / c * b
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- An injective linear map sends linearly independent families of vectors to linearly independent
families of vectors. See also `LinearIndependent.map` for a more general statement. -/
theorem LinearIndependent.map' (hv : LinearIndependent R v) (f : M →ₗ[R] M')
    (hf_inj : LinearMap.ker f = ⊥) : LinearIndependent R (f ∘ v)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.rotateL_lemma₃ {a b c : ℕ} (H2 : 3 * a ≤ b + c) (h : b < 2 * c) : a + b < 3 * c
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi sᶜ t = pi univ t
-- Mathlib/Order/UpperLower/Basic.lean
theorem isLowerSet_iInter {f : ι → Set α} (hf : ∀ i, IsLowerSet (f i)) : IsLowerSet (⋂ i, f i)
-- Mathlib/RingTheory/Polynomial/Quotient.lean
lemma quotientEquivQuotientMvPolynomial_rightInverse (I : Ideal R) :
    Function.RightInverse
      (eval₂ (Ideal.Quotient.lift I
        ((Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R))).comp C)
          fun i hi => quotient_map_C_eq_zero hi)
          fun i => Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R)) (X i))
      (Ideal.Quotient.lift (Ideal.map C I : Ideal (MvPolynomial σ R))
        (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) fun a ha => eval₂_C_mk_eq_zero ha)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive]
theorem toFun_eq_coe (f : α →*o β) : f.toFun = (f : α → β)
-- Mathlib/Data/Matroid/Constructions.lean
@[simp] theorem loopyOn_basis_iff : (loopyOn E).Basis I X ↔ I = ∅ ∧ X ⊆ E
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma mul_nonpos_iff [MulPosStrictMono α] [PosMulStrictMono α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· ≤ ·)] :
    a * b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma compls_univ [Fintype α] : (univ : Finset α)ᶜˢ = univ
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem lcongr_symm_single {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) (k : κ) (n : N) :
    (lcongr e₁ e₂).symm (Finsupp.single k n) = Finsupp.single (e₁.symm k) (e₂.symm n)
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma homMk₅_app_four :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨4, by valid⟩ = app₄
-- Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean
/-- If `M` is nondegenerate and `v ≠ 0`, then there is some `w` such that `w * M * v ≠ 0`. -/
theorem Nondegenerate.exists_not_ortho_of_ne_zero {M : Matrix m m R} (hM : Nondegenerate M)
    {v : m → R} (hv : v ≠ 0) : ∃ w, Matrix.dotProduct v (M *ᵥ w) ≠ 0
-- Mathlib/Topology/MetricSpace/PiNat.lean
@[simp]
theorem mem_cylinder_iff {x y : ∀ n, E n} {n : ℕ} : y ∈ cylinder x n ↔ ∀ i < n, y i = x i
-- Mathlib/FieldTheory/Adjoin.lean
theorem eq_adjoin_of_eq_algebra_adjoin (K : IntermediateField F E)
    (h : K.toSubalgebra = Algebra.adjoin F S) : K = adjoin F S
-- Mathlib/ModelTheory/Basic.lean
@[ext]
theorem ext ⦃f g : M ↪[L] N⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem rightAngleRotation_trans_rightAngleRotation :
    LinearIsometryEquiv.trans J J = LinearIsometryEquiv.neg ℝ
-- Mathlib/CategoryTheory/Comma/Over.lean
/--
If `k.left` is an epimorphism, then `k` is an epimorphism. In other words, `Over.forget X` reflects
epimorphisms.
The converse does not hold without additional assumptions on the underlying category, see
`CategoryTheory.Over.epi_left_of_epi`.
-/
theorem epi_of_epi_left {f g : Over X} (k : f ⟶ g) [hk : Epi k.left] : Epi k
-- Mathlib/Analysis/Convolution.lean
theorem ConvolutionExistsAt.add_distrib {x : G} (hfg : ConvolutionExistsAt f g x L μ)
    (hfg' : ConvolutionExistsAt f' g x L μ) :
    ((f + f') ⋆[L, μ] g) x = (f ⋆[L, μ] g) x + (f' ⋆[L, μ] g) x
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma hasKernel [S.HasRightHomology] [HasCokernel S.f] :
    HasKernel (cokernel.desc S.f S.g S.zero)
-- Mathlib/Data/List/Chain.lean
theorem chain_map (f : β → α) {b : β} {l : List β} :
    Chain R (f b) (map f l) ↔ Chain (fun a b : β => R (f a) (f b)) b l
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem isClosed_range_of_spaced_out {ι} [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α)
    {f : ι → α} (hf : Pairwise fun x y => (f x, f y) ∉ V₀) : IsClosed (range f)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_congr_right_iff : (a ∧ b ↔ a ∧ c) ↔ (a → (b ↔ c))
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem fourier_zero {x : AddCircle T} : fourier 0 x = 1
-- Mathlib/Order/Filter/AtTopBot.lean
@[simp]
theorem comap_atBot (e : α ≃o β) : comap e atBot = atBot
-- .lake/packages/lean4/src/lean/Init/GetElem.lean
theorem getElem?_pos [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    (c : cont) (i : idx) (h : dom c i) [Decidable (dom c i)] : c[i]? = some (c[i]'h)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem Adj.of_spanningCoe {G' : Subgraph G} {u v : G'.verts} (h : G'.spanningCoe.Adj u v) :
    G.Adj u v
-- Mathlib/Data/Set/Sups.lean
protected theorem Nonempty.infs : s.Nonempty → t.Nonempty → (s ⊼ t).Nonempty
-- Mathlib/Order/FixedPoints.lean
theorem lfp_le_map {a : α} (ha : lfp f ≤ a) : lfp f ≤ f a
-- Mathlib/Algebra/MonoidAlgebra/Ideal.lean
/-- If `x` belongs to the ideal generated by generators in `s`, then every element of the support of
`x` factors through an element of `s`.

We could spell `∃ d, m = d * m` as `MulOpposite.op m' ∣ MulOpposite.op m` but this would be worse.
-/
theorem MonoidAlgebra.mem_ideal_span_of_image [Monoid G] [Semiring k] {s : Set G}
    {x : MonoidAlgebra k G} :
    x ∈ Ideal.span (MonoidAlgebra.of k G '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d * m'
-- Mathlib/Algebra/AddConstMap/Basic.lean
theorem map_nat_add [AddCommMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℕ) (x : G) : f (↑n + x) = f x + n
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem dist_lt_mul_of_lt (hf : LipschitzWith K f) (hK : K ≠ 0) (hr : dist x y < r) :
    dist (f x) (f y) < K * r
-- Mathlib/Order/Lattice.lean
theorem eq_of_inf_eq_sup_eq {a b c : α} (h₁ : b ⊓ a = c ⊓ a) (h₂ : b ⊔ a = c ⊔ a) : b = c
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive]
theorem unop_iInf (S : ι → Subgroup Gᵐᵒᵖ) : (iInf S).unop = ⨅ i, (S i).unop
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem innerSL_apply (v w : E) : innerSL 𝕜 v w = ⟪v, w⟫
-- Mathlib/Probability/Independence/Conditional.lean
theorem condIndepSet_iff_condIndepSets_singleton {s t : Set Ω} (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepSet m' hm' s t μ ↔ CondIndepSets m' hm' {s} {t} μ
-- Mathlib/Data/TypeVec.lean
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
@[nontriviality]
theorem subsingleton_iff [Subsingleton B] : IsCyclotomicExtension S A B ↔ S = { } ∨ S = {1}
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem power_le_power_right {a b c : Cardinal} : a ≤ b → a ^ c ≤ b ^ c
-- Mathlib/Topology/Connected/PathConnected.lean
theorem pathComponent_subset_component (x : X) : pathComponent x ⊆ connectedComponent x
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Zero.lean
/-- A functor preserves zero morphisms if it sends zero morphisms to zero morphisms. -/
class PreservesZeroMorphisms (F : C ⥤ D) : Prop where
  /-- For any pair objects `F (0: X ⟶ Y) = (0 : F X ⟶ F Y)` -/
  map_zero : ∀ X Y : C, F.map (0 : X ⟶ Y) = 0 := by aesop
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem!_cons_zero [Inhabited α] {l : List α} : (a::l)[0]! = a
-- Mathlib/Topology/Bases.lean
theorem IsSeparable.of_separableSpace [h : SeparableSpace α] (s : Set α) : IsSeparable s
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem IccExtend_range (f : Icc a b → β) : range (IccExtend h f) = range f
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
theorem polarBilin_tmul [Invertible (2 : A)] (Q₁ : QuadraticForm A M₁) (Q₂ : QuadraticForm R M₂) :
    polarBilin (Q₁.tmul Q₂) = ⅟(2 : A) • (polarBilin Q₁).tmul (polarBilin Q₂)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
    sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem universally_stableUnderBaseChange (P : MorphismProperty C) :
    P.universally.StableUnderBaseChange
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma hasLeftExtension_iff_postcomp₁ :
    HasLeftKanExtension L' F ↔ HasLeftKanExtension L F
-- Mathlib/Logic/Small/Group.lean
@[simp]
lemma equivShrink_neg [Neg α] [Small α] (x : α) :
    equivShrink α (-x) = -equivShrink α x
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem map_bot (f : R →+* S) : (⊥ : Subring R).map f = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem eq_mk_iff_val_eq {a : Fin n} {k : Nat} {hk : k < n} :
    a = ⟨k, hk⟩ ↔ (a : Nat) = k
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive (attr := simp) nnnorm_pos]
lemma nnnorm_pos' : 0 < ‖a‖₊ ↔ a ≠ 1
-- Mathlib/Data/Matroid/Restrict.lean
theorem Basis.basis_restriction (hI : M.Basis I X) (hNM : N ≤r M) (hX : X ⊆ N.E) : N.Basis I X
-- Mathlib/Algebra/Homology/TotalComplex.lean
lemma d₁_eq' {i₁ i₁' : I₁} (h : c₁.Rel i₁ i₁') (i₂ : I₂) (i₁₂ : I₁₂) :
    K.d₁ c₁₂ i₁ i₂ i₁₂ = ComplexShape.ε₁ c₁ c₂ c₁₂ ⟨i₁, i₂⟩ • ((K.d i₁ i₁').f i₂ ≫
      K.toGradedObject.ιMapObjOrZero (ComplexShape.π c₁ c₂ c₁₂) ⟨i₁', i₂⟩ i₁₂)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem or_eq_true_iff : ∀ (x y : Bool), (x || y) = true ↔ x = true ∨ y = true
-- Mathlib/Topology/Algebra/StarSubalgebra.lean
theorem topologicalClosure_map [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
    (s : StarSubalgebra R A) (φ : A →⋆ₐ[R] B) (hφ : ClosedEmbedding φ) :
    (map φ s).topologicalClosure = map φ s.topologicalClosure
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csSup_image2_eq_csSup_csInf (h₁ : ∀ b, GaloisConnection (swap l b) (u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a ∘ ofDual) (toDual ∘ u₂ a)) :
    s.Nonempty → BddAbove s → t.Nonempty → BddBelow t → sSup (image2 l s t) = l (sSup s) (sInf t)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem normSq_ratCast (q : ℚ) : normSq q = q * q
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
theorem span_sup {S : Set (ℙ K V)} {W : Subspace K V} : span S ⊔ W = span (S ∪ W)
-- Mathlib/AlgebraicGeometry/Limits.lean
lemma exists_sigmaι_eq (x : (∐ f : _)) : ∃ i y, (Sigma.ι f i).1.base y = x
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- A rewrite lemma for `padicValRat p q` when `q` is expressed in terms of `Rat.mk`. -/
protected theorem defn (p : ℕ) [hp : Fact p.Prime] {q : ℚ} {n d : ℤ} (hqz : q ≠ 0)
    (qdf : q = n /. d) :
    padicValRat p q =
      (multiplicity (p : ℤ) n).get
          (finite_int_iff.2 ⟨hp.1.ne_one, fun hn => by simp_all⟩) -
        (multiplicity (p : ℤ) d).get
          (finite_int_iff.2 ⟨hp.1.ne_one, fun hd => by simp_all⟩)
-- Mathlib/Topology/Bases.lean
lemma IsTopologicalBasis.eq_of_forall_subset_iff {t : Set α} (hB : IsTopologicalBasis B)
    (hs : IsOpen s) (ht : IsOpen t) (h : ∀ U ∈ B, U ⊆ s ↔ U ⊆ t) : s = t
-- Mathlib/Topology/Constructions.lean
/-- A product set is open in a product space if and only if each factor is open, or one of them is
empty -/
theorem isOpen_prod_iff' {s : Set X} {t : Set Y} :
    IsOpen (s ×ˢ t) ↔ IsOpen s ∧ IsOpen t ∨ s = ∅ ∨ t = ∅
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem condition {X} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) (I : S.Relation) :
    P.map I.r.g₁.op (x ((S.index P).fstTo I)) = P.map I.r.g₂.op (x ((S.index P).sndTo I))
-- Mathlib/LinearAlgebra/Lagrange.lean
/--
Two polynomials, with the same degree and leading coefficient, which have the same evaluation
on a set of distinct values with cardinality equal to the degree, are equal.
-/
theorem eq_of_degree_le_of_eval_finset_eq
    (h_deg_le : f.degree ≤ s.card)
    (h_deg_eq : f.degree = g.degree)
    (hlc : f.leadingCoeff = g.leadingCoeff)
    (h_eval : ∀ x ∈ s, f.eval x = g.eval x) :
    f = g
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem sum_const' (ι : Type u) (a : Cardinal.{u}) : (sum fun _ : ι => a) = #ι * a
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Icc_diff_both (a b : α) : Icc a b \ {a, b} = Ioo a b
-- Mathlib/Analysis/Convex/EGauge.lean
lemma egauge_smul_left (hc : c ≠ 0) (s : Set E) (x : E) :
    egauge 𝕜 (c • s) x = egauge 𝕜 s x / ‖c‖₊
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem rootsExpandToRoots_apply (x) : (rootsExpandToRoots p f x : R) = x ^ p
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
@[simp]
theorem right_triangle : whiskerLeft G adj.unit ≫ whiskerRight adj.counit G = 𝟙 _
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem Fintype.total_apply (f) : Fintype.total R S v f = ∑ i, f i • v i
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_map_zero_le : f (g 0) ≤ f 0 + ⌈g 0⌉
-- Mathlib/Data/Set/Lattice.lean
theorem sInter_eq_biInter {s : Set (Set α)} : ⋂₀ s = ⋂ (i : Set α) (_ : i ∈ s), i
-- Mathlib/CategoryTheory/Sites/Types.lean
theorem discreteSieve_mem (α : Type u) : discreteSieve α ∈ typesGrothendieckTopology α
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem mono_ac {ν : Measure α} {φ : ι → Set α} (hφ : AECover μ l φ) (hle : ν ≪ μ) :
    AECover ν l φ
-- Mathlib/Algebra/SMulWithZero.lean
lemma boole_smul (a : M) : (if p then 1 else 0 : R) • a = if p then a else 0
-- Mathlib/Algebra/Order/Group/Int.lean
theorem natAbs_sub_pos_iff {i j : ℤ} : 0 < natAbs (i - j) ↔ i ≠ j
-- Mathlib/RingTheory/Perfection.lean
theorem coeff_nat_find_add_ne_zero {f : PreTilt K v O hv p} {h : ∃ n, coeff _ _ n f ≠ 0} (k : ℕ) :
    coeff _ _ (Nat.find h + k) f ≠ 0
-- Mathlib/Algebra/Algebra/Hom.lean
@[simp]
theorem toLinearMap_apply (p : A) : φ.toLinearMap p = φ p
-- Mathlib/Data/Set/Finite.lean
theorem finite_preimage_inl_and_inr {s : Set (α ⊕ β)} :
    (Sum.inl ⁻¹' s).Finite ∧ (Sum.inr ⁻¹' s).Finite ↔ s.Finite
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem tail_ofFn {n : ℕ} (f : Fin n.succ → α) : tail (ofFn f) = ofFn fun i => f i.succ
-- Mathlib/Order/Monotone/Basic.lean
theorem foldl_monotone [Preorder α] {f : α → β → α} (H : ∀ b, Monotone fun a ↦ f a b)
    (l : List β) : Monotone fun a ↦ l.foldl f a
-- Mathlib/Data/Set/Function.lean
theorem piecewise_insert [DecidableEq α] (j : α) [∀ i, Decidable (i ∈ insert j s)] :
    (insert j s).piecewise f g = Function.update (s.piecewise f g) j (f j)
-- Mathlib/Algebra/Category/AlgebraCat/Basic.lean
@[simp]
theorem coe_of (X : Type u) [Ring X] [Algebra R X] : (of R X : Type u) = X
-- Mathlib/MeasureTheory/Constructions/EventuallyMeasurable.lean
/-- A set which is `EventuallyEq` to an `EventuallyMeasurableSet`
is an `EventuallyMeasurableSet`. -/
theorem EventuallyMeasurableSet.congr
    (ht : EventuallyMeasurableSet m l t) (hst : s =ᶠ[l] t) : EventuallyMeasurableSet m l s
-- Mathlib/Topology/Bornology/BoundedOperation.lean
lemma isBounded_pow {R : Type*} [Bornology R] [Monoid R] [BoundedMul R] {s : Set R}
    (s_bdd : Bornology.IsBounded s) (n : ℕ) :
    Bornology.IsBounded ((fun x ↦ x ^ n) '' s)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffOn_prod' {t : Finset ι} {f : ι → E → 𝔸'} (h : ∀ i ∈ t, ContDiffOn 𝕜 n (f i) s) :
    ContDiffOn 𝕜 n (∏ i ∈ t, f i) s
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the topologies
of uniform convergence on `𝔖` and pointwise convergence induce the same topology on `ι`.

This is a specialization of `EquicontinuousOn.inducing_uniformOnFun_iff_pi'` to
the case where `𝔖` covers `X`. -/
lemma EquicontinuousOn.inducing_uniformOnFun_iff_pi [TopologicalSpace ι]
    {𝔖 : Set (Set X)} (𝔖_covers : ⋃₀ 𝔖 = univ) (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
    (F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
    Inducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
    Inducing F
-- Mathlib/Topology/Compactness/LocallyCompact.lean
protected theorem IsClosed.locallyCompactSpace [LocallyCompactSpace X] {s : Set X}
    (hs : IsClosed s) : LocallyCompactSpace s
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**, local version.

If `f` has a finite limit `c` almost surely at `l'`, where `(l, l')` is an
`intervalIntegral.FTCFilter` pair around `a`, then `∫ x in u..v, f x ∂μ = (v - u) • c + o (v - u)`
as both `u` and `v` tend to `l`. -/
theorem integral_sub_linear_isLittleO_of_tendsto_ae [FTCFilter a l l']
    (hfm : StronglyMeasurableAtFilter f l') (hf : Tendsto f (l' ⊓ ae volume) (𝓝 c)) {u v : ι → ℝ}
    (hu : Tendsto u lt l) (hv : Tendsto v lt l) :
    (fun t => (∫ x in u t..v t, f x) - (v t - u t) • c) =o[lt] (v - u)
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and `N` are linearly disjoint, if `M` is flat, then for any family of
`R`-linearly independent elements `{ m_i }` of `M`, and any family of
`R`-linearly independent elements `{ n_j }` of `N`, the family `{ m_i * n_j }` in `S` is
also `R`-linearly independent. -/
theorem linearIndependent_mul_of_flat_left (H : M.LinearDisjoint N) [Module.Flat R M]
    {κ ι : Type*} {m : κ → M} {n : ι → N} (hm : LinearIndependent R m)
    (hn : LinearIndependent R n) : LinearIndependent R fun (i : κ × ι) ↦ (m i.1).1 * (n i.2).1
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem NFBelow_zero : ∀ {o}, NFBelow o 0 ↔ o = 0
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arccos`. -/
theorem oangle_add_right_eq_arccos_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle x (x + y) = Real.arccos (‖x‖ / ‖x + y‖)
-- Mathlib/CategoryTheory/NatTrans.lean
theorem congr_app {F G : C ⥤ D} {α β : NatTrans F G} (h : α = β) (X : C) : α.app X = β.app X
-- Mathlib/GroupTheory/PresentedGroup.lean
theorem equivPresentedGroup_symm_apply_of (x : β) (rels : Set (FreeGroup α)) (e : α ≃ β) :
    (equivPresentedGroup rels e).symm (PresentedGroup.of x) =
      PresentedGroup.of (rels := rels) (e.symm x)
-- Mathlib/Algebra/Lie/Basic.lean
theorem sub_apply (f g : M →ₗ⁅R,L⁆ N) (m : M) : (f - g) m = f m - g m
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
lemma sigmaFinite_of_measure_compl_sigmaFiniteSet_eq_zero [SFinite μ]
    (h : μ μ.sigmaFiniteSetᶜ = 0) :
    SigmaFinite μ
-- Mathlib/Algebra/Group/Support.lean
@[to_additive (attr := simp)]
theorem mulSupport_one' : mulSupport (1 : α → M) = ∅
-- Mathlib/Logic/Relator.lean
lemma bi_total_eq {α : Type u₁} : Relator.BiTotal (@Eq α)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem add_self_ne_one : ∀ n, n + n ≠ 1
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem toQuaternion_ofQuaternion (q : ℍ[R,c₁,c₂]) : toQuaternion (ofQuaternion q) = q
-- Mathlib/CategoryTheory/Limits/Yoneda.lean
/-- The proposed colimit cocone over `coyoneda.obj X` is a colimit cocone.
-/
@[simps]
def colimitCoconeIsColimit (X : Cᵒᵖ) : IsColimit (colimitCocone X)
-- Mathlib/CategoryTheory/Adjunction/Unique.lean
@[reassoc (attr := simp)]
theorem leftAdjointUniq_hom_counit {F F' : C ⥤ D} {G : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) :
    whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit = adj1.counit
-- Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean
theorem frobenius_frobeniusRotation {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    frobenius (frobeniusRotation p ha₁ ha₂) * a₁ = frobeniusRotation p ha₁ ha₂ * a₂