ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
@[simp]
theorem toTensorAlgebra_galgebra_toFun (r : R) :
    TensorPower.toTensorAlgebra (DirectSum.GAlgebra.toFun (R := R) (A := fun n => ⨂[R]^n M) r) =
      algebraMap _ _ r
-- Mathlib/NumberTheory/Divisors.lean
theorem perfect_iff_sum_properDivisors (h : 0 < n) : Perfect n ↔ ∑ i ∈ properDivisors n, i = n
-- Mathlib/Algebra/CharP/Defs.lean
lemma char_is_prime_of_two_le (p : ℕ) [hc : CharP R p] (hp : 2 ≤ p) : Nat.Prime p
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem self_comp_symm : e ∘ e.symm = id
-- Mathlib/CategoryTheory/Monoidal/Cartesian/Comon_.lean
/--
Every comonoid object in a cartesian monoidal category is equivalent to
the canonical comonoid structure on the underlying object.
-/
@[simps] def iso_cartesianComon_ (A : Comon_ C) : A ≅ (cartesianComon_ C).obj A.X
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem toFun_eq_coe {f : α →ᵈ β} : f.toFun = (f : α → β)
-- Mathlib/Data/Matroid/Closure.lean
lemma basis'_iff_basis_closure : M.Basis' I X ↔ M.Basis I (M.closure X) ∧ I ⊆ X
-- Mathlib/RingTheory/WittVector/Basic.lean
private lemma ghostFun_zsmul (m : ℤ) (x : WittVector p R) : ghostFun (m • x) = m • ghostFun x
-- Mathlib/Dynamics/Minimal.lean
@[to_additive]
theorem IsOpen.iUnion_preimage_smul [IsMinimal M α] {U : Set α} (hUo : IsOpen U)
    (hne : U.Nonempty) : ⋃ c : M, (c • ·) ⁻¹' U = univ
-- Mathlib/Combinatorics/Colex.lean
lemma insert_lt_insert (ha : a ∉ s) (hb : b ∉ s) :
    toColex (insert a s) < toColex (insert b s) ↔ a < b
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive]
theorem mul_bot : s * ⊥ = ⊥
-- Mathlib/GroupTheory/GroupAction/FixingSubgroup.lean
theorem mem_fixingSubgroup_iff_subset_fixedBy {s : Set α} {m : M} :
    m ∈ fixingSubgroup M s ↔ s ⊆ fixedBy α m
-- Mathlib/SetTheory/Surreal/Basic.lean
/-- Ordinal games are numeric. -/
theorem numeric_toPGame (o : Ordinal) : o.toPGame.Numeric
-- Mathlib/Data/Set/Basic.lean
theorem diff_subset_compl (s t : Set α) : s \ t ⊆ tᶜ
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem find?_nil : ([] : List α).find? p = none
-- Mathlib/Algebra/Group/Even.lean
@[simp]
lemma even_toAdd_iff {a : Multiplicative α} : Even (Multiplicative.toAdd a) ↔ IsSquare a
-- Mathlib/Order/SupClosed.lean
lemma IsSublattice_range [FunLike F α β] [LatticeHomClass F α β] (f : F) :
    IsSublattice (Set.range f)
-- Mathlib/Data/Finset/Basic.lean
theorem subset_iff {s₁ s₂ : Finset α} : s₁ ⊆ s₂ ↔ ∀ ⦃x⦄, x ∈ s₁ → x ∈ s₂
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem inclusion_refl {S : Subgroupoid C} : inclusion (le_refl S) = 𝟭 S.objs
-- Mathlib/NumberTheory/NumberField/Discriminant.lean
theorem exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧
      |Algebra.norm ℚ (a : K)| ≤ FractionalIdeal.absNorm I.1 * (4 / π) ^ NrComplexPlaces K *
        (finrank ℚ K).factorial / (finrank ℚ K) ^ (finrank ℚ K) * Real.sqrt |discr K|
