ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Star/StarRingHom.lean
theorem rightInverse_symm (e : A ≃⋆+* B) : Function.RightInverse e.symm e
-- Mathlib/Data/Fintype/Sigma.lean
lemma Set.biUnion_finsetSigma_univ' (s : Finset ι) (f : Π i, κ i → Set α) :
    ⋃ i ∈ s, ⋃ j, f i j = ⋃ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij.1 ij.2
-- Mathlib/Topology/Separation.lean
/-- The closure of a compact set in an R₁ space is a compact set. -/
protected theorem IsCompact.closure {K : Set X} (hK : IsCompact K) : IsCompact (closure K)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem filterMap_length_eq_length {l} :
    (filterMap f l).length = l.length ↔ ∀ a ∈ l, (f a).isSome
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem GoodProducts.max_eq_o_cons_tail (l : MaxProducts C ho) :
    l.val.val = (term I ho) :: l.val.Tail.val
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem comp_symm (e : A₁ ≃ₐ[R] A₂) : AlgHom.comp (e : A₁ →ₐ[R] A₂) ↑e.symm = AlgHom.id R A₂
-- Mathlib/Data/Multiset/Basic.lean
theorem mem_of_mem_filter {a : α} {s} (h : a ∈ filter p s) : a ∈ s
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem const_mul {f : α → 𝕜} (hf : Memℓp f p) (c : 𝕜) : Memℓp (fun x => c * f x) p
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma mem_mutuallySingularSetSlice (κ η : Kernel α γ) (a : α) (x : γ) :
    x ∈ mutuallySingularSetSlice κ η a ↔ 1 ≤ rnDerivAux κ (κ + η) a x
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem id_right (U : Under X) : CommaMorphism.right (𝟙 U) = 𝟙 U.right
-- Mathlib/Order/Monotone/Basic.lean
theorem strictMono_id [Preorder α] : StrictMono (id : α → α)
-- Mathlib/Algebra/Lie/Submodule.lean
theorem inclusion_apply {I₁ I₂ : LieIdeal R L} (h : I₁ ≤ I₂) (x : I₁) :
    inclusion h x = ⟨x.1, h x.2⟩
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma ofHom_neg (φ : F ⟶ G) :
    Cochain.ofHom (-φ) = -Cochain.ofHom φ
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] protected theorem «forall» {p : α ⊕ β → Prop} :
    (∀ x, p x) ↔ (∀ a, p (inl a)) ∧ ∀ b, p (inr b)
-- Mathlib/Data/PNat/Defs.lean
@[simp]
theorem toPNat'_zero : Nat.toPNat' 0 = 1
-- Mathlib/ModelTheory/Types.lean
theorem not_mem_iff (p : T.CompleteType α) (φ : L[[α]].Sentence) : φ.not ∈ p ↔ ¬φ ∈ p
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma opcyclesMap'_eq : opcyclesMap' φ h₁.right h₂.right = γ.right.φQ
-- Mathlib/Topology/MetricSpace/PiNat.lean
theorem cylinder_anti (x : ∀ n, E n) {m n : ℕ} (h : m ≤ n) : cylinder x n ⊆ cylinder x m
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_add_eq_of_leadingCoeff_add_ne_zero (h : leadingCoeff p + leadingCoeff q ≠ 0) :
    degree (p + q) = max p.degree q.degree
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_le {a b : Cardinal.{v}} : lift.{u, v} a ≤ lift.{u, v} b ↔ a ≤ b
-- Mathlib/Logic/Equiv/Fin.lean
theorem finSuccEquiv'_symm_coe_above {i : Fin (n + 1)} {m : Fin n} (h : i ≤ Fin.castSucc m) :
    (finSuccEquiv' i).symm m = m.succ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_of_neg_le_neg {a b : Int} (h : -b ≤ -a) : a ≤ b
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[ext]
lemma ext (z₁ z₂ : Cocycle F G n) (h : (z₁ : Cochain F G n) = z₂) : z₁ = z₂
-- Mathlib/NumberTheory/LSeries/Linearity.lean
@[simp]
lemma LSeries_smul (f : ℕ → ℂ) (c s : ℂ) : LSeries (c • f) s = c * LSeries f s
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem equiv_symm_eq_apply {X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} [HasMultiequalizer (S.index P)]
    (x : Meq P S) (I : S.Arrow) :
    Multiequalizer.ι (S.index P) I ((Meq.equiv P S).symm x) = x I
-- Mathlib/RingTheory/EuclideanDomain.lean
theorem span_gcd [DecidableEq α] (x y : α) :
    span ({gcd x y} : Set α) = span ({x, y} : Set α)
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive (attr := simp)]
theorem iterate_map_inv {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) :
    f^[n] x⁻¹ = (f^[n] x)⁻¹
