ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem product_singleton : ({a} : Multiset α) ×ˢ ({b} : Multiset β) = {(a, b)}
-- Mathlib/Data/Finset/Interval.lean
theorem Ico_eq_image_ssubsets (h : s ⊆ t) : Ico s t = (t \ s).ssubsets.image (s ∪ ·)
-- Mathlib/FieldTheory/RatFunc/Defs.lean
/-- `RatFunc.mk (p q : K[X])` is `p / q` as a rational function.

If `q = 0`, then `mk` returns 0.

This is an auxiliary definition used to define an `Algebra` structure on `RatFunc`;
the `simp` normal form of `mk p q` is `algebraMap _ _ p / algebraMap _ _ q`.
-/
protected irreducible_def mk (p q : K[X]) : RatFunc K
-- Mathlib/Algebra/Field/Subfield.lean
theorem gc_map_comap (f : K →+* L) : GaloisConnection (map f) (comap f)
-- Mathlib/Data/Nat/Factorization/Root.lean
/-- The RHS is a noncomputable version of `Nat.floorRoot` with better order theoretical
properties. -/
lemma floorRoot_def :
    floorRoot n a = if n = 0 ∨ a = 0 then 0 else (a.factorization ⌊/⌋ n).prod (· ^ ·)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem subgroupMap_symm_apply (e : G ≃* G') (H : Subgroup G) (g : H.map (e : G →* G')) :
    (e.subgroupMap H).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_compl (h₁ : MeasurableSet s) (h_fin : μ s ≠ ∞) : μ sᶜ = μ univ - μ s
-- Mathlib/RingTheory/TensorProduct/MvPolynomial.lean
lemma rTensor_apply_X_tmul (s : σ) (n : N) (d : σ →₀ ℕ) :
    rTensor (X s ⊗ₜ[R] n) d = if Finsupp.single s 1 = d then (1 : S) ⊗ₜ[R] n else 0
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem map_mul [MulHomClass F M N] (f : F) (x y : M) : f (x * y) = f x * f y
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
lemma log_inv {x : ℝ≥0∞} : log x⁻¹ = - log x
-- Mathlib/Order/LiminfLimsup.lean
theorem le_liminf_of_le {f : Filter β} {u : β → α} {a}
    (hf : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h : ∀ᶠ n in f, a ≤ u n) : a ≤ liminf u f
-- Mathlib/Topology/Basic.lean
/-- Complement to a singleton is dense if and only if the singleton is not an open set. -/
theorem dense_compl_singleton_iff_not_open :
    Dense ({x}ᶜ : Set X) ↔ ¬IsOpen ({x} : Set X)
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
theorem IsIntegralClosure.range_le_span_dualBasis [Algebra.IsSeparable K L] {ι : Type*} [Fintype ι]
    [DecidableEq ι] (b : Basis ι K L) (hb_int : ∀ i, IsIntegral A (b i)) [IsIntegrallyClosed A] :
    LinearMap.range ((Algebra.linearMap C L).restrictScalars A) ≤
    Submodule.span A (Set.range <| (traceForm K L).dualBasis (traceForm_nondegenerate K L) b)
-- Mathlib/SetTheory/Game/Impartial.lean
theorem fuzzy_zero_iff_gf : G ‖ 0 ↔ 0 ⧏ G
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖
-- Mathlib/Topology/Compactness/Compact.lean
theorem isCompact_iUnion {ι : Sort*} {f : ι → Set X} [Finite ι] (h : ∀ i, IsCompact (f i)) :
    IsCompact (⋃ i, f i)
-- Mathlib/Data/FunLike/Equiv.lean
protected theorem injective (e : E) : Function.Injective e
-- Mathlib/Control/Basic.lean
theorem CommApplicative.commutative_map {m : Type u → Type v} [h : Applicative m]
    [CommApplicative m] {α β γ} (a : m α) (b : m β) {f : α → β → γ} :
  f <$> a <*> b = flip f <$> b <*> a