-- Mathlib/Data/Num/Lemmas.lean
theorem succ_to_nat (n) : (succ n : ℕ) = n + 1
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem closedBall_subset_cthickening_singleton {α : Type*} [PseudoMetricSpace α] (x : α) (δ : ℝ) :
    closedBall x δ ⊆ cthickening δ ({x} : Set α)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem isUnit_iff_ne_zero : IsUnit a ↔ a ≠ 0
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_sdiff_sup_sdiff' : z \ (x \ y ⊔ y \ x) = z ⊓ x ⊓ y ⊔ z \ x ⊓ z \ y
-- Mathlib/Topology/ContinuousOn.lean
theorem tendsto_nhdsWithin_of_tendsto_nhds {f : α → β} {a : α} {s : Set α} {l : Filter β}
    (h : Tendsto f (𝓝 a) l) : Tendsto f (𝓝[s] a) l
-- Mathlib/Data/List/OfFn.lean
@[simp]
theorem ofFn_const : ∀ (n : ℕ) (c : α), (ofFn fun _ : Fin n => c) = replicate n c
-- Mathlib/ModelTheory/Algebra/Field/Basic.lean
theorem FieldAxiom.toProp_of_model {K : Type*}
    [Add K] [Mul K] [Neg K] [Zero K] [One K] [CompatibleRing K]
    [Theory.field.Model K] (ax : FieldAxiom) : ax.toProp K
-- Mathlib/Data/List/Basic.lean
theorem getElem_reverse_aux₂ :
    ∀ (l r : List α) (i : Nat) (h1) (h2),
      (reverseAux l r)[length l - 1 - i]'h1 = l[i]'h2
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem one_le_pi_div_two : (1 : ℝ) ≤ π / 2
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem tensorLeftTensor_inv_app (X Y Z : C) :
    (tensorLeftTensor X Y).inv.app Z = (associator X Y Z).inv
-- Mathlib/Data/PNat/Basic.lean
theorem pos_of_div_pos {n : ℕ+} {a : ℕ} (h : a ∣ n) : 0 < a
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem norm_deriv_eq_norm_fderiv : ‖deriv f x‖ = ‖fderiv 𝕜 f x‖
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.cPolynomialOn (hf : HasFiniteFPowerSeriesOnBall f p x n r) :
    CPolynomialOn 𝕜 f (EMetric.ball x r)
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean
private theorem isRoot_cyclotomic_iff' {n : ℕ} {K : Type*} [Field K] {μ : K} [NeZero (n : K)] :
    IsRoot (cyclotomic n K) μ ↔ IsPrimitiveRoot μ n
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem lmul'_comp_includeLeft : (lmul' R : _ →ₐ[R] S).comp includeLeft = AlgHom.id R S
-- Mathlib/Analysis/Seminorm.lean
/-- A seminorm is uniformly continuous if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.uniformContinuous'`. -/
protected theorem uniformContinuous_of_forall' [UniformSpace E] [UniformAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    UniformContinuous p
-- Mathlib/Data/Set/Sigma.lean
theorem forall_sigma_iff {p : (Σ i, α i) → Prop} :
    (∀ x ∈ s.sigma t, p x) ↔ ∀ ⦃i⦄, i ∈ s → ∀ ⦃a⦄, a ∈ t i → p ⟨i, a⟩
-- Mathlib/Data/Int/Defs.lean
protected lemma add_nonnneg_iff_neg_le' : 0 ≤ a + b ↔ -a ≤ b
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem eq_nil_of_map_eq_nil {f : α → β} {l : List α} (h : map f l = []) : l = []
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffWithinAt.div_const {f : E → 𝕜'} {n} (hf : ContDiffWithinAt 𝕜 n f s x) (c : 𝕜') :
    ContDiffWithinAt 𝕜 n (fun x => f x / c) s x
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem coe_prodUnique [Unique β] : (⇑(prodUnique α β) : α × β → α) = Prod.fst
-- Mathlib/Topology/Separation.lean
theorem SeparatedNhds.of_singleton_finset [T2Space X] {x : X} {s : Finset X} (h : x ∉ s) :
    SeparatedNhds ({x} : Set X) s
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integrableOn_Ioi_exp_neg_mul_sq_iff {b : ℝ} :
    IntegrableOn (fun x : ℝ => exp (-b * x ^ 2)) (Ioi 0) ↔ 0 < b
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- Coercing a subspace to a set then taking the affine span produces the original subspace. -/
@[simp]
theorem affineSpan_coe (s : AffineSubspace k P) : affineSpan k (s : Set P) = s
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_eq (hb : 0 ≤ b) : |a| = b ↔ a = b ∨ a = -b
-- Mathlib/Data/List/DropRight.lean
lemma rdrop_add (i j : ℕ) : (l.rdrop i).rdrop j = l.rdrop (i + j)
-- Mathlib/CategoryTheory/Generator.lean
theorem isDetector_op_iff (G : C) : IsDetector (op G) ↔ IsCodetector G
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
@[reassoc]
theorem gluedLiftPullbackMap_fst (i j : 𝒰.J) :
    gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫
        (pullbackSymmetry _ _).hom ≫
          pullback.map _ _ _ _ (𝟙 _) s.snd f (Category.id_comp _).symm s.condition