-- Mathlib/Algebra/MvPolynomial/Polynomial.lean
theorem eval_polynomial_eval_finSuccEquiv {n : ℕ} {x : Fin n → R}
    [CommSemiring R] (f : MvPolynomial (Fin (n + 1)) R) (q : MvPolynomial (Fin n) R) :
    (eval x) (Polynomial.eval q (finSuccEquiv R n f)) = eval (Fin.cases (eval x q) x) f
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem Squarefree.gcd_right (a : α) {b : α} (hb : Squarefree b) : Squarefree (gcd a b)
-- Mathlib/Algebra/GroupWithZero/Semiconj.lean
lemma zpow_right₀ (h : Commute a b) : ∀ m : ℤ, Commute a (b ^ m)
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma isLocallyInjective_of_isLocallyInjective_of_isLocallySurjective_fac
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} {f₁ : F₁ ⟶ F₂} {f₂ : F₂ ⟶ F₃} (f₃ : F₁ ⟶ F₃) (fac : f₁ ≫ f₂ = f₃)
    [IsLocallyInjective J f₃] [IsLocallySurjective J f₁] :
    IsLocallyInjective J f₂
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem toDual_bihimp : toDual (a ⇔ b) = toDual a ∆ toDual b
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
protected theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b)
-- Mathlib/Topology/NhdsSet.lean
theorem disjoint_principal_nhdsSet : Disjoint (𝓟 s) (𝓝ˢ t) ↔ Disjoint (closure s) t
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_symmDiff (s t : Set α) (f : α → M) :
    mulIndicator (s ∆ t) f = mulIndicator (s \ t) f * mulIndicator (t \ s) f