-- Mathlib/CategoryTheory/Shift/CommShift.lean
@[reassoc (attr := simp)]
lemma commShiftIso_hom_naturality {X Y : C} (f : X ⟶ Y) (a : A) :
    F.map (f⟦a⟧') ≫ (F.commShiftIso a).hom.app Y =
      (F.commShiftIso a).hom.app X ≫ (F.map f)⟦a⟧'
-- Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean
/-- An additive character on `ZMod n` is nontrivial iff it takes a value `≠ 1` on `1`. -/
theorem zmod_char_ne_one_iff (n : ℕ) [NeZero n] (ψ : AddChar (ZMod n) C) : ψ ≠ 1 ↔ ψ 1 ≠ 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem get?_eq_some : l.get? n = some a ↔ ∃ h, get l ⟨n, h⟩ = a
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
@[simp]
theorem deriv_add_const' (c : F) : (deriv fun y => f y + c) = deriv f
-- Mathlib/Algebra/DirectSum/Decomposition.lean
theorem decompose_of_mem {x : M} {i : ι} (hx : x ∈ ℳ i) :
    decompose ℳ x = DirectSum.of (fun i ↦ ℳ i) i ⟨x, hx⟩
-- Mathlib/NumberTheory/NumberField/Units/Basic.lean
theorem coe_mul (x y : (𝓞 K)ˣ) : ((x * y : (𝓞 K)ˣ) : K) = (x : K) * (y : K)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem cauchySeq_iff {u : ℕ → α} :
    CauchySeq u ↔ ∀ V ∈ 𝓤 α, ∃ N, ∀ k ≥ N, ∀ l ≥ N, (u k, u l) ∈ V
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem isComplete_iUnion_separated {ι : Sort*} {s : ι → Set α} (hs : ∀ i, IsComplete (s i))
    {U : Set (α × α)} (hU : U ∈ 𝓤 α) (hd : ∀ (i j : ι), ∀ x ∈ s i, ∀ y ∈ s j, (x, y) ∈ U → i = j) :
    IsComplete (⋃ i, s i)
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem Fin.conjTranspose_circulant [Star α] :
    ∀ {n} (v : Fin n → α), (circulant v)ᴴ = circulant (star fun i => v (-i))
-- Mathlib/Data/Multiset/Bind.lean
theorem map_bind (m : Multiset α) (n : α → Multiset β) (f : β → γ) :
    map f (bind m n) = bind m fun a => map f (n a)
-- Mathlib/Topology/NoetherianSpace.lean
/-- In a Noetherian space, every closed set is a finite union of irreducible closed sets. -/
theorem NoetherianSpace.exists_finset_irreducible [NoetherianSpace α] (s : Closeds α) :
    ∃ S : Finset (Closeds α), (∀ k : S, IsIrreducible (k : Set α)) ∧ s = S.sup id
-- Mathlib/Computability/Partrec.lean
theorem option_getD {f : α → Option β} {g : α → β} (hf : Computable f) (hg : Computable g) :
    Computable fun a => (f a).getD (g a)
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma abs_le_one_iff_mul_self_le_one : |a| ≤ 1 ↔ a * a ≤ 1
-- Mathlib/Algebra/Algebra/Equiv.lean
protected theorem congr_arg {f : A₁ ≃ₐ[R] A₂} {x x' : A₁} : x = x' → f x = f x'
-- Mathlib/Order/Fin/Tuple.lean
lemma preimage_insertNth_Icc_of_mem {i : Fin (n + 1)} {x : α i} {q₁ q₂ : ∀ j, α j}
    (hx : x ∈ Icc (q₁ i) (q₂ i)) :
    i.insertNth x ⁻¹' Icc q₁ q₂ = Icc (fun j ↦ q₁ (i.succAbove j)) fun j ↦ q₂ (i.succAbove j)
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma pOpcyclesIso_hom_inv_id :
    K.pOpcycles j ≫ (K.pOpcyclesIso i j hi h).inv = 𝟙 _
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
lemma IsPointwiseRightKanExtensionAt.hasPointwiseRightKanExtensionAt
    {Y : D} (h : E.IsPointwiseRightKanExtensionAt Y) :
    HasPointwiseRightKanExtensionAt L F Y
-- Mathlib/Algebra/BigOperators/Ring.lean
lemma dvd_sum (h : ∀ i ∈ s, a ∣ f i) : a ∣ ∑ i ∈ s, f i
-- Mathlib/RingTheory/Presentation.lean
lemma ideal_fg_of_isFinite [P.IsFinite] : P.ker.FG
-- Mathlib/Order/CompleteLattice.lean
theorem Monotone.le_map_sSup [CompleteLattice β] {s : Set α} {f : α → β} (hf : Monotone f) :
    ⨆ a ∈ s, f a ≤ f (sSup s)
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- `D ⋙ forget T` has a limit, then `D` has a limit. -/
theorem hasLimit_of_comp_forget_hasLimit (D : J ⥤ Algebra T) [HasLimit (D ⋙ forget T)] :
    HasLimit D
-- Mathlib/Data/Int/Defs.lean
protected lemma mul_nonneg_iff_of_pos_right (hb : 0 < b) : 0 ≤ a * b ↔ 0 ≤ a
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- If `μ` is inner regular for finite measure sets with respect to compact sets,
then any measurable set of finite measure can be approximated by a compact closed subset.
Compared to `MeasurableSet.exists_isCompact_lt_add`,
this version additionally assumes that `α` is an R₁ space with Borel σ-algebra.
-/
theorem _root_.MeasurableSet.exists_isCompact_isClosed_lt_add
    [InnerRegularCompactLTTop μ] [R1Space α] [BorelSpace α]
    ⦃A : Set α⦄ (hA : MeasurableSet A) (h'A : μ A ≠ ∞) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∃ K, K ⊆ A ∧ IsCompact K ∧ IsClosed K ∧ μ A < μ K + ε
-- Mathlib/Analysis/Convex/Side.lean
theorem sSameSide_vadd_right_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.SSameSide x (v +ᵥ y) ↔ s.SSameSide x y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ_1728_of_two_eq_zero (h2 : (2 : F) = 0) :
    ofJ 1728 = @ofJ0 _ _ (invertibleOfNonzero <| two_or_three_ne_zero.neg_resolve_left h2)
-- Mathlib/SetTheory/Game/PGame.lean
theorem not_fuzzy_of_ge {x y : PGame} (h : y ≤ x) : ¬x ‖ y
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.dvd_of_dvd_mul_left_of_isPrimal (H1 : IsRelPrime x y) (H2 : x ∣ y * z)
    (h : IsPrimal x) : x ∣ z
-- Mathlib/Probability/Density.lean
/-- X `HasPDF` if there is a pdf `f` such that `map X ℙ = μ.withDensity f`. -/
theorem hasPDF_of_map_eq_withDensity {X : Ω → E} {ℙ : Measure Ω} {μ : Measure E}
    (hX : AEMeasurable X ℙ) (f : E → ℝ≥0∞) (hf : AEMeasurable f μ) (h : map X ℙ = μ.withDensity f) :
    HasPDF X ℙ μ
-- Mathlib/MeasureTheory/Function/SimpleFuncDense.lean
@[simp, nolint simpNF] -- Porting note: LHS doesn't simplify.
theorem approxOn_comp {γ : Type*} [MeasurableSpace γ] {f : β → α} (hf : Measurable f) {g : γ → β}
    (hg : Measurable g) {s : Set α} {y₀ : α} (h₀ : y₀ ∈ s) [SeparableSpace s] (n : ℕ) :
    approxOn (f ∘ g) (hf.comp hg) s y₀ h₀ n = (approxOn f hf s y₀ h₀ n).comp g hg
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem restrict_Ioc_eq_restrict_Icc : μ.restrict (Ioc a b) = μ.restrict (Icc a b)
-- Mathlib/Topology/Category/TopCat/Basic.lean
@[simp]
theorem coe_of (X : Type u) [TopologicalSpace X] : (of X : Type u) = X
-- Mathlib/Probability/Kernel/Basic.lean
protected theorem measurable_coe (κ : Kernel α β) {s : Set β} (hs : MeasurableSet s) :
    Measurable fun a => κ a s
-- Mathlib/Data/Nat/Factors.lean
theorem eq_two_pow_or_exists_odd_prime_and_dvd (n : ℕ) :
    (∃ k : ℕ, n = 2 ^ k) ∨ ∃ p, Nat.Prime p ∧ p ∣ n ∧ Odd p
-- Mathlib/Topology/Sets/Opens.lean
@[simp, norm_cast]
theorem coe_finset_sup (f : ι → Opens α) (s : Finset ι) : (↑(s.sup f) : Set α) = s.sup ((↑) ∘ f)
-- Mathlib/Data/DFinsupp/WellFounded.lean
theorem Lex.acc_single (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
    ∀ a, Acc (DFinsupp.Lex r s) (single i a)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem restrict_add (v w : VectorMeasure α M) (i : Set α) :
    (v + w).restrict i = v.restrict i + w.restrict i
-- Mathlib/Tactic/Positivity/Basic.lean
private lemma min_ne_of_lt_of_ne (ha : c < a) (hb : b ≠ c) : min a b ≠ c
-- Mathlib/Computability/Partrec.lean
nonrec theorem pair {f : α → β} {g : α → γ} (hf : Computable f) (hg : Computable g) :
    Computable fun a => (f a, g a)
-- Mathlib/Data/Real/EReal.lean
lemma mul_top_of_neg : ∀ {x : EReal}, x < 0 → x * ⊤ = ⊥
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
theorem continuous_of_continuous_eval [TopologicalSpace α] {g : α → WeakDual 𝕜 E}
    (h : ∀ y, Continuous fun a => (g a) y) : Continuous g
-- Mathlib/Algebra/Order/Group/Int.lean
theorem natAbs_abs (a : ℤ) : natAbs |a| = natAbs a
-- Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean
theorem injective_splitCenterBox (I : Box ι) : Injective I.splitCenterBox
-- Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean
/-- The non-zero `•`-divisors with `•` as right multiplication correspond with the non-zero
divisors. Note that the `MulOpposite` is needed because we defined `nonZeroDivisors` with
multiplication on the right. -/
lemma nonZeroSMulDivisors_mulOpposite_eq_op_nonZeroDivisors :
    Rᵐᵒᵖ ⁰[R] = R⁰.op
-- Mathlib/CategoryTheory/Sites/Coherent/CoherentTopology.lean
/--
Effective epi families in a precoherent category are transitive, in the sense that an
`EffectiveEpiFamily` and an `EffectiveEpiFamily` over each member, the composition is an
`EffectiveEpiFamily`.
Note: The finiteness condition is an artifact of the proof and is probably unnecessary.
-/
theorem EffectiveEpiFamily.transitive_of_finite {α : Type} [Finite α] {Y : α → C}
    (π : (a : α) → (Y a ⟶ X)) (h : EffectiveEpiFamily Y π) {β : α → Type} [∀ (a : α), Finite (β a)]
    {Y_n : (a : α) → β a → C} (π_n : (a : α) → (b : β a) → (Y_n a b ⟶ Y a))
    (H : ∀ a, EffectiveEpiFamily (Y_n a) (π_n a)) :
    EffectiveEpiFamily
      (fun (c : Σ a, β a) => Y_n c.fst c.snd) (fun c => π_n c.fst c.snd ≫ π c.fst)
-- Mathlib/Data/List/Lattice.lean
theorem subset_inter {l l₁ l₂ : List α} (h₁ : l ⊆ l₁) (h₂ : l ⊆ l₂) : l ⊆ l₁ ∩ l₂
-- Mathlib/Util/CompileInductive.lean
@[csimp] private theorem Float.val_eq : @Float.val = Float.valImpl
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem opNorm_smul_le {𝕜' : Type*} [NormedField 𝕜'] [NormedSpace 𝕜' F] [SMulCommClass 𝕜₂ 𝕜' F]
    (c : 𝕜') (f : E →SL[σ₁₂] F) : ‖c • f‖ ≤ ‖c‖ * ‖f‖
-- Mathlib/Algebra/Order/Monovary.lean
lemma Antivary.div_left₀ (hf₁ : 0 ≤ f₁) (hf₂ : StrongLT 0 f₂) (h₁ : Antivary f₁ g)
    (h₂ : Monovary f₂ g) : Antivary (f₁ / f₂) g
-- Mathlib/Data/Nat/Totient.lean
theorem totient_gcd_mul_totient_mul (a b : ℕ) : φ (a.gcd b) * φ (a * b) = φ a * φ b * a.gcd b
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
/-- `(1 : FractionalIdeal S P)` is defined as the R-submodule `f(R) ≤ P`.

However, this is not definitionally equal to `1 : Submodule R P`,
which is proved in the actual `simp` lemma `coe_one`. -/
theorem coe_one_eq_coeSubmodule_top : ↑(1 : FractionalIdeal S P) = coeSubmodule P (⊤ : Ideal R)
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
/-- The functor which maps `S : SnakeInput C` to the diagram
`S.L₀.X₁ ⟶ S.L₀.X₂ ⟶ S.L₀.X₃ ⟶ S.L₃.X₁ ⟶ S.L₃.X₂ ⟶ S.L₃.X₃`. -/
@[simps]
noncomputable def composableArrowsFunctor : SnakeInput C ⥤ ComposableArrows C 5
-- Mathlib/Topology/Constructions.lean
theorem nhds_eq (x : CofiniteTopology X) : 𝓝 x = pure x ⊔ cofinite
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_self (p : Prop) : (p ∧ p) = p
-- Mathlib/FieldTheory/PrimitiveElement.lean
theorem exists_primitive_element_of_finite_intermediateField
    [Finite (IntermediateField F E)] (K : IntermediateField F E) : ∃ α : E, F⟮α⟯ = K
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiag'_blockDiagonal' [DecidableEq o] (M : ∀ i, Matrix (m' i) (n' i) α) :
    blockDiag' (blockDiagonal' M) = M
-- Mathlib/Data/Matrix/Basic.lean
theorem star_dotProduct : star v ⬝ᵥ w = star (star w ⬝ᵥ v)
-- Mathlib/Data/Finsupp/Basic.lean
theorem filter_curry (f : α × β →₀ M) (p : α → Prop) [DecidablePred p] :
    (f.filter fun a : α × β => p a.1).curry = f.curry.filter p
-- Mathlib/Data/Fin/Basic.lean
theorem lt_castPred_succ_iff {a b : Fin (n + 1)} (ha : succ a ≠ last (n + 1)) :
    b < (succ a).castPred ha ↔ b ≤ a
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_iUnion_congr [Countable ι] {s : ι → Set α} :
    μ.restrict (⋃ i, s i) = ν.restrict (⋃ i, s i) ↔ ∀ i, μ.restrict (s i) = ν.restrict (s i)
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean
theorem hasPushout_of_preservesPushout [HasPushout f g] : HasPushout (G.map f) (G.map g)
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_add_of_principal_mul {o : Ordinal} (ho : Principal (· * ·) o) (ho₂ : o ≠ 2) :
    Principal (· + ·) o
-- Mathlib/CategoryTheory/Abelian/FunctorCategory.lean
/-- The abelian coimage in a functor category can be calculated componentwise. -/
@[simps!]
def coimageObjIso : (Abelian.coimage α).obj X ≅ Abelian.coimage (α.app X)
-- Mathlib/Algebra/AlgebraicCard.lean
theorem cardinal_mk_lift_le_max :
    Cardinal.lift.{u} #{ x : A // IsAlgebraic R x } ≤ max (Cardinal.lift.{v} #R) ℵ₀
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- A set is contained in its own closed thickening. -/
theorem self_subset_cthickening {δ : ℝ} (E : Set α) : E ⊆ cthickening δ E
-- Mathlib/Data/Finset/Image.lean
theorem map_filter {f : α ≃ β} {p : α → Prop} [DecidablePred p] :
    (s.filter p).map f.toEmbedding = (s.map f.toEmbedding).filter (p ∘ f.symm)
-- Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean
/-- Given a pullback in `C`, construct a binary product in `C/B`. -/
theorem over_binaryProduct_of_pullback [HasPullbacks C] {B : C} : HasBinaryProducts (Over B)
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncateFun_out (x : TruncatedWittVector p n R) : x.out.truncateFun n = x
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem strictMonoOn_projIcc : StrictMonoOn (projIcc a b h) (Icc a b)
-- Mathlib/CategoryTheory/PathCategory.lean
@[simp]
-- Porting note (#11215): TODO get rid of `(id X : C)` somehow?
theorem composePath_id {X : Paths C} : composePath (𝟙 X) = 𝟙 (id X : C)
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem forget_obj (R : CommRingCat) : (forget _).obj R = R
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem eq_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) {x y} : y = e.symm x ↔ e y = x
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_mk {a : α} {s nd} : a ∈ @Finset.mk α s nd ↔ a ∈ s
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem single_mul_single [Mul G] {a₁ a₂ : G} {b₁ b₂ : k} :
    single a₁ b₁ * single a₂ b₂ = single (a₁ * a₂) (b₁ * b₂)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
lemma completeSpace_prod_of_nonempty [UniformSpace β] [Nonempty α] [Nonempty β] :
    CompleteSpace (α × β) ↔ CompleteSpace α ∧ CompleteSpace β
-- Mathlib/RingTheory/Nakayama.lean
lemma top_ne_pointwise_smul_of_mem_jacobson_annihilator [Nontrivial M]
    [Module.Finite R M] {r} (h : r ∈ (Module.annihilator R M).jacobson) :
    (⊤ : Submodule R M) ≠ r • ⊤
-- Mathlib/Topology/Clopen.lean
theorem IsClopen.prod {t : Set Y} (hs : IsClopen s) (ht : IsClopen t) : IsClopen (s ×ˢ t)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
lemma regularityReduced_le : G.regularityReduced P ε δ ≤ G
-- Mathlib/Data/Int/CardIntervalMod.lean
/-- There are `⌈(b - v) / r⌉ - ⌈(a - v) / r⌉` numbers congruent to `v` mod `r` in `[a, b)`,
if `a ≤ b`. `Nat` version of `Int.Ico_filter_modEq_card`. -/
theorem Ico_filter_modEq_card (v : ℕ) : ((Ico a b).filter (· ≡ v [MOD r])).card =
    max (⌈(b - v) / (r : ℚ)⌉ - ⌈(a - v) / (r : ℚ)⌉) 0
-- .lake/packages/lean4/src/lean/Init/Control/StateCps.lean
@[simp] theorem runK_bind_get (f : σ → StateCpsT σ m β) (s : σ) (k : β → σ → m γ) : (get >>= f).runK s k = (f s).runK s k
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem omega_le_oadd (e n a) : ω ^ repr e ≤ repr (oadd e n a)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Squash.ind {α : Type u} {motive : Squash α → Prop} (h : ∀ (a : α), motive (Squash.mk a)) : ∀ (q : Squash α), motive q
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp]
lemma opcyclesMap_id [HasRightHomology S] :
    opcyclesMap (𝟙 S) = 𝟙 _
-- Mathlib/CategoryTheory/Triangulated/Subcategory.lean
lemma smul_mem_W_iff {X Y : C} (f : X ⟶ Y) (n : ℤˣ) :
    S.W (n • f) ↔ S.W f
-- Mathlib/Algebra/IsPrimePow.lean
theorem IsPrimePow.not_unit {n : R} (h : IsPrimePow n) : ¬IsUnit n
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem iterate_comp_eval₂ (k : ℕ) (t : S) :
    eval₂ f t (p.comp^[k] q) = (fun x => eval₂ f x p)^[k] (eval₂ f t q)
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_iInf_comap_of_surjective {ι : Sort*} (S : ι → Submodule R₂ M₂) :
    (⨅ i, (S i).comap f).map f = iInf S
-- Mathlib/CategoryTheory/Sites/CoverPreserving.lean
/-- `CompatiblePreserving` functors indeed preserve compatible families. -/
theorem Presieve.FamilyOfElements.Compatible.functorPushforward :
    (x.functorPushforward G).Compatible
-- Mathlib/SetTheory/Game/PGame.lean
theorem le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem mem_top {x : A} : x ∈ (⊤ : StarSubalgebra R A)
-- Mathlib/Algebra/Homology/QuasiIso.lean
lemma homotopyEquivalences_le_quasiIso [CategoryWithHomology C] :
    homotopyEquivalences C c ≤ quasiIso C c
-- Mathlib/Algebra/Module/Defs.lean
theorem add_smul : (r + s) • x = r • x + s • x
-- Mathlib/Algebra/Algebra/Hom.lean
theorem map_smul_of_tower {R'} [SMul R' A] [SMul R' B] [LinearMap.CompatibleSMul A B R' R] (r : R')
    (x : A) : φ (r • x) = r • φ x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma degree_norm_ne_one [IsDomain R] (x : W.CoordinateRing) :
    (Algebra.norm R[X] x).degree ≠ 1
-- Mathlib/Data/Multiset/Basic.lean
theorem mem_filter_of_mem {a : α} {l} (m : a ∈ l) (h : p a) : a ∈ filter p l
-- Mathlib/Analysis/Calculus/Deriv/Pow.lean
@[simp]
theorem deriv_pow' : (deriv fun x : 𝕜 => x ^ n) = fun x => (n : 𝕜) * x ^ (n - 1)
-- Mathlib/Init/Data/Int/Order.lean
theorem lt.elim {a b : ℤ} (h : a < b) {P : Prop} (h' : ∀ n : ℕ, a + ↑(Nat.succ n) = b → P) : P
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem mrange_mk : MonoidHom.mrange (@mk M N _ _) = ⊤
-- Mathlib/Logic/Function/Basic.lean
theorem comp_update {α' : Sort*} {β : Sort*} (f : α' → β) (g : α → α') (i : α) (v : α') :
    f ∘ update g i v = update (f ∘ g) i (f v)
-- Mathlib/RingTheory/LaurentSeries.lean
@[simp]
theorem coeff_coe_powerSeries (x : PowerSeries R) (n : ℕ) :
    HahnSeries.coeff (x : LaurentSeries R) n = PowerSeries.coeff R n x
-- Mathlib/NumberTheory/Cyclotomic/Three.lean
/-- We have that `η ^ 2 + η + 1 = 0`. -/
lemma eta_sq_add_eta_add_one : (η : 𝓞 K) ^ 2 + η + 1 = 0
-- Mathlib/Topology/MetricSpace/Equicontinuity.lean
/-- Characterization of uniform equicontinuity for families of functions taking values in a
(pseudo) metric space. -/
theorem uniformEquicontinuous_iff_right {ι : Type*} [UniformSpace β] {F : ι → β → α} :
    UniformEquicontinuous F ↔ ∀ ε > 0, ∀ᶠ xy : β × β in 𝓤 β, ∀ i, dist (F i xy.1) (F i xy.2) < ε
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem algEquivOfLinearEquivTripleTensorProduct_apply (f h_mul h_one x) :
    (algEquivOfLinearEquivTripleTensorProduct f h_mul h_one : (A ⊗[R] B) ⊗[R] C ≃ₐ[R] D) x = f x
-- Mathlib/CategoryTheory/Abelian/FunctorCategory.lean
theorem coimageImageComparison_app' :
    (coimageImageComparison α).app X =
      (coimageObjIso α X).hom ≫ coimageImageComparison (α.app X) ≫ (imageObjIso α X).inv
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem measure_zero_of_dimH_lt {μ : Measure X} {d : ℝ≥0} (h : μ ≪ μH[d]) {s : Set X}
    (hd : dimH s < d) : μ s = 0
-- Mathlib/Algebra/Quandle.lean
/-- The *adjoint action* of a rack on itself is `op'`, and the adjoint
action of `x ◃ y` is the conjugate of the action of `y` by the action
of `x`. It is another way to understand the self-distributivity axiom.

This is used in the natural rack homomorphism `toConj` from `R` to
`Conj (R ≃ R)` defined by `op'`.
-/
theorem ad_conj {R : Type*} [Rack R] (x y : R) : act' (x ◃ y) = act' x * act' y * (act' x)⁻¹
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem smul_mem (t : R) {x : L} (h : x ∈ L') : t • x ∈ L'
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem measure_ball_pos (x : X) {r : ℝ≥0∞} (hr : r ≠ 0) : 0 < μ (ball x r)
-- Mathlib/Order/Lattice.lean
@[gcongr]
theorem inf_le_inf_right (a : α) {b c : α} (h : b ≤ c) : b ⊓ a ≤ c ⊓ a
-- Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean
/-- A finite dimensional submodule over `ℝ` or `ℂ` is `Submodule.ClosedComplemented`. -/
lemma Submodule.ClosedComplemented.of_finiteDimensional (p : Submodule 𝕜 F)
    [FiniteDimensional 𝕜 p] : p.ClosedComplemented
-- Mathlib/Logic/Basic.lean
theorem lawful_beq_subsingleton {α : Type*} (inst1 : BEq α) (inst2 : BEq α)
    [@LawfulBEq α inst1] [@LawfulBEq α inst2] :
    inst1 = inst2
-- Mathlib/Analysis/Analytic/Within.lean
@[simp] lemma analyticWithinAt_univ {f : E → F} {x : E} :
    AnalyticWithinAt 𝕜 f univ x ↔ AnalyticAt 𝕜 f x
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem adjoin_eq_bot_iff : adjoin F S = ⊥ ↔ S ⊆ (⊥ : IntermediateField F E)
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem sub_self {X Y : C} (a : X ⟶ Y) : a - a = 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_div_pow_lt_one_div_pow_of_lt (a1 : 1 < a) {m n : ℕ} (mn : m < n) :
    1 / a ^ n < 1 / a ^ m
-- Mathlib/Logic/Function/Defs.lean
theorem RightInverse.surjective {f : α → β} {g : β → α} (h : RightInverse g f) : Surjective f
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
/-- Right-exactness of tensor product -/
lemma lTensor_mkQ (N : Submodule R M) :
    ker (lTensor Q (N.mkQ)) = range (lTensor Q N.subtype)
-- Mathlib/Algebra/Lie/BaseChange.lean
private theorem bracket_def (x : A ⊗[R] L) (m : A ⊗[R] M) : ⁅x, m⁆ = bracket' R A L M x m