-- Mathlib/Control/Traversable/Instances.lean
protected theorem traverse_map {α β γ : Type u} (g : α → β) (f : β → G γ) (x : σ ⊕ α) :
    Sum.traverse f (g <$> x) = Sum.traverse (f ∘ g) x
-- Mathlib/Logic/Small/Group.lean
@[to_additive existing (attr := simp)]
lemma equivShrink_symm_one [One α] [Small α] : (equivShrink α).symm 1 = 1
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map₂Left'_nil_right (f : α → Option β → γ) (as) :
    map₂Left' f as [] = (as.map fun a => f a none, [])
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)] lemma f'_π : h.f' ≫ h.π = 0
-- Mathlib/Analysis/BoxIntegral/Basic.lean
theorem Integrable.neg (hf : Integrable I l f vol) : Integrable I l (-f) vol
-- Mathlib/Analysis/Calculus/Implicit.lean
theorem pt_mem_toPartialHomeomorph_source : φ.pt ∈ φ.toPartialHomeomorph.source
-- Mathlib/Topology/Partial.lean
theorem rtendsto_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
    RTendsto r l (𝓝 x) ↔ ∀ s, IsOpen s → x ∈ s → r.core s ∈ l
-- Mathlib/Data/Ordmap/Ordnode.lean
@[simp] theorem size_node (sz : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α) :
    size (node sz l x r) = sz
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[elab_as_elim]
theorem induction_on_irreducible {P : α → Prop} (a : α) (h0 : P 0) (hu : ∀ u : α, IsUnit u → P u)
    (hi : ∀ a i : α, a ≠ 0 → Irreducible i → P a → P (i * a)) : P a
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem isSome_none : @isSome α none = false
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem ediam_image (s : Set P) : EMetric.diam (e '' s) = EMetric.diam s
-- Mathlib/Order/CompleteLattice.lean
theorem OrderIso.map_sInf [CompleteLattice β] (f : α ≃o β) (s : Set α) :
    f (sInf s) = ⨅ a ∈ s, f a
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
@[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ pullback.fst _ _
-- Mathlib/Probability/Cdf.lean
@[simp] lemma MeasureTheory.Measure.cdf_eq_iff (μ ν : Measure ℝ) [IsProbabilityMeasure μ]
    [IsProbabilityMeasure ν] :
    cdf μ = cdf ν ↔ μ = ν
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
theorem restrict_le_self (m : OuterMeasure α) (s : Set α) : restrict s m ≤ m
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem subgroup_on_glpos_smul_apply (s : Γ) (g : GL(2, ℝ)⁺) (z : ℍ) :
    (s • g) • z = ((s : GL(2, ℝ)⁺) * g) • z
-- Mathlib/Tactic/NormNum/Ineq.lean
theorem isInt_lt_false [OrderedRing α] {a b : α} {a' b' : ℤ}
    (ha : IsInt a a') (hb : IsInt b b') (h : decide (b' ≤ a')) : ¬a < b
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem AddSubgroup.toIntSubmodule_toAddSubgroup (S : AddSubgroup M) :
    S.toIntSubmodule.toAddSubgroup = S
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_comp (g : BoundedLatticeHom βᵒᵈ γᵒᵈ) (f : BoundedLatticeHom αᵒᵈ βᵒᵈ) :
    BoundedLatticeHom.dual.symm (g.comp f) =
      (BoundedLatticeHom.dual.symm g).comp (BoundedLatticeHom.dual.symm f)
-- Mathlib/Data/List/MinMax.lean
theorem minimum_not_lt_of_mem : a ∈ l → (minimum l : WithTop α) = m → ¬a < m
-- Mathlib/CategoryTheory/Generator.lean
theorem IsSeparating.isDetecting [Balanced C] {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) :
    IsDetecting 𝒢
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
/-- Constant one function has product `1` -/
@[to_additive "Constant zero function has sum `0`"]
theorem hasProd_one : HasProd (fun _ ↦ 1 : β → α) 1
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- The valuation on the completion agrees with the global valuation on elements of the
integer ring. -/
theorem valuedAdicCompletion_eq_valuation (r : R) :
    Valued.v (r : v.adicCompletion K) = v.valuation (r : K)
-- Mathlib/Data/PFunctor/Univariate/M.lean
@[simp]
theorem head_mk (x : F (M F)) : head (M.mk x) = x.1
-- Mathlib/Data/List/Zip.lean
@[simp]
theorem revzip_map_fst (l : List α) : (revzip l).map Prod.fst = l
-- Mathlib/Algebra/Polynomial/EraseLead.lean
theorem natDegree_pos_of_eraseLead_ne_zero (h : f.eraseLead ≠ 0) : 0 < f.natDegree
-- Mathlib/Data/List/Sort.lean
/-- If `l` is already `List.Sorted` with respect to `r`, then `insertionSort` does not change
it. -/
theorem Sorted.insertionSort_eq : ∀ {l : List α}, Sorted r l → insertionSort r l = l
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem setLIntegral_preimage_condDistrib (hX : Measurable X) (hY : AEMeasurable Y μ)
    (hs : MeasurableSet s) (ht : MeasurableSet t) :
    ∫⁻ a in X ⁻¹' t, condDistrib Y X μ (X a) s ∂μ = μ (X ⁻¹' t ∩ Y ⁻¹' s)
-- Mathlib/RingTheory/Localization/Basic.lean
/-- See note [partially-applied ext lemmas] -/
theorem monoidHom_ext ⦃j k : S →* P⦄
    (h : j.comp (algebraMap R S : R →* S) = k.comp (algebraMap R S)) : j = k
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
theorem additive_of_preservesBinaryBiproducts [HasBinaryBiproducts C] [PreservesZeroMorphisms F]
    [PreservesBinaryBiproducts F] : Additive F
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem symm_apply_apply (e : P₁ ≃ᵃL[k] P₂) (p : P₁) : e.symm (e p) = p
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
@[simp]
theorem involute_e0 : involute (e0 Q) = -e0 Q
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_of_arrow_mk_iso (φ : S₁ ⟶ S₂) (φ' : S₃ ⟶ S₄) (e : Arrow.mk φ ≅ Arrow.mk φ')
    [hφ : QuasiIso φ] : QuasiIso φ'
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem singleton_inj {x y : ZFSet} : ({x} : ZFSet) = {y} ↔ x = y
-- Mathlib/Topology/Order/OrderClosed.lean
theorem not_tendsto_nhds_of_tendsto_atTop (hf : Tendsto f l atTop) (a : α) : ¬Tendsto f l (𝓝 a)
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma mul_div_mul_right (h : IsUnit c) (a b : α) : a * c / (b * c) = a / b
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem primPart_dvd (p : R[X]) : p.primPart ∣ p
-- Mathlib/Data/Matroid/Map.lean
lemma Indep.mapEmbedding (hI : M.Indep I) (f : α ↪ β) : (M.mapEmbedding f).Indep (f '' I)
-- Mathlib/Data/Seq/Computation.lean
/-- `Terminates s` asserts that the computation `s` eventually terminates with some value. -/
class Terminates (s : Computation α) : Prop where
  /-- assertion that there is some term `a` such that the `Computation` terminates -/
  term : ∃ a, a ∈ s
-- .lake/packages/lean4/src/lean/Init/Control/ExceptCps.lean
@[simp] theorem run_bind_lift [Monad m] (x : m α) (f : α → ExceptCpsT ε m β) : run (ExceptCpsT.lift x >>= f : ExceptCpsT ε m β) = x >>= fun a => run (f a)
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_pos' [LinearOrderedRing α] (hx : 0 < x + 1) (hn : n ≠ 0) :
    0 < ∑ i ∈ range n, x ^ i
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_add_of_neg_lt_sub_left {a b c : Int} (h : -a < b - c) : c < a + b
-- Mathlib/Tactic/CategoryTheory/BicategoricalComp.lean
@[simps]
instance left (f g : a ⟶ b) [BicategoricalCoherence f g] :
    BicategoricalCoherence (𝟙 a ≫ f) g
-- Mathlib/Analysis/Convex/Between.lean
theorem wbtw_or_wbtw_smul_vadd_of_nonpos (x : P) (v : V) {r₁ r₂ : R} (hr₁ : r₁ ≤ 0) (hr₂ : r₂ ≤ 0) :
    Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_equiv_eq_zero_iff_ne : #(α ≃ β) = 0 ↔ #α ≠ #β
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem edges_transfer (hp) : (p.transfer H hp).edges = p.edges
-- Mathlib/Algebra/Field/Basic.lean
@[field_simps]
theorem neg_div' (a b : K) : -(b / a) = -b / a
-- Mathlib/Algebra/Ring/Units.lean
@[simp, norm_cast]
protected theorem coe_neg_one : ((-1 : αˣ) : α) = -1
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem eraseP_cons_of_neg {l : List α} (p) (h : ¬p a) :
    (a :: l).eraseP p = a :: l.eraseP p
-- Mathlib/GroupTheory/Nilpotent.lean
/-- A group `G` is nilpotent if its upper central series is eventually `G`. -/
class Group.IsNilpotent (G : Type*) [Group G] : Prop where
  nilpotent' : ∃ n : ℕ, upperCentralSeries G n = ⊤
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerTMul_add (A : Matrix l m α) (B₁ B₂ : Matrix n p α) :
    A ⊗ₖₜ[R] (B₁ + B₂) = A ⊗ₖₜ B₁ + A ⊗ₖₜ B₂
-- Mathlib/CategoryTheory/Monad/Coequalizer.lean
/-- Construct the Beck cofork in the category of algebras. This cofork is reflexive as well as a
coequalizer.
-/
@[simps!]
def beckAlgebraCofork : Cofork (FreeCoequalizer.topMap X) (FreeCoequalizer.bottomMap X)
-- Mathlib/Data/Real/Pointwise.lean
theorem Real.mul_iInf_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (r * ⨅ i, f i) = ⨅ i, r * f i
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem induction_on [Semiring k] [Monoid G] {p : MonoidAlgebra k G → Prop} (f : MonoidAlgebra k G)
    (hM : ∀ g, p (of k G g)) (hadd : ∀ f g : MonoidAlgebra k G, p f → p g → p (f + g))
    (hsmul : ∀ (r : k) (f), p f → p (r • f)) : p f
-- Mathlib/FieldTheory/Adjoin.lean
theorem restrictScalars_adjoin (K : IntermediateField F E) (S : Set E) :
    restrictScalars F (adjoin K S) = adjoin F (K ∪ S)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem center_eq_top (R) [CommRing R] : center R = ⊤
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
    ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i)
