ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Ideal/Operations.lean
/-- Prime avoidance. Atiyah-Macdonald 1.11, Eisenbud 3.3, Stacks 00DS, Matsumura Ex.1.6. -/
theorem subset_union_prime {R : Type u} [CommRing R] {s : Finset ι} {f : ι → Ideal R} (a b : ι)
    (hp : ∀ i ∈ s, i ≠ a → i ≠ b → IsPrime (f i)) {I : Ideal R} :
    ((I : Set R) ⊆ ⋃ i ∈ (↑s : Set ι), f i) ↔ ∃ i ∈ s, I ≤ f i
-- Mathlib/Algebra/Periodic.lean
protected theorem Periodic.const_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
    Periodic (fun x => f (a * x)) (a⁻¹ * c)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.pow' {f : α → R} {g : α → 𝕜} (h : IsBigOWith c l f g) :
    ∀ n : ℕ, IsBigOWith (Nat.casesOn n ‖(1 : R)‖ fun n => c ^ (n + 1))
      l (fun x => f x ^ n) fun x => g x ^ n
-- Mathlib/Algebra/Group/Hom/Instances.lean
/-- The expression `fun g m ↦ g (f m)` as a `MonoidHom`.
Equivalently, `(fun g ↦ MonoidHom.comp g f)` as a `MonoidHom`. -/
@[to_additive (attr := simps!)
      "The expression `fun g m ↦ g (f m)` as an `AddMonoidHom`.
      Equivalently, `(fun g ↦ AddMonoidHom.comp g f)` as an `AddMonoidHom`.

      This also exists in a `LinearMap` version, `LinearMap.lcomp`."]
def compHom' [MulOneClass M] [MulOneClass N] [CommMonoid P] (f : M →* N) : (N →* P) →* M →* P
-- Mathlib/Data/Int/Interval.lean
theorem Icc_eq_finset_map :
    Icc a b =
      (Finset.range (b + 1 - a).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding a)
-- Mathlib/Analysis/RCLike/Basic.lean
theorem norm_I_of_ne_zero (hI : (I : K) ≠ 0) : ‖(I : K)‖ = 1
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem mul_subset_iff : s * t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x * y ∈ u
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
@[simp]
theorem mulIsInitial_inv (X : C) [HasBinaryProduct X I] (hI : IsInitial I) :
    (mulIsInitial X hI).inv = hI.to _
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem ret_bind (a : α) (f : α → Seq1 β) : bind (ret a) f = f a
-- Mathlib/Order/Hom/Basic.lean
@[simp] theorem toFun_eq_coe (f : α →o β) : f.toFun = f
-- Mathlib/Algebra/Module/Injective.lean
protected theorem extension_property (h : Module.Baer R Q)
    (f : M →ₗ[R] N) (hf : Function.Injective f) (g : M →ₗ[R] Q) : ∃ h, h ∘ₗ f = g
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem closure_sUnion (s : Set (Set R)) : closure (⋃₀ s) = ⨆ t ∈ s, closure t
-- Mathlib/Probability/Process/Adapted.lean
/-- A continuous and adapted process is progressively measurable. -/
theorem Adapted.progMeasurable_of_continuous [TopologicalSpace ι] [MetrizableSpace ι]
    [SecondCountableTopology ι] [MeasurableSpace ι] [OpensMeasurableSpace ι]
    [PseudoMetrizableSpace β] (h : Adapted f u) (hu_cont : ∀ ω, Continuous fun i => u i ω) :
    ProgMeasurable f u
-- Mathlib/Data/Fintype/Basic.lean
theorem Fin.univ_image_get' [DecidableEq β] (l : List α) (f : α → β) :
    Finset.univ.image (f <| l.get ·) = (l.map f).toFinset
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
@[simp]
theorem SL_reduction_mod_hom_val (N : ℕ) (γ : SL(2, ℤ)) :
    ∀ i j : Fin 2, (SLMOD(N) γ : Matrix (Fin 2) (Fin 2) (ZMod N)) i j = ((↑ₘγ i j : ℤ) : ZMod N)
-- Mathlib/Data/Set/Image.lean
theorem Injective.preimage_surjective (hf : Injective f) : Surjective (preimage f)
-- Mathlib/Order/SetNotation.lean
@[simp]
theorem iInf_eq_iInter (s : ι → Set α) : iInf s = iInter s
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma inter_eq_univ : s ∩ t = univ ↔ s = univ ∧ t = univ
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem exp_lt_exp {x y : ℝ} : exp x < exp y ↔ x < y
-- Mathlib/Analysis/Convex/Combination.lean
theorem Finset.centerMass_eq_of_sum_1 (hw : ∑ i ∈ t, w i = 1) :
    t.centerMass w z = ∑ i ∈ t, w i • z i
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem length_rowLens {μ : YoungDiagram} : μ.rowLens.length = μ.colLen 0
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem nonunits_le : A.nonunits ≤ A.toSubring.toSubmonoid.toSubsemigroup
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem coe_castLT (i : Fin m) (h : i.1 < n) : (castLT i h : Nat) = i
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma exp_neg_llr [SigmaFinite μ] [SigmaFinite ν] (hμν : μ ≪ ν) :
    (fun x ↦ exp (- llr μ ν x)) =ᵐ[μ] fun x ↦ (ν.rnDeriv μ x).toReal
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem compl_adj (G : SimpleGraph V) (v w : V) : Gᶜ.Adj v w ↔ v ≠ w ∧ ¬G.Adj v w
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem norm_const_eq [h : Nonempty α] (b : β) : ‖const α b‖ = ‖b‖
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem IsLinearMap.with_bound {f : E → F} (hf : IsLinearMap 𝕜 f) (M : ℝ)
    (h : ∀ x : E, ‖f x‖ ≤ M * ‖x‖) : IsBoundedLinearMap 𝕜 f
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma neg_iff_neg_of_smul_pos [PosSMulMono α β] [SMulPosMono α β] (hab : 0 < a • b) :
    a < 0 ↔ b < 0
-- Mathlib/Algebra/Module/Equiv/Defs.lean
protected theorem surjective : Function.Surjective e
-- Mathlib/Algebra/Lie/Submodule.lean
theorem mem_iSup_of_mem {ι} {b : M} {N : ι → LieSubmodule R L M} (i : ι) (h : b ∈ N i) :
    b ∈ ⨆ i, N i
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_ne_zero_of_nonempty (r) [IsWellOrder α r] [h : Nonempty α] : type r ≠ 0
-- Mathlib/Algebra/TrivSqZeroExt.lean
/-- A simplified version of `TrivSqZeroExt.liftEquiv` for the commutative case. -/
@[simps! apply symm_apply_coe]
def liftEquivOfComm :
    { f : M →ₗ[R'] A // ∀ x y, f x * f y = 0 } ≃ (tsze R' M →ₐ[R'] A)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Tendsto.atTop_mul_atBot (hf : Tendsto f l atTop) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x * g x) l atBot
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem exists_mem_of_length_pos : ∀ {l : List α}, 0 < length l → ∃ a, a ∈ l
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem mem_comap : s ∈ comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s
-- Mathlib/Analysis/Normed/Group/Quotient.lean
/-- `S.normedMk` agrees with `QuotientAddGroup.mk' S`. -/
@[simp]
theorem normedMk.apply (S : AddSubgroup M) (m : M) : normedMk S m = QuotientAddGroup.mk' S m
-- Mathlib/Algebra/Homology/Localization.lean
lemma Qh_inverts_quasiIso : (HomotopyCategory.quasiIso C c).IsInvertedBy Qh
-- Mathlib/Data/Int/CharZero.lean
@[simp, norm_cast]
theorem cast_div_charZero {k : Type*} [DivisionRing k] [CharZero k] {m n : ℤ} (n_dvd : n ∣ m) :
    ((m / n : ℤ) : k) = m / n
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem isScalarTower_of_injective [SMul R S] [CompatibleSMul M M₂ R S] [IsScalarTower R S M₂]
    (f : M →ₗ[S] M₂) (hf : Function.Injective f) : IsScalarTower R S M
-- Mathlib/Order/Cover.lean
theorem covBy_of_eq_or_eq (hab : a < b) (h : ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b) : a ⋖ b
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
/-- This property holds if the type of morphisms between `X` and `Y`
in the localized category with respect to `W : MorphismProperty C`
is small. -/
class HasSmallLocalizedHom : Prop where
  small : Small.{w} (W.Q.obj X ⟶ W.Q.obj Y)
-- Mathlib/Algebra/Polynomial/Eval.lean
/-- `Polynomial.eval` as linear map -/
@[simps]
def leval {R : Type*} [Semiring R] (r : R) : R[X] →ₗ[R] R
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem rank_fun' : Module.rank R (η → R) = Fintype.card η
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive] lemma left_inv_eq_right_inv (hba : b * a = 1) (hac : a * c = 1) : b = c
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[fun_prop]
theorem comp_aemeasurable' {f : α → δ} {g : δ → β} (hg : AEMeasurable g (μ.map f))
    (hf : AEMeasurable f μ) : AEMeasurable (fun x ↦ g (f x)) μ
-- Mathlib/Probability/Distributions/Gamma.lean
/-- The Lebesgue integral of the gamma pdf over nonpositive reals equals 0 -/
lemma lintegral_gammaPDF_of_nonpos {x a r : ℝ} (hx : x ≤ 0) :
    ∫⁻ y in Iio x, gammaPDF a r y = 0
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepSets.iInter {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    (h : ∃ n, IndepSets (s n) s' μ) :
    IndepSets (⋂ n, s n) s' μ
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma π_homologyMap_ι [S₁.HasHomology] [S₂.HasHomology] (φ : S₁ ⟶ S₂) :
    S₁.homologyπ ≫ homologyMap φ ≫ S₂.homologyι = S₁.iCycles ≫ φ.τ₂ ≫ S₂.pOpcycles
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem erase_sub {β : ι → Type v} [∀ i, AddGroup (β i)] (i : ι) (f g : Π₀ i, β i) :
    (f - g).erase i = f.erase i - g.erase i
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/-- The lower closure of a finite set is closed in the upper topology. -/
theorem isClosed_lowerClosure (h : s.Finite) : IsClosed (lowerClosure s : Set α)
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem of_irreducible_expand_pow {p : ℕ} (hp : p ≠ 0) {f : R[X]} {n : ℕ} :
    Irreducible (expand R (p ^ n) f) → Irreducible f
-- Mathlib/Data/Nat/Totient.lean
@[simp]
theorem totient_zero : φ 0 = 0
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma ofHoms_v (ψ : ∀ (p : ℤ), F.X p ⟶ G.X p) (p : ℤ) :
    (ofHoms ψ).v p p (add_zero p) = ψ p
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_trivChange_source (i j : ι) (p : B × F) :
    p ∈ (Z.trivChange i j).source ↔ p.1 ∈ Z.baseSet i ∩ Z.baseSet j
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem map_id (γ : Path x y) : γ.map continuous_id = γ
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_eq_formPerm_iff {l l' : List α} (hl : l.Nodup) (hl' : l'.Nodup) :
    l.formPerm = l'.formPerm ↔ l ~r l' ∨ l.length ≤ 1 ∧ l'.length ≤ 1
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem monomial_eq_zero_iff (t : R) (n : ℕ) : monomial n t = 0 ↔ t = 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_div_right_of_neg (hc : c < 0) : a / c ≤ b / c ↔ b ≤ a
-- Mathlib/Algebra/Group/Units.lean
@[field_simps]
theorem eq_divp_iff_mul_eq {x : α} {u : αˣ} {y : α} : x = y /ₚ u ↔ x * u = y
-- Mathlib/Data/Nat/Choose/Factorization.lean
/-- Primes greater than about `sqrt n` appear only to multiplicity 0 or 1
in the binomial coefficient. -/
theorem factorization_choose_le_one (p_large : n < p ^ 2) : (choose n k).factorization p ≤ 1
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive (attr := continuity) continuous_nnnorm]
theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma smul_eq_comap : σ • w = w.comap σ.symm
-- Mathlib/Data/Sigma/Basic.lean
theorem fst_surjective [h : ∀ a, Nonempty (β a)] : Surjective (fst : (Σ a, β a) → α)
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
@[simp] lemma isOpen_ofLowerSet_preimage {s : Set α} :
    IsOpen (ofLowerSet ⁻¹' s) ↔ IsLowerSet s
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem sumCongrHom_injective {α β : Type*} : Function.Injective (sumCongrHom α β)
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem prod_rightInvSeq (ω : List B) : prod (ris ω) = (π ω)⁻¹
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem degrees_add [DecidableEq σ] (p q : MvPolynomial σ R) :
    (p + q).degrees ≤ p.degrees ⊔ q.degrees
-- Mathlib/Data/Fin/Basic.lean
theorem max_val {a : Fin n} : max (a : ℕ) n = n
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If ∠ABC = 0, then (dist A C) = abs ((dist A B) - (dist B C)). -/
theorem dist_eq_abs_sub_dist_of_angle_eq_zero {p1 p2 p3 : P} (h : ∠ p1 p2 p3 = 0) :
    dist p1 p3 = |dist p1 p2 - dist p3 p2|
-- Mathlib/Data/Matroid/Restrict.lean
@[simp] theorem Basis.base_restrict (h : M.Basis I X) : (M ↾ X).Base I
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem coe_compl (s : Subtype (MeasurableSet : Set α → Prop)) : ↑sᶜ = (sᶜ : Set α)
-- Mathlib/CategoryTheory/CofilteredSystem.lean
theorem eventually_injective [Nonempty J] [Finite F.sections] :
    ∃ j, ∀ (i) (f : i ⟶ j), (F.map f).Injective
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Nat.ble_eq_true_of_le (h : LE.le n m) : Eq (Nat.ble n m) true
-- Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean
/-- The Haar measure defined by any orthonormal basis of a finite-dimensional inner product space
is equal to its volume measure. -/
theorem OrthonormalBasis.addHaar_eq_volume {ι F : Type*} [Fintype ι] [NormedAddCommGroup F]
    [InnerProductSpace ℝ F] [FiniteDimensional ℝ F] [MeasurableSpace F] [BorelSpace F]
    (b : OrthonormalBasis ι ℝ F) :
    b.toBasis.addHaar = volume
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem comp {Kg : ℝ≥0} {g : β → γ} (hg : AntilipschitzWith Kg g) {Kf : ℝ≥0} {f : α → β}
    (hf : AntilipschitzWith Kf f) : AntilipschitzWith (Kf * Kg) (g ∘ f)
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Change of variables, general form. If `f` is continuous on `[a, b]` and has
right-derivative `f'` in `(a, b)`, `g` is continuous on `f '' (a, b)` and integrable on
`f '' [a, b]`, and `f' x • (g ∘ f) x` is integrable on `[a, b]`,
then we can substitute `u = f x` to get `∫ x in a..b, f' x • (g ∘ f) x = ∫ u in f a..f b, g u`.
-/
theorem integral_comp_smul_deriv''' {f f' : ℝ → ℝ} {g : ℝ → G} (hf : ContinuousOn f [[a, b]])
    (hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x)
    (hg_cont : ContinuousOn g (f '' Ioo (min a b) (max a b))) (hg1 : IntegrableOn g (f '' [[a, b]]))
    (hg2 : IntegrableOn (fun x => f' x • (g ∘ f) x) [[a, b]]) :
    (∫ x in a..b, f' x • (g ∘ f) x) = ∫ u in f a..f b, g u
-- Mathlib/Data/List/Basic.lean
@[simp, deprecated get_zero_scanl (since := "2023-01-05")]
theorem nthLe_zero_scanl {h : 0 < (scanl f b l).length} : (scanl f b l).nthLe 0 h = b
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem cond_self (c : Bool) (t : α) : cond c t t = t
-- Mathlib/GroupTheory/Coset.lean
@[to_additive (attr := elab_as_elim)]
theorem induction_on' {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z : α, C z) : C x
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes right covariance. -/
theorem Right.one_lt_mul_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (hb : 1 ≤ b)
    (b0 : 0 < b) : 1 < a * b
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem Equiv.Perm.decomposeFin_symm_apply_zero {n : ℕ} (p : Fin (n + 1)) (e : Perm (Fin n)) :
    Equiv.Perm.decomposeFin.symm (p, e) 0 = p
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableOn.const_add (hf : DifferentiableOn 𝕜 f s) (c : F) :
    DifferentiableOn 𝕜 (fun y => c + f y) s
-- Mathlib/CategoryTheory/Category/Preorder.lean
theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
protected theorem is_norm (q : ℚ_[p]) : ↑(padicNormE q) = ‖q‖
-- Mathlib/LinearAlgebra/Matrix/Reindex.lean
theorem reindexLinearEquiv_mul [Fintype n] [Fintype n'] (eₘ : m ≃ m') (eₙ : n ≃ n') (eₒ : o ≃ o')
    (M : Matrix m n A) (N : Matrix n o A) :
    reindexLinearEquiv R A eₘ eₙ M * reindexLinearEquiv R A eₙ eₒ N =
      reindexLinearEquiv R A eₘ eₒ (M * N)
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem norm_restr {k n : ℕ} (f : G[×n]→L[𝕜] G') (s : Finset (Fin n)) (hk : s.card = k) (z : G) :
    ‖f.restr s hk z‖ ≤ ‖f‖ * ‖z‖ ^ (n - k)
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem update_self : f.update a (f a) = f
-- Mathlib/Topology/Basic.lean
theorem IsOpen.eventually_mem (hs : IsOpen s) (hx : x ∈ s) :
    ∀ᶠ x in 𝓝 x, x ∈ s
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) : (n + 1) • x = x
-- Mathlib/SetTheory/Cardinal/Basic.lean
/-- A variant of `Cardinal.lift_mk_le` with specialized universes.
Because Lean often can not realize it should use this specialization itself,
we provide this statement separately so you don't have to solve the specialization problem either.
-/
theorem lift_mk_le' {α : Type u} {β : Type v} : lift.{v} #α ≤ lift.{u} #β ↔ Nonempty (α ↪ β)
-- Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
lemma IsTree.existsUnique_path (hG : G.IsTree) : ∀ v w, ∃! p : G.Walk v w, p.IsPath
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Counting.lean
private lemma edgeDensity_badVertices_le (hε : 0 ≤ ε) (dst : 2 * ε ≤ G.edgeDensity s t) :
    G.edgeDensity (badVertices G ε s t) t ≤ G.edgeDensity s t - ε
-- Mathlib/Data/List/Basic.lean
theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (l₁ l₂ : List α)
    (h₁ : ∀ a ∈ l₁, p a) (h₂ : ∀ a ∈ l₂, p a) :
    ((l₁ ++ l₂).pmap f fun a ha => (List.mem_append.1 ha).elim (h₁ a) (h₂ a)) =
      l₁.pmap f h₁ ++ l₂.pmap f h₂
-- Mathlib/Topology/Algebra/Order/UpperLower.lean
/-- Ad hoc class stating that the closure of an upper set is an upper set. This is used to state
lemmas that do not mention algebraic operations for both the additive and multiplicative versions
simultaneously. If you find a satisfying replacement for this typeclass, please remove it! -/
class HasUpperLowerClosure (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  isUpperSet_closure : ∀ s : Set α, IsUpperSet s → IsUpperSet (closure s)
  isLowerSet_closure : ∀ s : Set α, IsLowerSet s → IsLowerSet (closure s)
  isOpen_upperClosure : ∀ s : Set α, IsOpen s → IsOpen (upperClosure s : Set α)
  isOpen_lowerClosure : ∀ s : Set α, IsOpen s → IsOpen (lowerClosure s : Set α)
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma GrowsPolynomially.rpow (p : ℝ) (hf : GrowsPolynomially f)
    (hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p
-- Mathlib/SetTheory/Cardinal/ToNat.lean
@[simp]
theorem toNat_ofNat (n : ℕ) [n.AtLeastTwo] :
    Cardinal.toNat (no_index (OfNat.ofNat n)) = OfNat.ofNat n
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem snd_star [Star R] [Star A] (x : Unitization R A) : (star x).snd = star x.snd
-- Mathlib/Data/ENat/Basic.lean
@[simp]
theorem top_ne_coe (a : ℕ) : ⊤ ≠ (a : ℕ∞)
-- Mathlib/Order/Defs.lean
theorem le_of_lt_or_eq : ∀ {a b : α}, a < b ∨ a = b → a ≤ b
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem minFacAux_has_prop {n : ℕ} (n2 : 2 ≤ n) :
    ∀ k i, k = 2 * i + 3 → (∀ m, 2 ≤ m → m ∣ n → k ≤ m) → minFacProp n (minFacAux n k)
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g
-- Mathlib/MeasureTheory/SetSemiring.lean
/-- A semi-ring of sets `C` is a family of sets containing `∅`, stable by intersection and such that
for all `s, t ∈ C`, `s \ t` is equal to a disjoint union of finitely many sets in `C`. -/
structure IsSetSemiring (C : Set (Set α)) : Prop where
  empty_mem : ∅ ∈ C
  inter_mem : ∀ s ∈ C, ∀ t ∈ C, s ∩ t ∈ C
  diff_eq_sUnion' : ∀ s ∈ C, ∀ t ∈ C,
    ∃ I : Finset (Set α), ↑I ⊆ C ∧ PairwiseDisjoint (I : Set (Set α)) id ∧ s \ t = ⋃₀ I
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem empty_sdiff (s : Finset α) : ∅ \ s = ∅
-- Mathlib/Data/Matrix/Basic.lean
/-- The `LinearMap` between spaces of matrices induced by a `LinearMap` between their
coefficients. This is `Matrix.map` as a `LinearMap`. -/
@[simps]
def mapMatrix (f : α →ₗ[R] β) : Matrix m n α →ₗ[R] Matrix m n β
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
@[simp]
theorem toJordanDecomposition_toSignedMeasure (j : JordanDecomposition α) :
    j.toSignedMeasure.toJordanDecomposition = j
-- Mathlib/Logic/Relation.lean
theorem transGen_eq_self (trans : Transitive r) : TransGen r = r
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[to_additive]
theorem forall_coe_one_iff_one (f : α →ᵇ β) : (∀ x, f x = 1) ↔ f = 1
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = (x : G) ^ n
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem Multipliable.div (hf : Multipliable f) (hg : Multipliable g) :
    Multipliable fun b ↦ f b / g b
-- Mathlib/Computability/Ackermann.lean
theorem not_primrec_ack_self : ¬Primrec fun n => ack n n
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma oddKernel_def (a x : ℝ) : ↑(oddKernel a x) = jacobiTheta₂'' a (I * x)
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
/--
A class describing the property of preserving finite effective epimorphic families.
-/
class PreservesFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor preserves finite effective epimorphic families if it maps finite effective epimorphic
  families to effective epimorphic families.
  -/
  preserves : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
-- Mathlib/Algebra/GroupWithZero/Basic.lean
lemma zpow_add' {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n
-- .lake/packages/lean4/src/lean/Init/Data/String/Lemmas.lean
protected theorem ne_of_data_ne {a b : String} (h : a.data ≠ b.data) : a ≠ b
-- Mathlib/Data/Set/Sups.lean
@[simp]
theorem infs_nonempty : (s ⊼ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem DifferentiableWithinAt.cos (hf : DifferentiableWithinAt ℝ f s x) :
    DifferentiableWithinAt ℝ (fun x => Real.cos (f x)) s x
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
theorem disjoint_of_mem_compression_of_not_mem (h : a ∈ 𝓒 u v s) (ha : a ∉ s) : Disjoint v a
-- Mathlib/Topology/MetricSpace/Gluing.lean
theorem fst_eq_of_dist_lt_one (x y : Σi, E i) (h : dist x y < 1) : x.1 = y.1
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_add_of_nonneg (x : ℝ≥0) {y z : ℝ} (hy : 0 ≤ y) (hz : 0 ≤ z) :
    x ^ (y + z) = x ^ y * x ^ z
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem basicOpen :
    IsAffineOpen (X.basicOpen f)
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem tuple0_le {α : Fin 0 → Type*} [∀ i, Preorder (α i)] (f g : ∀ i, α i) : f ≤ g
-- Mathlib/Order/Basic.lean
theorem eq_of_forall_gt_iff [LinearOrder α] {a b : α} (h : ∀ c, a < c ↔ b < c) : a = b
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
lemma stdAddChar_coe (j : ℤ) :
    stdAddChar (j : ZMod N) = exp (2 * π * I * j / N)
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
/-- The isomorphism in `Localization W` that is induced by a morphism in `W`. -/
@[simps]
def Qiso {X Y : C} (s : X ⟶ Y) (hs : W s) : (Q W).obj X ≅ (Q W).obj Y
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem cancel_mono_id (f : X ⟶ Y) [Mono f] {g : X ⟶ X} : g ≫ f = f ↔ g = 𝟙 X
-- Mathlib/SetTheory/ZFC/Ordinal.lean
protected theorem IsTransitive.union (hx : x.IsTransitive) (hy : y.IsTransitive) :
    (x ∪ y).IsTransitive
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_sup_comap_of_surjective (p q : Submodule R₂ M₂) :
    (p.comap f ⊔ q.comap f).map f = p ⊔ q
-- Mathlib/Data/Set/Basic.lean
theorem union_congr_left (ht : t ⊆ s ∪ u) (hu : u ⊆ s ∪ t) : s ∪ t = s ∪ u
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma measurable_rnDeriv (κ η : Kernel α γ) :
    Measurable (fun p : α × γ ↦ rnDeriv κ η p.1 p.2)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- Sum of a multiset of elements in a `NonUnitalSubring` of a `NonUnitalRing` is
in the `NonUnitalSubring`. -/
protected theorem multiset_sum_mem {R} [NonUnitalNonAssocRing R] (s : NonUnitalSubring R)
    (m : Multiset R) : (∀ a ∈ m, a ∈ s) → m.sum ∈ s
-- Mathlib/Order/WithBot.lean
lemma forall_ne_iff_eq_bot {x : WithBot α} : (∀ a : α, ↑a ≠ x) ↔ x = ⊥
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem enum_singleton (x : α) : enum [x] = [(0, x)]
-- Mathlib/GroupTheory/PushoutI.lean
theorem of_comp_eq_base (i : ι) : (of i).comp (φ i) = (base φ)
-- Mathlib/Order/Filter/Ultrafilter.lean
protected theorem em (f : Ultrafilter α) (p : α → Prop) : (∀ᶠ x in f, p x) ∨ ∀ᶠ x in f, ¬p x
-- Mathlib/Order/InitialSeg.lean
theorem init [IsTrans β s] (f : r ≺i s) {a : α} {b : β} (h : s b (f a)) : ∃ a', f a' = b
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma odd_iff_not_even : Odd n ↔ ¬Even n
-- Mathlib/Data/Int/Interval.lean
theorem Ico_eq_finset_map :
    Ico a b = (Finset.range (b - a).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding a)
-- Mathlib/Algebra/Order/Hom/Basic.lean
@[to_additive]
theorem map_pos_of_ne_one [Group α] [LinearOrderedAddCommMonoid β] [GroupNormClass F α β] (f : F)
    {x : α} (hx : x ≠ 1) : 0 < f x
-- Mathlib/Topology/Order/ScottTopology.lean
lemma dirSupClosed_of_isClosed (h : IsClosed s) : DirSupClosed s
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem eventually_imp : (∀ᶠ x in f, p x → q x) ↔ (∀ᶠ x in f, p x) → ∀ᶠ x in f, q x
-- Mathlib/Data/Semiquot.lean
@[simp]
theorem pure_le {a : α} {s : Semiquot α} : pure a ≤ s ↔ a ∈ s