ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Dynamics/FixedPoints/Basic.lean
protected theorem equiv_symm (h : IsFixedPt e x) : IsFixedPt e.symm x
-- Mathlib/Order/ModularLattice.lean
theorem isCompl_sup_left_of_isCompl_sup_right [Lattice α] [BoundedOrder α] [IsModularLattice α]
    (h : Disjoint b c) (hcomp : IsCompl a (b ⊔ c)) :
    IsCompl (a ⊔ b) c
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem cauchySeq_const [SemilatticeSup β] [Nonempty β] (x : α) : CauchySeq fun _ : β => x
-- Mathlib/CategoryTheory/Abelian/Exact.lean
theorem exact_iff_of_forks {cg : KernelFork S.g} (hg : IsLimit cg) {cf : CokernelCofork S.f}
    (hf : IsColimit cf) : S.Exact ↔ cg.ι ≫ cf.π = 0
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem ofLinearEquiv_toLinearEquiv (map_mul) (map_one) :
    ofLinearEquiv e.toLinearEquiv map_mul map_one = e
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem EuclideanSpace.single_apply (i : ι) (a : 𝕜) (j : ι) :
    (EuclideanSpace.single i a) j = ite (j = i) a 0
-- Mathlib/Data/Int/Log.lean
theorem clog_of_right_le_zero (b : ℕ) {r : R} (hr : r ≤ 0) : clog b r = 0
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- The associated bilinear form of an anisotropic quadratic form is nondegenerate. -/
theorem separatingLeft_of_anisotropic [Invertible (2 : R)] (Q : QuadraticMap R M R)
    (hB : Q.Anisotropic) :
    -- Porting note: added implicit argument
    (QuadraticMap.associated' (R := R) Q).SeparatingLeft
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem Perm.extendDomain_refl : Perm.extendDomain (Equiv.refl _) f = Equiv.refl _
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
/-- If `f : X → Y` is continuous and `Y` is equipped with the Borel sigma algebra, then
the push-forward of finite measures `f* : FiniteMeasure X → FiniteMeasure Y` is continuous
(in the topologies of weak convergence of measures). -/
lemma continuous_map {f : Ω → Ω'} (f_cont : Continuous f) :
    Continuous (fun ν ↦ FiniteMeasure.map ν f)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem add_lt_of_lt {a b c : Cardinal} (hc : ℵ₀ ≤ c) (h1 : a < c) (h2 : b < c) : a + b < c
-- Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean
theorem quasiSeparated_eq_diagonal_is_quasiCompact :
    @QuasiSeparated = MorphismProperty.diagonal @QuasiCompact
-- Mathlib/Data/Rat/BigOperators.lean
@[simp, norm_cast]
theorem cast_prod (s : Finset ι) (f : ι → ℚ) : ∏ i ∈ s, f i = ∏ i ∈ s, (f i : α)
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem cast_toZNum [Zero α] [One α] [Add α] [Neg α] : ∀ n : Num, (n.toZNum : α) = n
-- Mathlib/MeasureTheory/Function/Floor.lean
theorem Nat.measurable_floor : Measurable (Nat.floor : R → ℕ)
-- Mathlib/SetTheory/Game/Basic.lean
theorem quot_neg_mul_neg (x y : PGame) : ⟦-x * -y⟧ = (⟦x * y⟧ : Game)
-- Mathlib/Algebra/Star/Pointwise.lean
@[simp]
lemma StarMemClass.star_coe_eq {S α : Type*} [InvolutiveStar α] [SetLike S α]
    [StarMemClass S α] (s : S) : star (s : Set α) = s
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem mem_tail_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support.tail ↔ t ∈ p.support.tail ∨ t ∈ p'.support.tail
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- The `v`-adic valuation on `K` extends the `v`-adic valuation on `R`. -/
theorem valuation_of_algebraMap (r : R) : v.valuation (algebraMap R K r) = v.intValuation r
-- Mathlib/Computability/Partrec.lean
theorem rfindOpt_spec {α} {f : ℕ → Option α} {a} (h : a ∈ rfindOpt f) : ∃ n, a ∈ f n
-- Mathlib/Algebra/Lie/Weights/Basic.lean
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.stieltjesFunction_nonneg (a : α) (r : ℝ) : 0 ≤ hf.stieltjesFunction a r
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem aleph0_mul_continuum : ℵ₀ * 𝔠 = 𝔠
-- Mathlib/Order/Hom/Bounded.lean
@[ext]
theorem ext {f g : TopHom α β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/RingTheory/Valuation/RankOne.lean
lemma strictMono : StrictMono (hom v)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma slope_of_Y_eq {x₁ x₂ y₁ y₂ : F} (hx : x₁ = x₂) (hy : y₁ = W.negY x₂ y₂) :
    W.slope x₁ x₂ y₁ y₂ = 0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_one : ⇑(1 : E ≃ₗᵢ[R] E) = id
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem subtypeEquivCodomain_symm_apply (f : { x' // x' ≠ x } → Y) (y : Y) (x' : X) :
    ((subtypeEquivCodomain f).symm y : X → Y) x' = if h : x' ≠ x then f ⟨x', h⟩ else y
-- Mathlib/Algebra/Lie/Submodule.lean
theorem coe_map_of_surjective (h : Function.Surjective f) :
    LieSubmodule.toSubmodule (I.map f) = (LieSubmodule.toSubmodule I).map (f : L →ₗ[R] L')
-- Mathlib/Topology/NhdsSet.lean
theorem hasBasis_nhdsSet (s : Set X) : (𝓝ˢ s).HasBasis (fun U => IsOpen U ∧ s ⊆ U) fun U => U
-- Mathlib/Algebra/Ring/Pi.lean
/-- A family of ring homomorphisms `f a : γ →+* β a` defines a ring homomorphism
`Pi.ringHom f : γ →+* Π a, β a` given by `Pi.ringHom f x b = f b x`. -/
@[simps]
protected def ringHom {γ : Type w} [∀ i, NonAssocSemiring (f i)] [NonAssocSemiring γ]
    (g : ∀ i, γ →+* f i) : γ →+* ∀ i, f i
-- Mathlib/Data/Real/EReal.lean
theorem add_lt_top {x y : EReal} (hx : x ≠ ⊤) (hy : y ≠ ⊤) : x + y < ⊤
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
lemma IsEquipartition.sum_nonUniforms_lt' (hA : A.Nonempty) (hε : 0 < ε) (hP : P.IsEquipartition)
    (hG : P.IsUniform G ε) :
    ∑ i ∈ P.nonUniforms G ε, (i.1.card * i.2.card : 𝕜) < ε * (A.card + P.parts.card) ^ 2
-- Mathlib/ModelTheory/Definability.lean
@[simp]
theorem not_mem_bot {x : α → M} : ¬x ∈ (⊥ : L.DefinableSet A α)
-- Mathlib/Analysis/Complex/Angle.lean
lemma angle_exp_one (x : ℝ) : angle (exp (x * I)) 1 = |toIocMod Real.two_pi_pos (-π) x|
-- Mathlib/Data/Int/Defs.lean
@[norm_cast]
protected lemma natCast_sub {n m : ℕ} : n ≤ m → (↑(m - n) : ℤ) = ↑m - ↑n
-- Mathlib/Topology/PartialHomeomorph.lean
/-- Composition of partial homeomorphisms respects equivalence. -/
theorem EqOnSource.trans' {e e' : PartialHomeomorph X Y} {f f' : PartialHomeomorph Y Z}
    (he : e ≈ e') (hf : f ≈ f') : e.trans f ≈ e'.trans f'
-- Mathlib/Probability/Martingale/BorelCantelli.lean
theorem Adapted.isStoppingTime_leastGE (r : ℝ) (n : ℕ) (hf : Adapted ℱ f) :
    IsStoppingTime ℱ (leastGE f r n)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem dist_lt_add_of_nonempty_ball_inter_ball (h : (ball x ε₁ ∩ ball y ε₂).Nonempty) :
    dist x y < ε₁ + ε₂
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma measure_symmDiff_eq (hs : MeasurableSet s) (ht : MeasurableSet t) :
    μ (s ∆ t) = μ (s \ t) + μ (t \ s)
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
@[simp] theorem SatisfiesM_Id_eq : SatisfiesM (m := Id) p x ↔ p x
-- Mathlib/Topology/Sets/Compacts.lean
theorem map_comp (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (K : Compacts α) :
    K.map (f ∘ g) (hf.comp hg) = (K.map g hg).map f hf
-- Mathlib/Data/Finset/Lattice.lean
/-- Supremum of `s i`, `i : ι`, is equal to the supremum over `t : Finset ι` of suprema
`⨆ i ∈ t, s i`. This version works for `ι : Sort*`. See `iSup_eq_iSup_finset` for a version
that assumes `ι : Type*` but has no `PLift`s. -/
theorem iSup_eq_iSup_finset' (s : ι' → α) :
    ⨆ i, s i = ⨆ t : Finset (PLift ι'), ⨆ i ∈ t, s (PLift.down i)
-- Mathlib/Algebra/Algebra/Subalgebra/Operations.lean
/-- Suppose we are given `∑ i, lᵢ * sᵢ = 1` ∈ `S`, and `S'` a subalgebra of `S` that contains
`lᵢ` and `sᵢ`. To check that an `x : S` falls in `S'`, we only need to show that
`sᵢ ^ n • x ∈ S'` for some `n` for each `sᵢ`. -/
theorem mem_of_finset_sum_eq_one_of_pow_smul_mem
    {ι : Type*} (ι' : Finset ι) (s : ι → S) (l : ι → S)
    (e : ∑ i ∈ ι', l i * s i = 1) (hs : ∀ i, s i ∈ S') (hl : ∀ i, l i ∈ S') (x : S)
    (H : ∀ i, ∃ n : ℕ, (s i ^ n : S) • x ∈ S') : x ∈ S'
-- Mathlib/Control/Functor.lean
theorem functor_comp_id {F} [AF : Functor F] [LawfulFunctor F] :
    @Comp.functor F Id _ _ = AF
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem lex_inr_inr : Lex r s (inr b₁) (inr b₂) ↔ s b₁ b₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma comp_id (C : VariableChange R) : comp C id = C
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem dvd_of_mod_eq_zero {a b : Int} (H : mod b a = 0) : a ∣ b
-- Mathlib/Order/Monotone/Monovary.lean
theorem monovary_self (f : ι → α) : Monovary f f
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- Subsemiring closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`. -/
theorem closure_mono ⦃s t : Set R⦄ (h : s ⊆ t) : closure s ≤ closure t
-- Mathlib/Order/Disjoint.lean
theorem codisjoint_right_comm : Codisjoint (a ⊔ b) c ↔ Codisjoint (a ⊔ c) b
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- In this situation, `F` is also initial, see
    `Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful`. -/
theorem IsCofiltered.of_exists_of_isCofiltered_of_fullyFaithful [IsCofiltered D] [F.Full]
    [F.Faithful] (h : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) : IsCofiltered C
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_smul_le (a : R) (p : R[X]) : natDegree (a • p) ≤ natDegree p
-- Mathlib/NumberTheory/Dioph.lean
theorem diophPFun_comp1 {S : Set (Option α → ℕ)} (d : Dioph S) {f} (df : DiophPFun f) :
    Dioph {v : α → ℕ | ∃ h : f.Dom v, f.fn v h ::ₒ v ∈ S}
-- Mathlib/Algebra/Group/Fin/Tuple.lean
lemma cons_add_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    vecCons x v + vecCons y w = vecCons (x + y) (v + w)
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [NonUnitalAlgHomClass F R A B]
    [NonUnitalStarAlgHomClass F R A B] (f : F) :
    ⇑(f : A →⋆ₙₐ[R] B) = f
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem neg_apply : (-x) i = -x i
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
theorem coe_addHom_mk {σ : R →+* S} (f : AddHom M M₃) (h) :
    ((LinearMap.mk f h : M →ₛₗ[σ] M₃) : AddHom M M₃) = f
-- Mathlib/Data/Set/Basic.lean
theorem disjoint_compl_right_iff_subset : Disjoint s tᶜ ↔ s ⊆ t
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma X_eq_iff {P Q : Fin 3 → F} (hPz : P z ≠ 0) (hQz : Q z ≠ 0) :
    P x * Q z ^ 2 = Q x * P z ^ 2 ↔ P x / P z ^ 2 = Q x / Q z ^ 2
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem typein_le_typein' (o : Ordinal) {x x' : o.out.α} :
    @typein _ (· < ·) (isWellOrder_out_lt _) x ≤ @typein _ (· < ·) (isWellOrder_out_lt _) x'
      ↔ x ≤ x'
-- Mathlib/Order/Cover.lean
theorem WCovBy.covBy_of_ne (h : a ⩿ b) (h2 : a ≠ b) : a ⋖ b
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem le_of_count_ne_zero {m p : Associates α} (h0 : m ≠ 0) (hp : Irreducible p) :
    count p m.factors ≠ 0 → p ≤ m
-- Mathlib/Logic/Equiv/TransferInstance.lean
lemma algebraMap_def (e : α ≃ β) [Semiring β] [Algebra R β] (r : R) :
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    (algebraMap R α) r = e.symm ((algebraMap R β) r)
-- Mathlib/Data/Set/Subsingleton.lean
@[simp]
theorem monotoneOn_singleton : MonotoneOn f {a}
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_monomial_le (a : R) {m : ℕ} : (monomial m a).natDegree ≤ m
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
/-- A finite dimensional module has dimension at most 1 iff
there is some `v : V` so every vector is a multiple of `v`.
-/
theorem finrank_le_one_iff [Module.Free K V] [Module.Finite K V] :
    finrank K V ≤ 1 ↔ ∃ v : V, ∀ w : V, ∃ c : K, c • v = w
-- Mathlib/Data/List/Basic.lean
theorem foldrM_eq_foldr (f : α → β → m β) (b l) :
    foldrM f b l = foldr (fun a mb => mb >>= f a) (pure b) l
-- Mathlib/Algebra/BigOperators/Ring.lean
@[simp, norm_cast]
lemma cast_sum [AddCommGroupWithOne β] (s : Finset α) (f : α → ℤ) :
    ↑(∑ x ∈ s, f x : ℤ) = ∑ x ∈ s, (f x : β)
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
theorem recDiagAux_succ_succ {motive : Nat → Nat → Sort _}
    (zero_left : ∀ n, motive 0 n) (zero_right : ∀ m, motive m 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m n) :
    Nat.recDiagAux zero_left zero_right succ_succ (m+1) (n+1)
      = succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n)
-- Mathlib/Data/Finset/Card.lean
theorem one_lt_card_iff_nontrivial : 1 < s.card ↔ s.Nontrivial
-- Mathlib/Probability/Independence/Basic.lean
theorem Indep.indepSets {s1 s2 : Set (Set Ω)}
    (h_indep : Indep (generateFrom s1) (generateFrom s2) μ) :
    IndepSets s1 s2 μ
-- Mathlib/GroupTheory/Sylow.lean
theorem ext_iff {P Q : Sylow p G} : P = Q ↔ (P : Subgroup G) = Q
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma neg_def (P : W.Point) : P.neg = -P
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
theorem strictMono_cast : StrictMono (Nat.cast : ℕ → α)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma image_basicOpen_eq_basicOpen (a : A) (i : ℕ) :
    toSpec 𝒜 f '' (Subtype.val ⁻¹' (pbo (decompose 𝒜 a i) : Set (ProjectiveSpectrum 𝒜))) =
    (PrimeSpectrum.basicOpen (R := A⁰_ f) <|
      HomogeneousLocalization.mk
        ⟨m * i, ⟨decompose 𝒜 a i ^ m, SetLike.pow_mem_graded _ (Submodule.coe_mem _)⟩,
          ⟨f^i, by rw [mul_comm]; exact SetLike.pow_mem_graded _ f_deg⟩, ⟨i, rfl⟩⟩).1
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem max_div_div_right_of_nonpos (hc : c ≤ 0) (a b : α) : max (a / c) (b / c) = min a b / c
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem mem_closedBall : y ∈ closedBall p x r ↔ p (y - x) ≤ r
-- Mathlib/Order/Chain.lean
theorem IsChain.mono : s ⊆ t → IsChain r t → IsChain r s
-- Mathlib/Topology/Filter.lean
protected theorem mem_nhds_iff {l : Filter α} {S : Set (Filter α)} :
    S ∈ 𝓝 l ↔ ∃ t ∈ l, Iic (𝓟 t) ⊆ S
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[local simp] theorem ofNat_mul_negSucc' (m n : Nat) : ↑m * -[n+1] = negOfNat (m * succ n)
-- Mathlib/Data/List/Basic.lean
@[deprecated getElem_reverse (since := "2024-06-12")]
theorem get_reverse (l : List α) (i : Nat) (h1 h2) :
    get (reverse l) ⟨length l - 1 - i, h1⟩ = get l ⟨i, h2⟩
-- Mathlib/CategoryTheory/Sites/Coherent/CoherentSheaves.lean
lemma isSheaf_coherent (P : Cᵒᵖ ⥤ Type w) :
    Presieve.IsSheaf (coherentTopology C) P ↔
    (∀ (B : C) (α : Type) [Finite α] (X : α → C) (π : (a : α) → (X a ⟶ B)),
      EffectiveEpiFamily X π → (Presieve.ofArrows X π).IsSheafFor P)
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwise_univ : (univ : Set α).Pairwise r ↔ Pairwise r
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma lift_desc_f {K L : CochainComplex C ℤ} (α : Cocycle K F 1) (β : Cochain K G 0)
    (eq : δ 0 1 β + α.1.comp (Cochain.ofHom φ) (add_zero 1) = 0)
    (α' : Cochain F L (-1)) (β' : G ⟶ L)
    (eq' : δ (-1) 0 α' = Cochain.ofHom (φ ≫ β')) (n n' : ℤ) (hnn' : n + 1 = n') :
    (lift φ α β eq).f n ≫ (desc φ α' β' eq').f n =
    α.1.v n n' hnn' ≫ α'.v n' n (by omega) + β.v n n (add_zero n) ≫ β'.f n
-- Mathlib/Analysis/Convex/Gauge.lean
theorem gauge_eq_one_iff_mem_frontier (hc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) :
    gauge s x = 1 ↔ x ∈ frontier s
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_empty_type [IsEmpty ι] : LinearIndependent R v
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
/-- If `M ≤ N` are submonoids of `R` such that `∀ x : N, ∃ m : R, m * x ∈ M`, then the
localization at `N` is equal to the localizaton of `M`. -/
theorem isLocalization_of_is_exists_mul_mem (M N : Submonoid R) [IsLocalization M S] (h : M ≤ N)
    (h' : ∀ x : N, ∃ m : R, m * x ∈ M) : IsLocalization N S
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem comp_bfamilyOfFamily {ι : Type u} (f : ι → α) (g : α → β) :
    (fun i hi => g (bfamilyOfFamily f i hi)) = bfamilyOfFamily (g ∘ f)
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem length_cons : length (cons a b t) = length t + 1
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
@[ext]
theorem rightDistributor_ext_left {J : Type} [Fintype J]
    {f : J → C} {X Y : C} {g h : (⨁ f) ⊗ X ⟶ Y}
    (w : ∀ j, (biproduct.ι f j ▷ X) ≫ g = (biproduct.ι f j ▷ X) ≫ h) : g = h
-- Mathlib/Probability/Independence/Kernel.lean
theorem iIndepSets.iIndepSet_of_mem {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    [IsMarkovKernel κ] {μ : Measure α} {π : ι → Set (Set Ω)} {f : ι → Set Ω}
    (hfπ : ∀ i, f i ∈ π i) (hf : ∀ i, MeasurableSet (f i))
    (hπ : iIndepSets π κ μ) :
    iIndepSet f κ μ
-- Mathlib/Order/Filter/Extr.lean
theorem isMinOn_const {b : β} : IsMinOn (fun _ => b) s a
-- Mathlib/Topology/LocallyFinite.lean
protected theorem nhdsWithin_iUnion (hf : LocallyFinite f) (a : X) :
    𝓝[⋃ i, f i] a = ⨆ i, 𝓝[f i] a
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma rightHomologyMap_add :
    rightHomologyMap (φ + φ') = rightHomologyMap φ + rightHomologyMap φ'
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma homologyπ_naturality :
    K.homologyπ i ≫ homologyMap φ i = cyclesMap φ i ≫ L.homologyπ i
-- Mathlib/Topology/Separation.lean
theorem disjoint_nhds_nhds_iff_not_specializes : Disjoint (𝓝 x) (𝓝 y) ↔ ¬x ⤳ y
-- Mathlib/CategoryTheory/Sites/SheafHom.lean
@[simp]
lemma presheafHom_map_app_op_mk_id {X Y : C} (g : Y ⟶ X)
    (α : (presheafHom F G).obj (op X)) :
    ((presheafHom F G).map g.op α).app (op (Over.mk (𝟙 Y))) =
      α.app (op (Over.mk g))
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma antitone_rpow_of_base_le_one {b : ℝ} (hb₀ : 0 < b) (hb₁ : b ≤ 1) :
    Antitone (b ^ · : ℝ → ℝ)
-- Mathlib/Computability/Reduce.lean
theorem computable_of_manyOneReducible {p : α → Prop} {q : β → Prop} (h₁ : p ≤₀ q)
    (h₂ : ComputablePred q) : ComputablePred p
-- Mathlib/Deprecated/Group.lean
theorem Additive.isAddHom [Mul α] [Mul β] {f : α → β} (hf : IsMulHom f) :
    @IsAddHom (Additive α) (Additive β) _ _ f
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem le_sub_of_le_upcrossingsBefore (hN : 0 < N) (hab : a < b)
    (hn : n < upcrossingsBefore a b f N ω) :
    b - a ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω -
      stoppedValue f (lowerCrossingTime a b f N n) ω
-- Mathlib/CategoryTheory/GradedObject/Associator.lean
@[reassoc (attr := simp)]
lemma ι_mapBifunctorAssociator_inv (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : r (i₁, i₂, i₃) = j) :
    ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h ≫
      (mapBifunctorAssociator associator ρ₁₂ ρ₂₃ X₁ X₂ X₃).inv j =
    ((associator.inv.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ιMapBifunctor₁₂BifunctorMapObj F₁₂ G ρ₁₂ X₁ X₂ X₃ i₁ i₂ i₃ j h
-- Mathlib/Topology/Order/Basic.lean
theorem pi_Ioo_mem_nhds (ha : ∀ i, a i < x i) (hb : ∀ i, x i < b i) : Ioo a b ∈ 𝓝 x
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
@[simp, norm_cast]
theorem op_coe (S : Subsemiring R) : S.op = MulOpposite.unop ⁻¹' (S : Set R)
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_Icc (r s : β) : Convex 𝕜 (Icc r s)
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_mono {f : F} {p p' : Submodule R M} : p ≤ p' → map f p ≤ map f p'
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem addChar_eq (p : Pos) (c : Char) : p + c = ⟨p.byteIdx + c.utf8Size⟩
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem isNat_lucasLehmerTest : {p np : ℕ} →
    IsNat p np → LucasLehmerTest np → LucasLehmerTest p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem add_mod_mod (m n k : Nat) : (m + n % k) % k = (m + n) % k
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsLUB.mem_closure {a : α} {s : Set α} (ha : IsLUB s a) (hs : s.Nonempty) : a ∈ closure s
-- Mathlib/SetTheory/Cardinal/Basic.lean
/-- A cardinal lifted to a lower or equal universe equals itself. -/
@[simp, nolint simpNF]
theorem lift_id' (a : Cardinal.{max u v}) : lift.{u} a = a
-- Mathlib/Combinatorics/Quiver/Path.lean
lemma hom_heq_of_cons_eq_cons {p : Path a b} {p' : Path a c}
    {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e') : HEq e e'
-- Mathlib/Topology/Bornology/Basic.lean
@[simp] lemma isCobounded_preimage_toDual {s : Set αᵒᵈ} :
    IsCobounded (toDual ⁻¹' s) ↔ IsCobounded s
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Express `edist` in terms of `nndist`-/
theorem edist_nndist (x y : α) : edist x y = nndist x y
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
@[simp]
theorem bind_zero_left (f : α → Measure β) : bind 0 f = 0
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem hasDerivAtFilter_neg : HasDerivAtFilter Neg.neg (-1) x L
-- Mathlib/Data/Set/Basic.lean
lemma disjoint_sdiff_right : Disjoint s (t \ s)
-- Mathlib/Data/Set/Sups.lean
theorem Nonempty.of_infs_left : (s ⊼ t).Nonempty → s.Nonempty
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le.intro {a b : Int} (n : Nat) (h : a + n = b) : a ≤ b
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_symm_eq_iff (e : M ≃ₛₗ[τ₁₂] M₂) {K : Submodule R₂ M₂} :
    K.map e.symm = p ↔ p.map e = K
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma finite_countablePartition (α : Type*) [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    Set.Finite (countablePartition α n)
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem Finite.einfsep_pos (hs : s.Finite) : 0 < s.einfsep
-- Mathlib/LinearAlgebra/Span.lean
/-- A version of `Submodule.span_eq` for subobjects closed under addition and scalar multiplication
and containing zero. In general, this should not be used directly, but can be used to quickly
generate proofs for specific types of subobjects. -/
lemma coe_span_eq_self [SetLike S M] [AddSubmonoidClass S M] [SMulMemClass S R M] (s : S) :
    (span R (s : Set M) : Set M) = s
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem compl_eq_univ_iff (s : Finset α) : sᶜ = univ ↔ s = ∅
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem lsum_apply (S) [AddCommMonoid M] [Module R M] [Fintype ι] [DecidableEq ι] [Semiring S]
    [Module S M] [SMulCommClass R S M] (f : (i : ι) → φ i →ₗ[R] M) :
    lsum R φ S f = ∑ i : ι, (f i).comp (proj i)
-- Mathlib/Computability/PartrecCode.lean
theorem eval_part : Partrec₂ eval
-- Mathlib/Topology/SeparatedMap.lean
theorem const_of_comp [PreconnectedSpace A] (cont : Continuous g)
    (he : ∀ a a', p (g a) = p (g a')) (a a') : g a = g a'
-- Mathlib/Topology/Constructions.lean
theorem prod_generateFrom_generateFrom_eq {X Y : Type*} {s : Set (Set X)} {t : Set (Set Y)}
    (hs : ⋃₀ s = univ) (ht : ⋃₀ t = univ) :
    @instTopologicalSpaceProd X Y (generateFrom s) (generateFrom t) =
      generateFrom (image2 (·  ×ˢ ·) s t)
-- Mathlib/FieldTheory/Perfect.lean
theorem separable_iff_squarefree {g : K[X]} : g.Separable ↔ Squarefree g
-- Mathlib/Dynamics/Ergodic/Ergodic.lean
/-- A map `f : α → α` is said to be pre-ergodic with respect to a measure `μ` if any measurable
strictly invariant set is either almost empty or full. -/
structure PreErgodic (μ : Measure α := by volume_tac) : Prop where
  ae_empty_or_univ : ∀ ⦃s⦄, MeasurableSet s → f ⁻¹' s = s → s =ᵐ[μ] (∅ : Set α) ∨ s =ᵐ[μ] univ
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
/-- A right adjoint functor `R : D ⥤ C` is *monadic* if the comparison functor `Monad.comparison R`
from `D` to the category of Eilenberg-Moore algebras for the adjunction is an equivalence.
-/
class MonadicRightAdjoint (R : D ⥤ C) where
  /-- a choice of left adjoint for `R` -/
  L : C ⥤ D
  /-- `R` is a right adjoint -/
  adj : L ⊣ R
  eqv : (Monad.comparison adj).IsEquivalence
-- Mathlib/Order/Hom/Order.lean
@[simp, norm_cast]
theorem coe_iSup {ι : Sort*} [CompleteLattice β] (f : ι → α →o β) :
    ((⨆ i, f i : α →o β) : α → β) = ⨆ i, (f i : α → β)
-- Mathlib/Data/Matrix/Block.lean
theorem fromBlocks_toBlocks (M : Matrix (n ⊕ o) (l ⊕ m) α) :
    fromBlocks M.toBlocks₁₁ M.toBlocks₁₂ M.toBlocks₂₁ M.toBlocks₂₂ = M
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp] lemma toMeasure_map (ν : FiniteMeasure Ω) (f : Ω → Ω') :
    (ν.map f).toMeasure = ν.toMeasure.map f