-- Mathlib/Data/List/Sort.lean
theorem mergeSort_eq_insertionSort [IsAntisymm α r] (l : List α) :
    mergeSort r l = insertionSort r l
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem tendsto_indicator_ge (f : α → β) (x : α) :
    Tendsto (fun M : ℕ => { x | (M : ℝ) ≤ ‖f x‖₊ }.indicator f x) atTop (𝓝 0)
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem extend_coe [T2Space β] (hf : UniformContinuous f) (a : α) : (pkg.extend f) (ι a) = f a
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma intCast_im (n : ℤ) : (n : ℂ).im = 0
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := simp)]
theorem orbitRel.Quotient.orbit_mk (a : α) :
    orbitRel.Quotient.orbit (Quotient.mk'' a : orbitRel.Quotient G α) = MulAction.orbit G a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_neg {x : ℝ} (hx : 0 ≤ x) (y : ℝ) : x ^ (-y) = (x ^ y)⁻¹
-- Mathlib/Topology/Connected/Basic.lean
/-- A preconnected space is one where there is no non-trivial open partition. -/
class PreconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a preconnected space is a preconnected set. -/
  isPreconnected_univ : IsPreconnected (univ : Set α)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[congr]
theorem biUnion_congr (h : π₁ = π₂) (hi : ∀ J ∈ π₁, πi₁ J = πi₂ J) :
    π₁.biUnion πi₁ = π₂.biUnion πi₂
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If a set of functions is equicontinuous at some `x₀` within a set `S`, its closure for the
product topology is also equicontinuous at `x₀` within `S`. This would also be true for the coarser
topology of pointwise convergence on `S ∪ {x₀}`, see `Set.EquicontinuousWithinAt.closure'`. -/
protected theorem Set.EquicontinuousWithinAt.closure {A : Set (X → α)} {S : Set X} {x₀ : X}
    (hA : A.EquicontinuousWithinAt S x₀) :
    (closure A).EquicontinuousWithinAt S x₀