-- Mathlib/Algebra/BigOperators/Ring.lean
@[simp, norm_cast]
lemma cast_multiset_prod [CommSemiring β] (s : Multiset ℕ) : (↑s.prod : β) = (s.map (↑)).prod
-- Mathlib/Algebra/DirectSum/Module.lean
/-- Scalar multiplication commutes with direct sums. -/
theorem mk_smul (s : Finset ι) (c : R) (x) : mk M s (c • x) = c • mk M s x
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
@[simp]
lemma withDensity_zero_left (f : α → ℝ≥0∞) : (0 : Measure α).withDensity f = 0
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem contDiffWithinAt_extend_coord_change [ChartedSpace H M] (hf : f ∈ maximalAtlas I M)
    (hf' : f' ∈ maximalAtlas I M) {x : E} (hx : x ∈ ((f'.extend I).symm ≫ f.extend I).source) :
    ContDiffWithinAt 𝕜 ⊤ (f.extend I ∘ (f'.extend I).symm) (range I) x
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem coe_quotQuotMkₐ : ⇑(quotQuotMkₐ R I J) = quotQuotMk I J
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem DifferentiableOn.arsinh (h : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => arsinh (f x)) s
-- Mathlib/Data/Sym/Basic.lean
@[simp, norm_cast] lemma coe_mk (s : Multiset α) (h : Multiset.card s = n) : mk s h = s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
theorem lcm_comm (m n : Nat) : lcm m n = lcm n m
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem summable_mul_left_iff (h : a ≠ 0) : (Summable fun i ↦ a * f i) ↔ Summable f
-- .lake/packages/lean4/src/lean/Init/Classical.lean
@[simp] theorem imp_iff_left_iff  : (b ↔ a → b) ↔ a ∨ b
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem mk_right (f : S ⟶ T.obj Y) : (mk f).right = Y
-- Mathlib/NumberTheory/PythagoreanTriples.lean
theorem isClassified_of_normalize_isPrimitiveClassified (hc : h.normalize.IsPrimitiveClassified) :
    h.IsClassified
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem id_tensor_π_preserves_coequalizer_inv_desc {W X Y Z : C} (f g : X ⟶ Y) (h : Z ⊗ Y ⟶ W)
    (wh : (Z ◁ f) ≫ h = (Z ◁ g) ≫ h) :
    (Z ◁ coequalizer.π f g) ≫
        (PreservesCoequalizer.iso (tensorLeft Z) f g).inv ≫ coequalizer.desc h wh =
      h
-- Mathlib/Order/Bounded.lean
theorem unbounded_gt_iff [LinearOrder α] : Unbounded (· > ·) s ↔ ∀ a, ∃ b ∈ s, b ≤ a
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp] lemma add_right_inj (μ ν₁ ν₂ : Measure α) [SigmaFinite μ] :
    μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
/-- Equivalent types give rise to multiplicatively equivalent free groups.

The converse can be found in `GroupTheory.FreeAbelianGroupFinsupp`,
as `Equiv.of_freeGroupEquiv`
 -/
@[to_additive (attr := simps apply)
  "Equivalent types give rise to additively equivalent additive free groups."]
def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
theorem pullback_lift_map_isPullback {X Y S X' Y' S' : C} (f : X ⟶ S) (g : Y ⟶ S) (f' : X' ⟶ S')
    (g' : Y' ⟶ S') (i₁ : X ⟶ X') (i₂ : Y ⟶ Y') (i₃ : S ⟶ S') (e₁ : f ≫ i₃ = i₁ ≫ f')
    (e₂ : g ≫ i₃ = i₂ ≫ g') [Mono i₃] :
    IsPullback (pullback.lift (pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂) (fst _ _) (lift_fst _ _ _))
      (pullback.lift (pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂) (snd _ _) (lift_snd _ _ _))
      (pullback.fst _ _) (pullback.fst _ _)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem hasSum_toReal {f : α → ℝ≥0∞} (hsum : ∑' x, f x ≠ ∞) :
    HasSum (fun x => (f x).toReal) (∑' x, (f x).toReal)
-- Mathlib/Probability/Kernel/Basic.lean
theorem restrict_apply' (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (ht : MeasurableSet t) :
    κ.restrict hs a t = (κ a) (t ∩ s)
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
@[simp]
lemma NNReal.nndist_zero_eq_val' (z : ℝ≥0) : nndist z 0 = z
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem subset_pointwise_smul_iff {g : G} {S T : ValuationSubring K} : S ≤ g • T ↔ g⁻¹ • S ≤ T
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem iterate_toEnd_mem_lowerCentralSeries₂ (x y : L) (m : M) (k : ℕ) :
    (toEnd R L M x ∘ₗ toEnd R L M y)^[k] m ∈
      lowerCentralSeries R L M (2 * k)
-- Mathlib/Topology/Compactness/Compact.lean
theorem not_compactSpace_iff : ¬CompactSpace X ↔ NoncompactSpace X
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem false_of_true_iff_false (h : True ↔ False) : False
-- Mathlib/Data/Set/Image.lean
theorem image_inter {f : α → β} {s t : Set α} (H : Injective f) : f '' (s ∩ t) = f '' s ∩ f '' t
-- Mathlib/RingTheory/IntegralDomain.lean
/-- A finite subgroup of the unit group of an integral domain is cyclic. -/
theorem isCyclic_of_subgroup_isDomain [Finite G] (f : G →* R) (hf : Injective f) : IsCyclic G
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem prod_isUnit : ∀ {L : List M}, (∀ m ∈ L, IsUnit m) → IsUnit L.prod
-- Mathlib/Data/Finset/NAry.lean
theorem image_image₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (image₂ f s t).image g = image₂ f' (s.image g₁) (t.image g₂)
-- Mathlib/NumberTheory/Multiplicity.lean
theorem pow_sub_pow (hyx : y < x) (hxy : p ∣ x - y) (hx : ¬p ∣ x) {n : ℕ} (hn : n ≠ 0) :
    padicValNat p (x ^ n - y ^ n) = padicValNat p (x - y) + padicValNat p n
-- Mathlib/Analysis/Seminorm.lean
private theorem isLUB_sSup (s : Set (Seminorm 𝕜 E)) (hs₁ : BddAbove s) (hs₂ : s.Nonempty) :
    IsLUB s (sSup s)
-- Mathlib/Algebra/CharP/Defs.lean
lemma spec : ∀ x : ℕ, (x : R) = 0 ↔ ringChar R ∣ x
-- Mathlib/Data/Finset/NAry.lean
lemma sup_image₂_right (g : γ → δ) : sup (image₂ f s t) g = sup t fun y ↦ sup s (g <| f · y)
-- Mathlib/Analysis/CstarAlgebra/Spectrum.lean
lemma norm_map (φ : F) (a : A) : ‖φ a‖ = ‖a‖
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem isPairSelfAdjoint_equiv (e : M₁ ≃ₗ[R] M) (f : Module.End R M) :
    IsPairSelfAdjoint B F f ↔
      IsPairSelfAdjoint (B.compl₁₂ ↑e ↑e) (F.compl₁₂ ↑e ↑e) (e.symm.conj f)
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem SeminormedCommGroup.mem_closure_iff :
    a ∈ closure s ↔ ∀ ε, 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[aesop safe 20 apply (rule_sets := [Measurable])]
protected theorem sup [SemilatticeSup β] [ContinuousSup β] (hf : AEStronglyMeasurable f μ)
    (hg : AEStronglyMeasurable g μ) : AEStronglyMeasurable (f ⊔ g) μ
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
@[simp]
theorem restrict_toMeasure_support [MeasurableSingletonClass α] (p : PMF α) :
    Measure.restrict (toMeasure p) (support p) = toMeasure p
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_Iio (r : β) : StrictConvex 𝕜 (Iio r)
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
@[simp]
lemma aeval_equivPolynomial {S : Type*} [CommRing S] [Algebra S R]
    (f : PolynomialModule S S) (x : R) :
    aeval x (equivPolynomial f) = eval x (map R (Algebra.linearMap S R) f)
-- Mathlib/Order/Atoms.lean
theorem IsCoatom.lt_iff (h : IsCoatom a) : a < x ↔ x = ⊤
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem toAlgHom_toLinearMap : (e : A₁ →ₐ[R] A₂).toLinearMap = e.toLinearMap
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_eq_empty (h : ¬a < b) : Ioc a b = ∅
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_mem_eq_toFinset_prod (f : α → M) (s : Set α) [Fintype s] :
    ∏ᶠ i ∈ s, f i = ∏ i ∈ s.toFinset, f i
-- Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean
theorem isPartition_splitCenter (I : Box ι) : IsPartition (splitCenter I)
-- Mathlib/Data/List/AList.lean
@[simp]
theorem singleton_entries (a : α) (b : β a) : (singleton a b).entries = [Sigma.mk a b]
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
@[simp]
theorem stereographic_neg_apply (v : sphere (0 : E) 1) :
    stereographic (norm_eq_of_mem_sphere (-v)) v = 0
-- Mathlib/Data/ENNReal/Inv.lean
@[simp]
theorem inv_lt_top {x : ℝ≥0∞} : x⁻¹ < ∞ ↔ 0 < x
-- Mathlib/Data/Fintype/BigOperators.lean
@[simp]
theorem card_vector [Fintype α] (n : ℕ) : Fintype.card (Vector α n) = Fintype.card α ^ n
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
lemma dist_anti_right_pi : AntitoneOn (dist x) (Iic x)
-- Mathlib/Topology/Connected/PathConnected.lean
/-- If a set `W` is path-connected, then it is also path-connected when seen as a set in a smaller
ambient type `U` (when `U` contains `W`). -/
theorem IsPathConnected.preimage_coe {U W : Set X} (hW : IsPathConnected W) (hWU : W ⊆ U) :
    IsPathConnected (((↑) : U → X) ⁻¹' W)
-- Mathlib/Data/DFinsupp/Basic.lean
@[to_additive]
theorem prod_add_index [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {f g : Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) : (f + g).prod h = f.prod h * g.prod h
-- Mathlib/Data/Nat/Defs.lean
lemma leRecOn_injective {C : ℕ → Sort*} {n m} (hnm : n ≤ m) (next : ∀ {k}, C k → C (k + 1))
    (Hnext : ∀ n, Injective (@next n)) : Injective (@leRecOn C n m hnm next)
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem fourier_one {x : AddCircle T} : fourier 1 x = toCircle x
-- Mathlib/CategoryTheory/GradedObject.lean
/-- Given a map `p : I → J`, this is the functor `GradedObject I C ⥤ GradedObject J C` which
sends an `I`-object `X` to the graded object `X.mapObj p` which in degree `j : J` is given
by the coproduct of those `X i` such that `p i = j`. -/
@[simps]
noncomputable def map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
    GradedObject I C ⥤ GradedObject J C
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive]
private theorem smul'_char (r₁ : R) (r₂ : X) (s₁ s₂ : S) (u : S) (v : R) (huv : u * r₁ = v * s₂) :
    OreLocalization.smul' r₁ s₁ r₂ s₂ = v • r₂ /ₒ (u * s₁)
-- Mathlib/LinearAlgebra/BilinearMap.lean
lemma lsmul_eq_DistribMulAction_toLinearMap (r : R) :
    lsmul R M r = DistribMulAction.toLinearMap R M r
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem symm_trans_apply (e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃) (x : A₃) :
    (e₁.trans e₂).symm x = e₁.symm (e₂.symm x)
-- Mathlib/Deprecated/Ring.lean
/-- The identity map is a ring homomorphism. -/
theorem id : IsRingHom (@id α)
-- Mathlib/Algebra/Group/Commute/Units.lean
@[to_additive]
lemma isUnit_pow_succ_iff : IsUnit (a ^ (n + 1)) ↔ IsUnit a
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- `m` is `s`-factored if and only if `m` is nonzero and all prime divisors `≤ m` of `m`
are in `s`. -/
lemma mem_factoredNumbers_iff_forall_le {s : Finset ℕ} {m : ℕ} :
    m ∈ factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ≤ m, p.Prime → p ∣ m → p ∈ s
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_eq' : a ∆ b = (a ⊔ b) ⊓ (aᶜ ⊔ bᶜ)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem dist_le_infDist_add_diam (hs : IsBounded s) (hy : y ∈ s) :
    dist x y ≤ infDist x s + diam s
-- Mathlib/GroupTheory/SpecificGroups/Dihedral.lean
theorem r_one_pow_n : r (1 : ZMod n) ^ n = 1
-- Mathlib/Order/Interval/Basic.lean
@[simp, norm_cast]
theorem coe_sInf [@DecidableRel α (· ≤ ·)] (S : Set (Interval α)) :
    ↑(sInf S) = ⋂ s ∈ S, (s : Set α)
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem zeroLocus_anti_mono {s t : Set R} (h : s ⊆ t) : zeroLocus t ⊆ zeroLocus s
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem mclosure_range (f : F) : closure (Set.range f) = mrange f
-- Mathlib/CategoryTheory/Monoidal/Category.lean
/-- The right whiskering of an isomorphism is an isomorphism. -/
@[simps!]
def whiskerRightIso {X Y : C} (f : X ≅ Y) (Z : C) : X ⊗ Z ≅ Y ⊗ Z
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncateFun_mul (x y : 𝕎 R) :
    truncateFun n (x * y) = truncateFun n x * truncateFun n y
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_dvd_gcd_mul_left (m n k : Nat) : gcd m n ∣ gcd (k * m) n
-- Mathlib/Data/Set/Accumulate.lean
theorem accumulate_subset_iUnion [Preorder α] (x : α) : Accumulate s x ⊆ ⋃ i, s i
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.dvdNotUnit_iff_lt {I J : Ideal A} : DvdNotUnit I J ↔ J < I
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem right_not_mem_Ioo : b ∉ Ioo a b
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem range_map [DecidableEq γ] (g : β → γ) (f : α →ₛ β) : (f.map g).range = f.range.image g
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma binaryBiproductTriangle_distinguished (X₁ X₂ : C) :
    binaryBiproductTriangle X₁ X₂ ∈ distTriang C
-- Mathlib/Data/Finset/Piecewise.lean
@[simp]
lemma piecewise_insert_of_ne [DecidableEq ι] {i j : ι} [∀ i, Decidable (i ∈ insert j s)]
    (h : i ≠ j) : (insert j s).piecewise f g i = s.piecewise f g i
-- Mathlib/Data/Fin/Basic.lean
/-- If `n` is non-zero, converting the value of a `Fin n` to `Fin n` results
in the same value.  -/
@[simp] theorem cast_val_eq_self {n : ℕ} [NeZero n] (a : Fin n) : (a.val : Fin n) = a
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
theorem top_apply' (s : Set α) : (⊤ : OuterMeasure α) s = ⨅ h : s = ∅, 0
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
/-- `OneMemClass S M` says `S` is a type of subsets `s ≤ M`, such that `1 ∈ s` for all `s`. -/
class OneMemClass (S : Type*) (M : Type*) [One M] [SetLike S M] : Prop where
  /-- By definition, if we have `OneMemClass S M`, we have `1 ∈ s` for all `s : S`. -/
  one_mem : ∀ s : S, (1 : M) ∈ s
-- Mathlib/CategoryTheory/Dialectica/Basic.lean
theorem comp_le_lemma {X Y Z : Dial C} (F : Dial.Hom X Y) (G : Dial.Hom Y Z) :
    (Subobject.pullback π(π₁, π(π₁, prod.map F.f (𝟙 _) ≫ G.F) ≫ F.F)).obj X.rel ≤
    (Subobject.pullback (prod.map (F.f ≫ G.f) (𝟙 Z.tgt))).obj Z.rel
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive min_le_of_add_le_two_nsmul]
theorem min_le_of_mul_le_sq {a b c : M} (h : a * b ≤ c ^ 2) : min a b ≤ c
-- Mathlib/Order/Bounds/Basic.lean
/-- The image under a monotone function on a set `t` of a subset which has a lower bound in `t`
  is bounded below. -/
theorem map_bddBelow (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    (lowerBounds s ∩ t).Nonempty → BddBelow (f '' s)
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
/-- A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapAction : MonoidalFunctor (Action V G) (Action W G)
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Iio_mem_nhdsSet_Ico (h : b ≤ c) : Iio c ∈ 𝓝ˢ (Ico a b)
-- Mathlib/Probability/Independence/ZeroOne.lean
/-- **Kolmogorov's 0-1 law**, kernel version: any event in the tail σ-algebra of an independent
sequence of sub-σ-algebras has probability 0 or 1 almost surely. -/
theorem Kernel.measure_zero_or_one_of_measurableSet_limsup_atBot (h_le : ∀ n, s n ≤ m0)
    (h_indep : iIndep s κ μα) {t : Set Ω} (ht_tail : MeasurableSet[limsup s atBot] t) :
    ∀ᵐ a ∂μα, κ a t = 0 ∨ κ a t = 1
-- Mathlib/Algebra/BigOperators/Group/List.lean
theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n
-- Mathlib/AlgebraicGeometry/Noetherian.lean
/-- A scheme is locally Noetherian if and only if it is covered by affine opens whose sections
are noetherian rings.

See [Har77], Proposition II.3.2. -/
theorem isLocallyNoetherian_iff_of_iSup_eq_top {ι} {S : ι → X.affineOpens}
    (hS : (⨆ i, S i : X.Opens) = ⊤) :
    IsLocallyNoetherian X ↔ ∀ i, IsNoetherianRing Γ(X, S i)
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem map_add_le (x y : V) : e (x + y) ≤ e x + e y
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem toNonUnitalSubring_inj {S U : NonUnitalSubalgebra R A} :
    S.toNonUnitalSubring = U.toNonUnitalSubring ↔ S = U
-- Mathlib/Order/CompleteLattice.lean
theorem iInf₂_eq_top {f : ∀ i, κ i → α} : ⨅ (i) (j), f i j = ⊤ ↔ ∀ i j, f i j = ⊤
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_div' (s : Set α) (f g : α → G) :
    mulIndicator s (f / g) = mulIndicator s f / mulIndicator s g
-- Mathlib/NumberTheory/RamificationInertia.lean
@[simp]
theorem Factors.piQuotientEquiv_map (p : Ideal R) (hp : map (algebraMap R S) p ≠ ⊥) (x : R) :
    Factors.piQuotientEquiv p hp (algebraMap _ _ x) = fun _ =>
      Ideal.Quotient.mk _ (algebraMap _ _ x)
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiableAt_id : MDifferentiableAt I I (@id M) x
-- Mathlib/Analysis/Complex/Angle.lean
/-- Chord-length is always less than arc-length. -/
lemma norm_sub_le_angle (hx : ‖x‖ = 1) (hy : ‖y‖ = 1) : ‖x - y‖ ≤ angle x y
-- Mathlib/Data/List/Lemmas.lean
theorem mapAccumr₂_eq_foldr {σ φ : Type*} (f : α → β → σ → σ × φ) :
    ∀ (as : List α) (bs : List β) (s : σ),
    mapAccumr₂ f as bs s = foldr (fun ab s =>
                              let r := f ab.1 ab.2 s.1
                              (r.1, r.2 :: s.2)
                            ) (s, []) (as.zip bs)
-- Mathlib/Data/NNRat/Defs.lean
@[norm_cast, simp]
theorem Rat.coe_nnabs (x : ℚ) : (Rat.nnabs x : ℚ) = abs x
-- Mathlib/CategoryTheory/Monoidal/Cartesian/Comon_.lean
@[simp] theorem counit_eq_from (A : Comon_ C) : A.counit = terminal.from A.X
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem trans_refl (e : α ≃o β) : e.trans (refl β) = e
-- Mathlib/GroupTheory/Torsion.lean
/-- Torsion submonoids are torsion. -/
@[to_additive "Additive torsion submonoids are additively torsion."]
theorem torsion.isTorsion : IsTorsion <| torsion G
-- Mathlib/Order/Filter/Basic.lean
theorem comap_injective {f : α → β} (hf : Surjective f) : Injective (comap f)
-- Mathlib/Data/Set/Card.lean
theorem finite_of_encard_eq_coe {k : ℕ} (h : s.encard = k) : s.Finite
-- Mathlib/RingTheory/ChainOfDivisors.lean
/-- The second element of a chain is irreducible. -/
theorem second_of_chain_is_irreducible {q : Associates M} {n : ℕ} (hn : n ≠ 0)
    {c : Fin (n + 1) → Associates M} (h₁ : StrictMono c) (h₂ : ∀ {r}, r ≤ q ↔ ∃ i, r = c i)
    (hq : q ≠ 0) : Irreducible (c 1)
-- Mathlib/Algebra/Homology/SingleHomology.lean
@[reassoc (attr := simp)]
lemma singleObjHomologySelfIso_hom_singleObjHomologySelfIso_inv :
    (singleObjCyclesSelfIso c j A).hom ≫ (singleObjHomologySelfIso c j A).inv =
      ((single C c j).obj A).homologyπ j
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp] lemma nil_nil : (nil : G.Walk u u).Nil
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem Reachable.elim_path {p : Prop} {u v : V} (h : G.Reachable u v)
    (hp : G.Path u v → p) : p
-- Mathlib/Algebra/Order/Floor.lean
@[simp] theorem floor_sub_one (a : α) : ⌊a - 1⌋ = ⌊a⌋ - 1
-- Mathlib/Logic/Equiv/Set.lean
protected theorem image_compl {α β} (f : Equiv α β) (s : Set α) : f '' sᶜ = (f '' s)ᶜ
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem total_onFinset {s : Finset α} {f : α → R} (g : α → M) (hf : ∀ a, f a ≠ 0 → a ∈ s) :
    Finsupp.total α M R g (Finsupp.onFinset s f hf) = Finset.sum s fun x : α => f x • g x
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := ext)]
theorem ext : (∀ x, p x = q x) → p = q
-- Mathlib/RingTheory/DedekindDomain/SInteger.lean
/-- The `R`-subalgebra of `S`-integers of `K`. -/
@[simps!]
def integer : Subalgebra R K