ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma pairwiseDisjoint_diffFinset₀ (hC : IsSetSemiring C) (hs : s ∈ C) (hI : ↑I ⊆ C) :
    PairwiseDisjoint (hC.diffFinset₀ hs hI : Set (Set α)) id
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_lt_add_translationNumber_add_one (x : ℝ) : f x < x + τ f + 1
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_add (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) : f (x + y) = f x + f y
-- Mathlib/Tactic/NormNum/Inv.lean
theorem isRat_mkRat : {a na n : ℤ} → {b nb d : ℕ} → IsInt a na → IsNat b nb →
    IsRat (na / nb : ℚ) n d → IsRat (mkRat a b) n d
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
lemma prod_lt_prod (hf : ∀ i ∈ s, 0 < f i) (hfg : ∀ i ∈ s, f i ≤ g i)
    (hlt : ∃ i ∈ s, f i < g i) :
    ∏ i ∈ s, f i < ∏ i ∈ s, g i
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem CompleteLattice.setIndependent_iff_finite {s : Set α} :
    CompleteLattice.SetIndependent s ↔
      ∀ t : Finset α, ↑t ⊆ s → CompleteLattice.SetIndependent (↑t : Set α)
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
/-- `trim` sends the supremum of two outer measures to the supremum of the trimmed measures. -/
theorem trim_sup (m₁ m₂ : OuterMeasure α) : (m₁ ⊔ m₂).trim = m₁.trim ⊔ m₂.trim
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- A product over all subsets of `s ∪ {x}` is obtained by multiplying the product over all subsets
of `s`, and over all subsets of `s` to which one adds `x`. -/
@[to_additive "A sum over all subsets of `s ∪ {x}` is obtained by summing the sum over all subsets
of `s`, and over all subsets of `s` to which one adds `x`."]
lemma prod_powerset_cons (ha : a ∉ s) (f : Finset α → β) :
    ∏ t ∈ (s.cons a ha).powerset, f t = (∏ t ∈ s.powerset, f t) *
      ∏ t ∈ s.powerset.attach, f (cons a t $ not_mem_mono (mem_powerset.1 t.2) ha)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
/-- An object `X` in a category is a *zero object* if for every object `Y`
there is a unique morphism `to : X → Y` and a unique morphism `from : Y → X`.

This is a characteristic predicate for `has_zero_object`. -/
structure IsZero (X : C) : Prop where
  /-- there are unique morphisms to the object -/
  unique_to : ∀ Y, Nonempty (Unique (X ⟶ Y))
  /-- there are unique morphisms from the object -/
  unique_from : ∀ Y, Nonempty (Unique (Y ⟶ X))
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.hasBasis_self_subset {p : Set α → Prop} (h : l.HasBasis (fun s => s ∈ l ∧ p s) id)
    {V : Set α} (hV : V ∈ l) : l.HasBasis (fun s => s ∈ l ∧ p s ∧ s ⊆ V) id
-- Mathlib/CategoryTheory/Comma/Basic.lean
@[simp]
theorem comp_right : (f ≫ g).right = f.right ≫ g.right
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem ext_iff {x y : ZFSet.{u}} : x = y ↔ ∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem starLift_range (f : A →⋆ₙₐ[R] C) :
    (starLift f).range = StarAlgebra.adjoin R (NonUnitalStarAlgHom.range f : Set C)
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- The backward direction for `functorProdFunctorEquiv` -/
@[simps]
def functorProdToProdFunctor : (A ⥤ B × C) ⥤ (A ⥤ B) × (A ⥤ C)
-- Mathlib/Data/Int/GCD.lean
lemma pow_mem_range_pow_of_coprime (hmn : m.Coprime n) (a : α) :
    a ^ m ∈ Set.range (· ^ n : α → α) ↔ a ∈ Set.range (· ^ n : α → α)
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma predAbove_castSucc_self (p : Fin n) : p.predAbove (castSucc p) = p
-- Mathlib/Order/Concept.lean
@[simp]
theorem intentClosure_iUnion (f : ι → Set α) :
    intentClosure r (⋃ i, f i) = ⋂ i, intentClosure r (f i)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem lt_subset_interior_le (hf : Continuous f) (hg : Continuous g) :
    { b | f b < g b } ⊆ interior { b | f b ≤ g b }
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
lemma evaluation_coevaluation :
    η_ _ _ ▷ X ≫ (α_ _ _ _).hom ≫ X ◁ ε_ _ Y = (λ_ X).hom ≫ (ρ_ X).inv
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma Affine.CoordinateRing.mk_ψ₂_sq : mk W W.ψ₂ ^ 2 = mk W (C W.Ψ₂Sq)
-- Mathlib/Data/Real/GoldenRatio.lean
theorem gold_pow_sub_gold_pow (n : ℕ) : φ ^ (n + 2) - φ ^ (n + 1) = φ ^ n
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_eq_of_countable_range (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) (i : ι) : MeasurableSet[f i] {ω | τ ω = i}
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem subtypeDomain_not_piecewise (f : Subtype P →₀ M) (g : {a // ¬ P a} →₀ M) :
    subtypeDomain (¬P ·) (f.piecewise g) = g
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ico_diff_Ico_left (a b c : α) : Ico a b \ Ico a c = Ico (max a c) b
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem Nat.cauchy_induction (seed : ℕ) (hs : P seed) (f : ℕ → ℕ)
    (hf : ∀ x, seed ≤ x → P x → x < f x ∧ P (f x)) (n : ℕ) : P n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem nonneg_or_nonneg_neg : ∀ (a : Int), NonNeg a ∨ NonNeg (-a)
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
/-- `eval` is a multiplicative homomorphism except when a denominator evaluates to `0`.

Counterexample: `eval _ 0 X * eval _ 0 (1/X) = 0 ≠ 1 = eval _ 0 1 = eval _ 0 (X * 1/X)`.

See also `RatFunc.eval₂_denom_ne_zero` to make the hypotheses simpler but less general.
-/
theorem eval_mul {x y : RatFunc K} (hx : Polynomial.eval₂ f a (denom x) ≠ 0)
    (hy : Polynomial.eval₂ f a (denom y) ≠ 0) : eval f a (x * y) = eval f a x * eval f a y
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem closure_sUnion (s : Set (Set R)) : closure (⋃₀ s) = ⨆ t ∈ s, closure t
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_sdiff : a ∈ s \ t ↔ a ∈ s ∧ a ∉ t
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem prod_const (ι : Type u) (a : Cardinal.{v}) :
    (prod fun _ : ι => a) = lift.{u} a ^ lift.{v} #ι
-- Mathlib/Data/Matroid/IndepAxioms.lean
@[simp] theorem ofFinite_indep {E : Set α} hE Indep indep_empty indep_subset indep_aug
    subset_ground : (IndepMatroid.ofFinite
      (hE : E.Finite) Indep indep_empty indep_subset indep_aug subset_ground).Indep = Indep
-- Mathlib/Data/Set/Card.lean
theorem encard_strictMono [Finite α] : StrictMono (encard : Set α → ℕ∞)
-- Mathlib/RingTheory/Flat/CategoryTheory.lean
lemma lTensor_shortComplex_exact [Flat R M] (C : ShortComplex $ ModuleCat R) (hC : C.Exact) :
    C.map (tensorLeft M) |>.Exact
-- Mathlib/Data/Set/Sups.lean
@[simp]
theorem singleton_infs : {a} ⊼ t = t.image fun b => a ⊓ b
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
@[simp] theorem fst_zero : fst (0 : Measure (α × β)) = 0
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[reassoc]
lemma L₀X₂ToP_comp_φ₁ : S.L₀X₂ToP ≫ S.φ₁ = 0
-- Mathlib/Topology/MetricSpace/Gluing.lean
/-- The map `toInductiveLimit n` mapping `X n` to the inductive limit is an isometry. -/
theorem toInductiveLimit_isometry (I : ∀ n, Isometry (f n)) (n : ℕ) :
    Isometry (toInductiveLimit I n)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
/-- If A is an R-algebra all of whose elements are integral over R,
and B is an A-algebra all of whose elements are integral over A,
then all elements of B are integral over R. -/
protected theorem Algebra.IsIntegral.trans
    [Algebra.IsIntegral R A] [Algebra.IsIntegral A B] : Algebra.IsIntegral R B
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem id_apply (a : α) : PseudoEpimorphism.id α a = a
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem IsLUB.mul_left {s : Set α} (ha : 0 ≤ a) (hs : IsLUB s b) :
    IsLUB ((fun b => a * b) '' s) (a * b)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
/-- Closure of a subring `S` equals `S`. -/
theorem closure_eq (s : Subring R) : closure (s : Set R) = s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem cos_sub_pi_div_two (θ : Angle) : cos (θ - ↑(π / 2)) = sin θ
-- Mathlib/Init/Algebra/Classes.lean
theorem not_lt_of_equiv {a b : α} : a ≈ b → ¬a ≺ b
-- Mathlib/Topology/Basic.lean
@[simp]
theorem interior_compl : interior sᶜ = (closure s)ᶜ
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[ext]
theorem ext {x y : tsze R M} (h1 : x.fst = y.fst) (h2 : x.snd = y.snd) : x = y
-- Mathlib/Data/Complex/Exponential.lean
lemma exp_abs_le (x : ℝ) : exp |x| ≤ exp x + exp (-x)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem indicator_ae_eq_restrict_compl (hs : MeasurableSet s) :
    indicator s f =ᵐ[μ.restrict sᶜ] 0
-- Mathlib/Probability/Independence/Kernel.lean
protected lemma iIndepFun.iIndep (hf : iIndepFun mβ f κ μ) :
    iIndep (fun x ↦ (mβ x).comap (f x)) κ μ
-- Mathlib/Data/Int/Defs.lean
@[simp, nolint simpNF]
protected lemma sub_nonneg : 0 ≤ a - b ↔ b ≤ a
-- Mathlib/Combinatorics/Additive/AP/Three/Defs.lean
@[to_additive (attr := simp)]
theorem mulRothNumber_empty : mulRothNumber (∅ : Finset α) = 0
-- Mathlib/Algebra/Module/Submodule/Range.lean
theorem range_toAddSubgroup [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) :
    (range f).toAddSubgroup = f.toAddMonoidHom.range
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem gcd_image [DecidableEq β] {g : γ → β} (s : Finset γ) :
    (s.image g).gcd f = s.gcd (f ∘ g)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderiv_add (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    fderiv 𝕜 (fun y => f y + g y) x = fderiv 𝕜 f x + fderiv 𝕜 g x
-- Mathlib/CategoryTheory/Adjunction/Limits.lean
theorem hasLimit_comp_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimit K] : HasLimit (K ⋙ E)
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
@[simp]
lemma sectionsMap_id {M : PresheafOfModules.{v} R} (s : M.sections) :
    sectionsMap (𝟙 M) s = s
-- Mathlib/Order/Filter/Basic.lean
theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set α} (h₁ : s ∈ l₁)
    (h₂ : s ∈ l₂) (hinj : InjOn f s) : map f l₁ ≤ map f l₂ ↔ l₁ ≤ l₂
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
@[simp]
theorem coe_finsupport : (ρ.finsupport x₀ : Set ι) = support fun i ↦ ρ i x₀
-- Mathlib/Topology/Sheaves/Functors.lean
@[simp] lemma pushforward_obj_val (f : X ⟶ Y) (F : X.Sheaf C) :
    ((pushforward C f).obj F).1 = f _* F.1
-- Mathlib/Analysis/Normed/Operator/Banach.lean
@[simp]
theorem ofBijective_apply_symm_apply (f : E →SL[σ] F) (hinj : ker f = ⊥)
    (hsurj : LinearMap.range f = ⊤) (y : F) : f ((ofBijective f hinj hsurj).symm y) = y
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem arccos_le_pi_div_two {x} : arccos x ≤ π / 2 ↔ 0 ≤ x
-- Mathlib/CategoryTheory/Shift/ShiftSequence.lean
@[reassoc]
lemma shiftMap_comp' {X Y Z : C} {n : M} (f : X ⟶ Y) (g : Y ⟶ Z⟦n⟧) (a a' : M) (ha' : n + a = a') :
    F.shiftMap (f ≫ g) a a' ha' = (F.shift a).map f ≫ F.shiftMap g a a' ha'
-- Mathlib/Data/Sum/Basic.lean
@[simp]
theorem update_inr_comp_inl [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : β} {x : γ} :
    update f (inr i) x ∘ inl = f ∘ inl
-- Mathlib/Data/Rel.lean
theorem image_preimage_subset_inter_codom (s : Set β) : s ∩ r.codom ⊆ r.image (r.preimage s)
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem PairwiseDisjoint.prod {f : ι → Set α} {g : ι' → Set β} (hs : s.PairwiseDisjoint f)
    (ht : t.PairwiseDisjoint g) :
    (s ×ˢ t : Set (ι × ι')).PairwiseDisjoint fun i => f i.1 ×ˢ g i.2
-- Mathlib/Algebra/Lie/OfAssociative.lean
@[simp]
theorem toLieEquiv_symm_apply (x : A₂) : e.toLieEquiv.symm x = e.symm x
-- Mathlib/Computability/Primrec.lean
theorem _root_.PrimrecPred.not {p : α → Prop} [DecidablePred p] (hp : PrimrecPred p) :
    PrimrecPred fun a => ¬p a
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem mem_think (s : WSeq α) (a) : a ∈ think s ↔ a ∈ s
-- Mathlib/Topology/Constructions.lean
theorem Quotient.preimage_mem_nhds [TopologicalSpace X] [s : Setoid X] {V : Set <| Quotient s}
    {x : X} (hs : V ∈ 𝓝 (Quotient.mk' x)) : Quotient.mk' ⁻¹' V ∈ 𝓝 x
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem aeval_X_left_apply (p : MvPolynomial σ R) : aeval X p = p
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem mem_toSubmonoid {s : Subsemiring R} {x : R} : x ∈ s.toSubmonoid ↔ x ∈ s
-- Mathlib/Data/Part.lean
@[to_additive]
theorem left_dom_of_mul_dom [Mul α] {a b : Part α} (hab : Dom (a * b)) : a.Dom
-- Mathlib/Data/Finset/Lattice.lean
theorem isLUB_iff_isGreatest [LinearOrder α] (i : α) (s : Finset α) (hs : s.Nonempty) :
    IsLUB (s : Set α) i ↔ IsGreatest (↑s) i
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem isBounded_const (ι' : Type*) [Nonempty ι'] {p : ι → Seminorm 𝕜 E} {q : Seminorm 𝕜₂ F}
    (f : E →ₛₗ[σ₁₂] F) :
    IsBounded p (fun _ : ι' => q) f ↔ ∃ (s : Finset ι) (C : ℝ≥0), q.comp f ≤ C • s.sup p
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
/-- The complex power function `x ↦ x^s` is integrable on `(0, t)` iff `-1 < s.re`. -/
theorem integrableOn_Ioo_cpow_iff {s : ℂ} {t : ℝ} (ht : 0 < t) :
    IntegrableOn (fun x : ℝ ↦ (x : ℂ) ^ s) (Ioo (0 : ℝ) t) ↔ -1 < s.re
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toRelIsoLT_symm (e : α ≃o β) : e.toRelIsoLT.symm = e.symm.toRelIsoLT
-- Mathlib/RepresentationTheory/Rep.lean
theorem repOfTprodIso_inv_apply (x : TensorProduct k V W) : (repOfTprodIso ρ τ).inv.hom x = x
-- Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean
theorem antilipschitz_of_bound (f : E →SL[σ] F) {K : ℝ≥0} (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) :
    AntilipschitzWith K f
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_right_inj (hba : b ≤ a) (hca : c ≤ a) : a - b = a - c ↔ b = c
-- Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean
@[simp]
theorem toNonneg_coe {a : { x : α // 0 ≤ x }} : toNonneg (a : α) = a
-- Mathlib/Algebra/Algebra/Equiv.lean
theorem toLinearMap_ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    (ofAlgHom f g h₁ h₂).toLinearMap = f.toLinearMap
-- Mathlib/Deprecated/Group.lean
theorem map_mul' : ∀ x y, f (x * y) = f x * f y
-- Mathlib/Analysis/Normed/Group/Quotient.lean
theorem IsQuotient.norm_le {f : NormedAddGroupHom M N} (hquot : IsQuotient f) (m : M) :
    ‖f m‖ ≤ ‖m‖
-- Mathlib/Logic/Equiv/Option.lean
theorem removeNone_aux_some {x : α} (h : ∃ x', e (some x) = some x') :
    some (removeNone_aux e x) = e (some x)
-- Mathlib/Topology/Clopen.lean
theorem Set.Finite.isClopen_biUnion {s : Set Y} {f : Y → Set X} (hs : s.Finite)
    (h : ∀ i ∈ s, IsClopen <| f i) : IsClopen (⋃ i ∈ s, f i)
-- Mathlib/Topology/Instances/Matrix.lean
/-- To show a function into matrices is continuous it suffices to show the coefficients of the
resulting matrix are continuous -/
@[continuity]
theorem continuous_matrix [TopologicalSpace α] {f : α → Matrix m n R}
    (h : ∀ i j, Continuous fun a => f a i j) : Continuous f
-- Mathlib/Analysis/CstarAlgebra/Matrix.lean
lemma coe_toEuclideanCLM_eq_toEuclideanLin (A : Matrix n n 𝕜) :
    (toEuclideanCLM (n := n) (𝕜 := 𝕜) A : _ →ₗ[𝕜] _) = toEuclideanLin A
-- Mathlib/CategoryTheory/Monad/Basic.lean
/-- Construct a monad isomorphism from a natural isomorphism of functors where the forward
direction is a monad morphism. -/
@[simps]
def MonadIso.mk {M N : Monad C} (f : (M : C ⥤ C) ≅ N)
    (f_η : ∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X := by aesop_cat)
    (f_μ : ∀ (X : C), M.μ.app X ≫ f.hom.app X =
    (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X := by aesop_cat) : M ≅ N
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Mod.lean
theorem mod_pow_succ {x b k : Nat} :
    x % b ^ (k + 1) = x % b ^ k + b ^ k * ((x / b ^ k) % b)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- A compact subset has finite measure for a measure which is finite on compacts. -/
theorem _root_.IsCompact.measure_lt_top [TopologicalSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] ⦃K : Set α⦄ (hK : IsCompact K) : μ K < ∞
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem lift'_mk (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (m : M) (s : S) :
    LocalizedModule.lift' S g h (LocalizedModule.mk m s) = (h s).unit⁻¹.val (g m)
-- Mathlib/Data/Nat/Cast/Commute.lean
theorem _root_.Commute.ofNat_right (x : α) (n : ℕ) [n.AtLeastTwo] : Commute x (OfNat.ofNat n)
-- Mathlib/Data/Matrix/Basis.lean
theorem diag_eq_of_commute_stdBasisMatrix {i j : n} {M : Matrix n n α}
    (hM : Commute (stdBasisMatrix i j 1) M) : M i i = M j j
-- Mathlib/Algebra/DirectSum/Internal.lean
theorem coe_mul_of_apply_aux [AddMonoid ι] [SetLike.GradedMonoid A] (r : ⨁ i, A i) {i : ι}
    (r' : A i) {j n : ι} (H : ∀ x : ι, x + i = n ↔ x = j) :
    ((r * of (fun i => A i) i r') n : R) = r j * r'
-- Mathlib/Topology/UnitInterval.lean
theorem coe_ne_zero {x : I} : (x : ℝ) ≠ 0 ↔ x ≠ 0
-- Mathlib/Data/Finset/Sym.lean
theorem sym_fill_mem (a : α) {i : Fin (n + 1)} {m : Sym α (n - i)} (h : m ∈ s.sym (n - i)) :
    m.fill a i ∈ (insert a s).sym n
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
@[simp]
protected theorem nonempty (C : G.ComponentCompl K) : (C : Set V).Nonempty
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem Integrable.of_integral_ne_zero {f : α → G} (h : ∫ a, f a ∂μ ≠ 0) : Integrable f μ
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem mul_div_root_cancel [Fact (Irreducible f)] :
    (X - C (root f)) * ((f.map (of f)) / (X - C (root f))) = f.map (of f)
-- Mathlib/Probability/Martingale/Basic.lean
theorem martingale_zero (ℱ : Filtration ι m0) (μ : Measure Ω) : Martingale (0 : ι → Ω → E) ℱ μ
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem coeff_X_add_C_pow (r : R) (n k : ℕ) :
    ((X + C r) ^ n).coeff k = r ^ (n - k) * (n.choose k : R)
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem span_span_coe_preimage : span R (((↑) : span R s → M) ⁻¹' s) = ⊤
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- *Dirichlet's approximation theorem:*
For any real number `ξ` and positive natural `n`, there is a fraction `q`
such that `q.den ≤ n` and `|ξ - q| ≤ 1/((n+1)*q.den)`.

See also `AddCircle.exists_norm_nsmul_le`. -/
theorem exists_rat_abs_sub_le_and_den_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) :
    ∃ q : ℚ, |ξ - q| ≤ 1 / ((n + 1) * q.den) ∧ q.den ≤ n
-- Mathlib/Data/Multiset/Basic.lean
theorem card_erase_eq_ite {a : α} {s : Multiset α} :
    card (s.erase a) = if a ∈ s then pred (card s) else card s
-- Mathlib/RingTheory/Ideal/Norm.lean
theorem finite_setOf_absNorm_eq [CharZero S] {n : ℕ} (hn : 0 < n) :
    {I : Ideal S | Ideal.absNorm I = n}.Finite
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem subset_pointwise_smul_iff {a : M} {S T : Subsemiring R} : S ≤ a • T ↔ a⁻¹ • S ≤ T
-- Mathlib/Analysis/Calculus/Deriv/Inverse.lean
theorem HasDerivAt.tendsto_punctured_nhds (h : HasDerivAt f f' x) (hf' : f' ≠ 0) :
    Tendsto f (𝓝[≠] x) (𝓝[≠] f x)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem symm_continuousWithinAt_comp_right_iff {X} [TopologicalSpace X] {f : H → X} {s : Set H}
    {x : H} :
    ContinuousWithinAt (f ∘ I.symm) (I.symm ⁻¹' s ∩ range I) (I x) ↔ ContinuousWithinAt f s x
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem pointwise_smul_subset_iff {a : α} {S T : Subgroup G} : a • S ≤ T ↔ S ≤ a⁻¹ • T
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙHom_id :
    cfcₙHom ha ⟨(ContinuousMap.id R).restrict <| σₙ R a, rfl⟩ = a
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp] lemma ceilDiv_apply (f : ∀ i, π i) (a : α) (i : ι) : (f ⌈/⌉ a) i = f i ⌈/⌉ a
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- A non-unital subring is closed under negation. -/
protected theorem neg_mem {x : R} : x ∈ s → -x ∈ s
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.balanceL {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r') :
    Valid' o₁ (@balanceL α l x r) o₂
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_sub_right_of_add_le {a b c : Int} (h : a + b ≤ c) : a ≤ c - b
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- The angle between three points is zero if and only if one of the first and third points is
strictly between the other two, or those two points are equal but not equal to the second. -/
theorem angle_eq_zero_iff_eq_and_ne_or_sbtw {p₁ p₂ p₃ : P} :
    ∠ p₁ p₂ p₃ = 0 ↔ p₁ = p₃ ∧ p₁ ≠ p₂ ∨ Sbtw ℝ p₂ p₁ p₃ ∨ Sbtw ℝ p₂ p₃ p₁
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem measurableSet_eq_fun {m : MeasurableSpace α} {E} [TopologicalSpace E] [MetrizableSpace E]
    {f g : α → E} (hf : StronglyMeasurable f) (hg : StronglyMeasurable g) :
    MeasurableSet { x | f x = g x }
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem ker_le_comap {K : Ideal S} (f : F) : RingHom.ker f ≤ comap f K
-- Mathlib/Order/Directed.lean
/-- A set stable by infimum is `≥`-directed. -/
theorem directedOn_of_inf_mem [SemilatticeInf α] {S : Set α}
    (H : ∀ ⦃i j⦄, i ∈ S → j ∈ S → i ⊓ j ∈ S) : DirectedOn (· ≥ ·) S
-- Mathlib/Algebra/Lie/Submodule.lean
theorem map_inf_le : (N ⊓ N₂).map f ≤ N.map f ⊓ N₂.map f
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_coe_le_of_lintegral_coe_le {f : α → ℝ≥0} {b : ℝ≥0} (h : ∫⁻ a, f a ∂μ ≤ b) :
    ∫ a, (f a : ℝ) ∂μ ≤ b
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem ofConjAct_one : ofConjAct (1 : ConjAct G) = 1
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem isAdjointPair_toBilin' [DecidableEq n] :
    BilinForm.IsAdjointPair (Matrix.toBilin' J) (Matrix.toBilin' J₃) (Matrix.toLin' A)
        (Matrix.toLin' A') ↔
      Matrix.IsAdjointPair J J₃ A A'
-- Mathlib/Dynamics/PeriodicPts.lean
/-- If `f` sends two periodic points `x` and `y` of the same positive period to the same point,
then `x = y`. For a similar statement about points of different periods see `eq_of_apply_eq`. -/
theorem eq_of_apply_eq_same (hx : IsPeriodicPt f n x) (hy : IsPeriodicPt f n y) (hn : 0 < n)
    (h : f x = f y) : x = y
-- Mathlib/CategoryTheory/Sites/Spaces.lean
/-- The pretopology associated to a space induces the Grothendieck topology associated to the space.
-/
@[simp]
theorem pretopology_toGrothendieck :
    Pretopology.toGrothendieck _ (Opens.pretopology T) = Opens.grothendieckTopology T
-- Mathlib/Order/LiminfLimsup.lean
theorem liminf_compl : (liminf u f)ᶜ = limsup (compl ∘ u) f
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_neg_Ioc : Neg.neg '' Ioc a b = Ico (-b) (-a)
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H b} :
    b ∈ pmap f l H ↔ ∃ (a : _) (h : a ∈ l), f a (H a h) = b
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem submodule_span_le_lieSpan : Submodule.span R s ≤ lieSpan R L s
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem hnot_bot : ￢(⊥ : α) = ⊤
-- Mathlib/Algebra/Star/Basic.lean
/-- `star` as an `AddEquiv` -/
@[simps apply]
def starAddEquiv [AddMonoid R] [StarAddMonoid R] : R ≃+ R
-- Mathlib/Order/Filter/Bases.lean
theorem _root_.Set.PairwiseDisjoint.exists_mem_filter_basis {I : Type*} {l : I → Filter α}
    {ι : I → Sort*} {p : ∀ i, ι i → Prop} {s : ∀ i, ι i → Set α} {S : Set I}
    (hd : S.PairwiseDisjoint l) (hS : S.Finite) (h : ∀ i, (l i).HasBasis (p i) (s i)) :
    ∃ ind : ∀ i, ι i, (∀ i, p i (ind i)) ∧ S.PairwiseDisjoint fun i => s i (ind i)
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem Finset.prod_dvd_of_coprime :
    (t : Set I).Pairwise (IsCoprime on s) → (∀ i ∈ t, s i ∣ z) → (∏ x ∈ t, s x) ∣ z
-- Mathlib/Order/Minimal.lean
theorem RelEmbedding.maximals_preimage_eq (f : r ↪r s) (y : Set β) :
    maximals r (f ⁻¹' y) = f ⁻¹' maximals s (y ∩ range f)
-- Mathlib/Data/Finsupp/Pointwise.lean
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc]
lemma d_sndX (i j : ι) (hij : c.Rel i j) :
    d φ i j ≫ sndX φ j = fstX φ i j hij ≫ φ.f j + sndX φ i ≫ G.d i j
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
@[simp]
theorem mk_mul (f g : CauSeq β abv) : mk f * mk g = mk (f * g)
-- Mathlib/Analysis/Complex/AbsMax.lean
/-- **Maximum modulus principle**: if `f : E → F` is complex differentiable on a nonempty bounded
set `U` and is continuous on its closure, then there exists a point `z ∈ frontier U` such that
`(‖f ·‖)` takes it maximum value on `closure U` at `z`. -/
theorem exists_mem_frontier_isMaxOn_norm [FiniteDimensional ℂ E] {f : E → F} {U : Set E}
    (hb : IsBounded U) (hne : U.Nonempty) (hd : DiffContOnCl ℂ f U) :
    ∃ z ∈ frontier U, IsMaxOn (norm ∘ f) (closure U) z
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_equiv_of_lift_eq (leq : lift.{v} #α = lift.{u} #β') : #(α ≃ β') = 2 ^ lift.{v} #α