-- Mathlib/GroupTheory/Coxeter/Basic.lean
@[simp]
theorem length_alternatingWord (i i' : B) (m : ℕ) :
    List.length (alternatingWord i i' m) = m
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem coe_lpSubmodule : (lpSubmodule E p 𝕜).toAddSubgroup = lp E p
-- Mathlib/MeasureTheory/PiSystem.lean
theorem generateFrom_piiUnionInter_measurableSet (m : ι → MeasurableSpace α) (S : Set ι) :
    generateFrom (piiUnionInter (fun n => { s | MeasurableSet[m n] s }) S) = ⨆ i ∈ S, m i
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_ball {x : α} {r : ι → ℝ} (hr : Tendsto r l atTop) :
    AECover μ l (fun i ↦ Metric.ball x (r i))
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem sum_fin [AddCommMonoid S] (f : ℕ → R → S) (hf : ∀ i, f i 0 = 0) {n : ℕ} {p : R[X]}
    (hn : p.degree < n) : (∑ i : Fin n, f i (p.coeff i)) = p.sum f
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- Monotone convergence theorem for nonincreasing sequences of functions -/
theorem lintegral_iInf_ae {f : ℕ → α → ℝ≥0∞} (h_meas : ∀ n, Measurable (f n))
    (h_mono : ∀ n : ℕ, f n.succ ≤ᵐ[μ] f n) (h_fin : ∫⁻ a, f 0 a ∂μ ≠ ∞) :
    ∫⁻ a, ⨅ n, f n a ∂μ = ⨅ n, ∫⁻ a, f n a ∂μ
-- Mathlib/RingTheory/Localization/Basic.lean
theorem map_right_cancel {x y} {c : M} (h : algebraMap R S (c * x) = algebraMap R S (c * y)) :
    algebraMap R S x = algebraMap R S y
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (i : U ⟶ V) :
    s.pt.presheaf.map i ≫ descCApp F s V =
      descCApp F s U ≫
        (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s) _* (colimitCocone F).pt.presheaf).map
          i
-- Mathlib/Order/Irreducible.lean
theorem SupIrred.ne_bot (ha : SupIrred a) : a ≠ ⊥
-- Mathlib/Logic/Function/Basic.lean
theorem uncurry_bicompl (f : γ → δ → ε) (g : α → γ) (h : β → δ) :
    uncurry (bicompl f g h) = uncurry f ∘ Prod.map g h
-- Mathlib/Geometry/Manifold/ContMDiffMFDeriv.lean
protected theorem mdifferentiable' (f : C^n⟮I, M; I', M'⟯) (hn : 1 ≤ n) : MDifferentiable I I' f
-- Mathlib/Topology/Homotopy/Path.lean
@[simp]
theorem target (F : Homotopy p₀ p₁) (t : I) : F (t, 1) = x₁
-- Mathlib/NumberTheory/Rayleigh.lean
theorem beattySeq'_symmDiff_beattySeq_pos {r s : ℝ} (hrs : r.IsConjExponent s) :
    {beattySeq' r k | k > 0} ∆ {beattySeq s k | k > 0} = {n | 0 < n}
-- Mathlib/RingTheory/Congruence/Basic.lean
/-- The inductively defined smallest congruence relation containing a binary relation `r` equals
    the infimum of the set of congruence relations containing `r`. -/
theorem ringConGen_eq (r : R → R → Prop) :
    ringConGen r = sInf {s : RingCon R | ∀ x y, r x y → s x y}
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc]
lemma stalkMap_congr (f g : X ⟶ Y) (hfg : f = g) (x x' : X)
    (hxx' : x = x') : f.stalkMap x ≫ X.presheaf.stalkSpecializes (specializes_of_eq hxx'.symm) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| hfg ▸ hxx' ▸ rfl) ≫ g.stalkMap x'
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
@[simp]
lemma endEquivSectionsFibers_π (f : End F) (A : PointedGaloisObject F) :
    (endEquivSectionsFibers F f).val A = f.app A A.pt
-- Mathlib/Topology/MetricSpace/Basic.lean
/-- Characterize the equality of points as the vanishing of the nonnegative distance-/
@[simp]
theorem nndist_eq_zero {x y : γ} : nndist x y = 0 ↔ x = y
-- Mathlib/Data/Finset/Pointwise.lean
theorem Nonempty.of_vsub_left : (s -ᵥ t : Finset α).Nonempty → s.Nonempty
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isIrreducible_zeroLocus_iff (I : Ideal R) :
    IsIrreducible (zeroLocus (I : Set R)) ↔ I.radical.IsPrime
-- Mathlib/Data/Holor.lean
theorem cprankMax_upper_bound [Ring α] : ∀ {ds}, ∀ x : Holor α ds, CPRankMax ds.prod x
-- Mathlib/Topology/MetricSpace/CauSeqFilter.lean
theorem CauchySeq.isCauSeq {f : ℕ → β} (hf : CauchySeq f) : IsCauSeq norm f
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem succ_pred : ∀ (i : Fin (n + 1)) (h : i ≠ 0), (i.pred h).succ = i
-- Mathlib/FieldTheory/Minpoly/Basic.lean
/-- If `a` strictly divides the minimal polynomial of `x`, then `x` cannot be a root for `a`. -/
theorem aeval_ne_zero_of_dvdNotUnit_minpoly {a : A[X]} (hx : IsIntegral A x) (hamonic : a.Monic)
    (hdvd : DvdNotUnit a (minpoly A x)) : Polynomial.aeval x a ≠ 0
-- Mathlib/Data/Sum/Order.lean
theorem inl_strictMono : StrictMono (toLex ∘ inl : α → α ⊕ₗ β)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem roots_normalize {p : R[X]} : (normalize p).roots = p.roots
-- Mathlib/Order/CompleteLatticeIntervals.lean
lemma Set.Icc.coe_sSup [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
    {S : Set (Set.Icc a b)} (hS : S.Nonempty) : letI := Set.Icc.completeLattice h
    ↑(sSup S) = sSup ((↑) '' S : Set α)
-- Mathlib/Topology/Separation.lean
theorem regularSpace_TFAE (X : Type u) [TopologicalSpace X] :
    List.TFAE [RegularSpace X,
      ∀ (s : Set X) x, x ∉ closure s → Disjoint (𝓝ˢ s) (𝓝 x),
      ∀ (x : X) (s : Set X), Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s,
      ∀ (x : X) (s : Set X), s ∈ 𝓝 x → ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s,
      ∀ x : X, (𝓝 x).lift' closure ≤ 𝓝 x,
      ∀ x : X , (𝓝 x).lift' closure = 𝓝 x]
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem arrowCongrSL_toLinearEquiv_apply (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G)
    (L : E →SL[σ₁₄] H) : (e₁₂.arrowCongrSL e₄₃).toLinearEquiv L =
      (e₄₃ : H →SL[σ₄₃] G).comp (L.comp (e₁₂.symm : F →SL[σ₂₁] E))
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
/-- This is the key identity satisfied by `σ`. -/
theorem σ_comp {X Y : C} (f : X ⟶ Y) : σ ≫ f = Limits.prod.map f f ≫ σ