ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
/-- See `rank_subsingleton` that assumes `Subsingleton R` instead. -/
theorem rank_subsingleton' [Subsingleton M] : Module.rank R M = 0
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
/-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `IsUnit f₁` and `IsUnit f₂`
to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem semiconj_of_isUnit_of_translationNumber_eq {f₁ f₂ : CircleDeg1Lift} (h₁ : IsUnit f₁)
    (h₂ : IsUnit f₂) (h : τ f₁ = τ f₂) : ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_of_lt_of_eq {n m k : Nat} : n < m → m = k → n < k
-- Mathlib/Order/CompleteLattice.lean
theorem le_iSup_inf_iSup (f g : ι → α) : ⨆ i, f i ⊓ g i ≤ (⨆ i, f i) ⊓ ⨆ i, g i
-- Mathlib/Order/Filter/Bases.lean
protected theorem HasBasis.neBot_iff (hl : l.HasBasis p s) :
    NeBot l ↔ ∀ {i}, p i → (s i).Nonempty
-- Mathlib/Algebra/Group/Hom/End.lean
/-- An `AddMonoidHom` preserves multiplication if pre- and post- composition with
`AddMonoidHom.mul` are equivalent. By converting the statement into an equality of
`AddMonoidHom`s, this lemma allows various specialized `ext` lemmas about `→+` to then be applied.
-/
theorem AddMonoidHom.map_mul_iff (f : R →+ S) :
    (∀ x y, f (x * y) = f x * f y) ↔
      (AddMonoidHom.mul : R →+ R →+ R).compr₂ f = (AddMonoidHom.mul.comp f).compl₂ f
-- Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean
@[simp]
theorem mk_pow {x : α} (hx : 0 ≤ x) (n : ℕ) :
    (⟨x, hx⟩ : { x : α // 0 ≤ x }) ^ n = ⟨x ^ n, pow_nonneg hx n⟩
-- Mathlib/AlgebraicGeometry/Noetherian.lean
lemma noetherianSpace_of_isAffineOpen (U : X.Opens) (hU : IsAffineOpen U)
    [IsNoetherianRing Γ(X, U)] :
    NoetherianSpace U
-- Mathlib/Algebra/Homology/ComplexShape.lean
theorem down'_mk {α : Type*} [AddRightCancelSemigroup α] (a : α) (i j : α) (h : j + a = i) :
    (down' a).Rel i j
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval₂_eq_eval_map (g : σ → S₁) (p : MvPolynomial σ R) : p.eval₂ f g = eval g (map f p)
-- Mathlib/Computability/Halting.lean
protected theorem cons {n m} {f : Vector ℕ n → ℕ} {g} (hf : @Partrec' n f) (hg : @Vec n m g) :
    Vec fun v => f v ::ᵥ g v
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem omega_zero : ∅ ∈ omega
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiffAt_diffeomorph_comp_iff {m} (h : M ≃ₘ^n⟮I, J⟯ N) {f : M' → M} (hm : m ≤ n) {x} :
    ContMDiffAt I' J m (h ∘ f) x ↔ ContMDiffAt I' I m f x
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem IsCompact.isLUB_sSup [ClosedIciTopology α] {s : Set α} (hs : IsCompact s)
    (ne_s : s.Nonempty) : IsLUB s (sSup s)
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
@[simp]
theorem log_exp (x : ℝ) : log (exp x) = x
-- Mathlib/Data/Fin/Basic.lean
theorem le_val_last (i : Fin (n + 1)) : i ≤ n
-- Mathlib/Data/Subtype.lean
theorem val_prop {S : Set α} (a : { a // a ∈ S }) : a.val ∈ S
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[norm_cast]
theorem coe_orderMonoidWithZeroHom_apply (f : α →+*o β) (a : α) : (f : α →*₀o β) a = f a
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem frobenius_nnnorm_map_eq (A : Matrix m n α) (f : α → β) (hf : ∀ a, ‖f a‖₊ = ‖a‖₊) :
    ‖A.map f‖₊ = ‖A‖₊
-- Mathlib/RingTheory/Smooth/StandardSmooth.lean
lemma IsStandardSmoothOfRelativeDimension.isStandardSmooth
    [IsStandardSmoothOfRelativeDimension.{t, w} n R S] :
    IsStandardSmooth.{t, w} R S
-- Mathlib/Data/Multiset/Basic.lean
theorem coe_replicate (n : ℕ) (a : α) : (List.replicate n a : Multiset α) = replicate n a
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem localization_comap_inducing [Algebra R S] (M : Submonoid R) [IsLocalization M S] :
    Inducing (comap (algebraMap R S))
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem tendsto_comp_exp_atBot {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto f (𝓝[>] 0) l
-- Mathlib/Order/CompleteLattice.lean
theorem up_sInf [InfSet α] (s : Set α) : up (sInf s) = sInf (ULift.down ⁻¹' s)
-- Mathlib/Order/Partition/Finpartition.lean
theorem mem_bot_iff : t ∈ (⊥ : Finpartition s).parts ↔ ∃ a ∈ s, {a} = t
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Memℒp.integrable_norm_rpow' [IsFiniteMeasure μ] {f : α → β} {p : ℝ≥0∞} (hf : Memℒp f p μ) :
    Integrable (fun x : α => ‖f x‖ ^ p.toReal) μ
-- Mathlib/RingTheory/FiniteType.lean
/-- An algebra over a commutative semiring is of `FiniteType` if it is finitely generated
over the base ring as algebra. -/
class Algebra.FiniteType [CommSemiring R] [Semiring A] [Algebra R A] : Prop where
  out : (⊤ : Subalgebra R A).FG
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem validFor : ∀ {s}, Valid s → ∃ l m r, ValidFor l m r s
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem ofReal_lt_ofReal_iff {p q : ℝ} (h : 0 < q) :
    ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem get_mem : ∀ {o : Option α} (h : isSome o), o.get h ∈ o
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp 1100]
theorem dNext_succ_chainComplex (f : ∀ i j, P.X i ⟶ Q.X j) (i : ℕ) :
    dNext (i + 1) f = P.d _ _ ≫ f i (i + 1)
-- Mathlib/Topology/Bornology/Basic.lean
theorem ext_iff_isBounded {t t' : Bornology α} :
    t = t' ↔ ∀ s, @IsBounded α t s ↔ @IsBounded α t' s
-- Mathlib/Data/Prod/PProd.lean
theorem Function.Injective.pprod_map {f : α → β} {g : γ → δ} (hf : Injective f) (hg : Injective g) :
    Injective (fun x ↦ ⟨f x.1, g x.2⟩ : PProd α γ → PProd β δ)
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- The cardinality of morphisms `A ⟶ X` is smaller than the cardinality of
the fiber of the target if the source is connected. -/
lemma card_hom_le_card_fiber_of_connected (A X : C) [IsConnected A] :
    Nat.card (A ⟶ X) ≤ Nat.card (F.obj X)
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.trans_left {w x y z : P} (h₁ : Wbtw R w y z) (h₂ : Wbtw R w x y) : Wbtw R w x z
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[simp, fun_prop]
theorem Differentiable.mul (ha : Differentiable 𝕜 a) (hb : Differentiable 𝕜 b) :
    Differentiable 𝕜 fun y => a y * b y
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiag_transpose (M : Matrix (m × o) (n × o) α) (k : o) :
    blockDiag Mᵀ k = (blockDiag M k)ᵀ
-- Mathlib/Order/Lattice.lean
theorem sup_eq_iff_inf_eq : a ⊔ b = b ↔ a ⊓ b = a
-- Mathlib/Topology/Separation.lean
theorem nhdsWithin_insert_of_ne [T1Space X] {x y : X} {s : Set X} (hxy : x ≠ y) :
    𝓝[insert y s] x = 𝓝[s] x
-- Mathlib/Data/Fin/Tuple/Sort.lean
/-- If the tuple `f` is not the same as `f ∘ sort f`, then `f` has a pair of strictly decreasing
entries. -/
theorem antitone_pair_of_not_sorted (h : f ≠ f ∘ sort f) : ∃ i j, i < j ∧ f j < f i
-- Mathlib/Algebra/Order/Sub/Canonical.lean
/-- See `lt_tsub_iff_left_of_le_of_le` for a weaker statement in a partial order. -/
protected theorem tsub_lt_tsub_iff_left_of_le (ha : AddLECancellable a) (hb : AddLECancellable b)
    (h : b ≤ a) : a - b < a - c ↔ c < b
-- Mathlib/Algebra/Order/Pointwise.lean
@[to_additive]
theorem sSup_inv (s : Set α) : sSup s⁻¹ = (sInf s)⁻¹
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- The `sSup` of a union of two sets is the max of the suprema of each subset, under the
assumptions that all sets are bounded above and nonempty. -/
theorem csSup_union (hs : BddAbove s) (sne : s.Nonempty) (ht : BddAbove t) (tne : t.Nonempty) :
    sSup (s ∪ t) = sSup s ⊔ sSup t
-- Mathlib/SetTheory/Ordinal/Basic.lean
/-- A well order `r` is order isomorphic to the set of ordinals smaller than `type r`. -/
@[simps]
def enumIso (r : α → α → Prop) [IsWellOrder α r] : Subrel (· < ·) (· < type r) ≃r r
-- Mathlib/CategoryTheory/Closed/Ideal.lean
/-- To show `i` is an exponential ideal it suffices to show that `A ⟹ iB` is "in" `D` for any `A` in
`C` and `B` in `D`.
-/
theorem ExponentialIdeal.mk' (h : ∀ (B : D) (A : C), (A ⟹ i.obj B) ∈ i.essImage) :
    ExponentialIdeal i
-- Mathlib/Data/Setoid/Partition.lean
/-- The equivalence classes of the equivalence relation defined by a partition of α equal
    the original partition. -/
theorem classes_mkClasses (c : Set (Set α)) (hc : IsPartition c) :
    (mkClasses c hc.2).classes = c
-- Mathlib/FieldTheory/Adjoin.lean
theorem subset_adjoin_of_subset_right {T : Set E} (H : T ⊆ S) : T ⊆ adjoin F S
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
/-- Given an open set `s` in a finite-dimensional real normed vector space, there exists a smooth
function with values in `[0, 1]` whose support is exactly `s`. -/
theorem IsOpen.exists_smooth_support_eq {s : Set E} (hs : IsOpen s) :
    ∃ f : E → ℝ, f.support = s ∧ ContDiff ℝ ⊤ f ∧ Set.range f ⊆ Set.Icc 0 1
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
protected lemma comp_zero {n₁ n₂ n₁₂ : ℤ} (z₁ : Cochain F G n₁)
    (h : n₁ + n₂ = n₁₂) : z₁.comp (0 : Cochain G K n₂) h = 0
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_min : a - min a b = a - b
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.refl : IsNormal id
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem inr_mul_inl [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M] (r : R) (m : M) :
    (inr m * inl r : tsze R M) = inr (m <• r)
-- Mathlib/Data/Nat/Factorization/Defs.lean
/-- The support of `n.factorization` is exactly `n.primeFactors`. -/
@[simp] lemma support_factorization (n : ℕ) : (factorization n).support = n.primeFactors
-- Mathlib/Analysis/Convex/Exposed.lean
protected theorem mono (hC : IsExposed 𝕜 A C) (hBA : B ⊆ A) (hCB : C ⊆ B) : IsExposed 𝕜 B C
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp] lemma mk_add (i j : NumDenSameDeg 𝒜 x) : mk (i + j) = mk i + mk j
-- Mathlib/RingTheory/WittVector/Verschiebung.lean
@[ghost_simps]
theorem ghostComponent_zero_verschiebung (x : 𝕎 R) : ghostComponent 0 (verschiebung x) = 0
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0
-- Mathlib/Analysis/PSeries.lean
theorem sum_condensed_le' (hf : ∀ ⦃m n⦄, 1 < m → m ≤ n → f n ≤ f m) (n : ℕ) :
    (∑ k ∈ range n, 2 ^ k • f (2 ^ (k + 1))) ≤ ∑ k ∈ Ico 2 (2 ^ n + 1), f k
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl) The natural transformation used to define the new cone -/
@[simps]
def γ : D ⋙ T.forget ⋙ ↑T ⟶ D ⋙ T.forget
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem equiv_apply : b.equiv b' e (b i) = b' (e i)
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
protected theorem neg {B : BilinForm R₁ M₁} (hB : B.IsSymm) : (-B).IsSymm
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem top_ne_ofReal {r : ℝ} : ∞ ≠ ENNReal.ofReal r
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem succ_zero : succ (0 : Cardinal) = 1
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
/-- See also `pow_left_strictMonoOn`. -/
@[to_additive nsmul_right_strictMono]  -- Porting note: nolint to_additive_doc
theorem pow_left_strictMono (hn : n ≠ 0) : StrictMono (· ^ n : M → M)
-- Mathlib/Topology/Connected/Basic.lean
theorem connectedComponentIn_nonempty_iff {x : α} {F : Set α} :
    (connectedComponentIn F x).Nonempty ↔ x ∈ F
-- Mathlib/Order/LiminfLimsup.lean
theorem liminf_le_limsup {f : Filter β} [NeBot f] {u : β → α}
    (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    liminf u f ≤ limsup u f
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_congr_measure {μ' : Measure α} (c c' : ℝ≥0∞) (hc : c ≠ ∞) (hc' : c' ≠ ∞)
    (hμ_le : μ ≤ c • μ') (hμ'_le : μ' ≤ c' • μ) (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ' T C') (f : α → E) :
    setToFun μ T hT f = setToFun μ' T hT' f
-- Mathlib/ModelTheory/Complexity.lean
theorem not_ex_isAtomic (φ : L.BoundedFormula α (n + 1)) : ¬φ.ex.IsAtomic
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem range_coe_union_infty : range ((↑) : X → OnePoint X) ∪ {∞} = univ
-- Mathlib/Topology/Sheaves/Stalks.lean
@[simp]
theorem stalkSpecializes_refl {C : Type*} [Category C] [Limits.HasColimits C] {X : TopCat}
    (F : X.Presheaf C) (x : X) : F.stalkSpecializes (specializes_refl x) = 𝟙 _
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
theorem polyOfInterest_vars_eq (n : ℕ) : (polyOfInterest p n).vars =
    ((p : 𝕄) ^ (n + 1) * (wittMul p (n + 1) + (p : 𝕄) ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
      X (0, n + 1) * rename (Prod.mk (1 : Fin 2)) (wittPolynomial p ℤ (n + 1)) -
      X (1, n + 1) * rename (Prod.mk (0 : Fin 2)) (wittPolynomial p ℤ (n + 1)))).vars
-- Mathlib/Topology/Baire/Lemmas.lean
/-- If a countable family of closed sets cover a dense `Gδ` set, then the union of their interiors
is dense. Formulated here with `⋃₀`. -/
theorem IsGδ.dense_sUnion_interior_of_closed {T : Set (Set X)} {s : Set X} (hs : IsGδ s)
    (hd : Dense s) (hc : T.Countable) (hc' : ∀ t ∈ T, IsClosed t) (hU : s ⊆ ⋃₀ T) :
    Dense (⋃ t ∈ T, interior t)
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem mem_asymm {x y : ZFSet} : x ∈ y → y ∉ x
-- Mathlib/Topology/MetricSpace/Polish.lean
/-- Given a closed embedding into a Polish space, the source space is also Polish. -/
theorem _root_.ClosedEmbedding.polishSpace [TopologicalSpace α] [TopologicalSpace β] [PolishSpace β]
    {f : α → β} (hf : ClosedEmbedding f) : PolishSpace α
-- Mathlib/LinearAlgebra/FreeModule/PID.lean
theorem eq_bot_of_generator_maximal_submoduleImage_eq_zero {N O : Submodule R M} (b : Basis ι R O)
    (hNO : N ≤ O) {ϕ : O →ₗ[R] R} (hϕ : ∀ ψ : O →ₗ[R] R, ¬ϕ.submoduleImage N < ψ.submoduleImage N)
    [(ϕ.submoduleImage N).IsPrincipal] (hgen : generator (ϕ.submoduleImage N) = 0) : N = ⊥
-- Mathlib/Data/Nat/Digits.lean
@[mono]
theorem ofDigits_monotone {p q : ℕ} (L : List ℕ) (h : p ≤ q) : ofDigits p L ≤ ofDigits q L
-- Mathlib/RepresentationTheory/Character.lean
@[simp]
theorem char_dual (V : FDRep k G) (g : G) : (of (dual V.ρ)).character g = V.character g⁻¹
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem Filter.EventuallyEq.fderivWithin_eq_nhds (h : f₁ =ᶠ[𝓝 x] f) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x
-- Mathlib/Data/Rel.lean
theorem core_subset : ((· ⊆ ·) ⇒ (· ⊆ ·)) r.core r.core
-- Mathlib/Data/Finset/Basic.lean
theorem choose_property (hp : ∃! a, a ∈ l ∧ p a) : p (choose p l hp)
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
@[simp] theorem H1LequivOfIsTrivial_H1_π_apply_apply
    [A.IsTrivial] (f : oneCocycles A) (x : Additive G) :
    H1LequivOfIsTrivial A (H1_π A f) x = f.1 (Additive.toMul x)
-- Mathlib/Order/Atoms.lean
@[simp]
theorem isAtom_iff [OrderBot α] [OrderBot β] (f : α ≃o β) (a : α) : IsAtom (f a) ↔ IsAtom a
-- Mathlib/Algebra/Lie/BaseChange.lean
@[simp]
private theorem bracket'_tmul (s t : A) (x : L) (m : M) :
    bracket' R A L M (s ⊗ₜ[R] x) (t ⊗ₜ[R] m) = (s * t) ⊗ₜ ⁅x, m⁆
-- Mathlib/Data/List/Infix.lean
lemma dropSlice_sublist (n m : ℕ) (l : List α) : l.dropSlice n m <+ l
-- Mathlib/Order/GaloisConnection.lean
theorem sInf_image2_eq_sInf_sSup (h₁ : ∀ b, GaloisConnection (l₁ b) (swap u b))
    (h₂ : ∀ a, GaloisConnection (toDual ∘ l₂ a) (u a ∘ ofDual)) :
    sInf (image2 u s t) = u (sInf s) (sSup t)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_smul (c : S₂) (f : M₁ →SL[σ₁₂] M₂) :
    ↑(c • f) = c • (f : M₁ →ₛₗ[σ₁₂] M₂)
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
lemma additive_of_full_essSurj_comp [Full F] [EssSurj F] (G : D ⥤ E)
    [(F ⋙ G).Additive] : G.Additive
-- Mathlib/Data/Seq/Computation.lean
theorem destruct_eq_think {s : Computation α} {s'} : destruct s = Sum.inr s' → s = think s'
-- Mathlib/Order/Concept.lean
@[simp]
theorem top_snd : (⊤ : Concept α β r).snd = intentClosure r univ
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem coe_Ioi (a : α) : ↑(Ioi a) = Set.Ioi a
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
/-- A Lie derivation `D` from the Lie `R`-algebra `L` to the `L`-module `M` is an `R`-linear map
that satisfies the Leibniz rule `D [a, b] = [a, D b] - [b, D a]`. -/
structure LieDerivation (R L M : Type*) [CommRing R] [LieRing L] [LieAlgebra R L]
    [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
    extends L →ₗ[R] M where
  protected leibniz' (a b : L) : toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, toLinearMap a⁆
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The strong pigeonhole principle for finitely many pigeons and pigeonholes.  Given a function `f`
between finite types `α` and `β` and a number `b` such that `card β • b ≤ card α`, there exists an
element `y : β` such that its preimage has at least `b` elements.
See also `Fintype.exists_lt_card_fiber_of_nsmul_lt_card` for a stronger statement. -/
theorem exists_le_card_fiber_of_nsmul_le_card [Nonempty β] (hb : card β • b ≤ card α) :
    ∃ y : β, b ≤ (univ.filter fun x => f x = y).card
-- Mathlib/Algebra/Module/Torsion.lean
/-- Quotienting by the torsion submodule gives a torsion-free module. -/
@[simp]
theorem torsion_eq_bot : torsion R (M ⧸ torsion R M) = ⊥
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem mem_source : x ∈ e.source ↔ proj x ∈ e.baseSet
-- Mathlib/CategoryTheory/SmallObject/Construction.lean
@[reassoc (attr := simp)]
lemma functorMapSrc_functorObjTop :
    functorMapSrc f πX πY φ hφ ≫ functorObjTop f πY = functorObjTop f πX ≫ φ
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueSet_eq_empty_iff : G.cliqueSet n = ∅ ↔ G.CliqueFree n
-- Mathlib/Order/Filter/AtTopBot.lean
theorem map_atBot_eq_of_gc [SemilatticeInf α] [SemilatticeInf β] {f : α → β} (g : β → α) (b' : β)
    (hf : Monotone f) (gc : ∀ a, ∀ b ≤ b', b ≤ f a ↔ g b ≤ a) (hgi : ∀ b ≤ b', f (g b) ≤ b) :
    map f atBot = atBot
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem AEMeasurable.isLUB {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α} {g : δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) (hg : ∀ᵐ b ∂μ, IsLUB { a | ∃ i, f i b = a } (g b)) :
    AEMeasurable g μ
-- Mathlib/Data/ZMod/Basic.lean
@[simp, norm_cast]
theorem cast_natCast' (k : ℕ) : (cast (k : ZMod n) : R) = k
-- Mathlib/Order/Atoms.lean
theorem isCoatom_singleton_compl (x : α) : IsCoatom ({x}ᶜ : Set α)
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.inter_left (l : List α) {t₁ t₂ : List α} (p : t₁ ~ t₂) : l ∩ t₁ = l ∩ t₂
-- Mathlib/Data/ZMod/Basic.lean
@[to_additive (attr := simp) existing nsmul_zmod_val_inv_nsmul]
lemma pow_zmod_val_inv_pow (hn : (Nat.card α).Coprime n) (a : α) :
    (a ^ (n⁻¹ : ZMod (Nat.card α)).val) ^ n = a
-- Mathlib/Topology/Metrizable/Uniformity.lean
theorem dist_ofPreNNDist_le (d : X → X → ℝ≥0) (dist_self : ∀ x, d x x = 0)
    (dist_comm : ∀ x y, d x y = d y x) (x y : X) :
    @dist X (@PseudoMetricSpace.toDist X (PseudoMetricSpace.ofPreNNDist d dist_self dist_comm)) x
        y ≤
      d x y
-- Mathlib/Data/Set/Image.lean
theorem _root_.Function.Injective.mem_set_image {f : α → β} (hf : Injective f) {s : Set α} {a : α} :
    f a ∈ f '' s ↔ a ∈ s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfcHom_closedEmbedding :
    ClosedEmbedding <| (cfcHom ha : C(spectrum R a, R) →⋆ₐ[R] A)
-- Mathlib/Data/Fin/Tuple/Curry.lean
@[simp low]
theorem uncurry_apply_succ {n : ℕ} {p : Fin (n + 1) → Type u} {τ : Type u}
    (f : Function.FromTypes p τ) (args : (i : Fin (n + 1)) → p i) :
    uncurry f args = uncurry (f (args 0)) (Fin.tail args)
-- Mathlib/Data/Finset/Pairwise.lean
theorem PairwiseDisjoint.elim_finset {s : Set ι} {f : ι → Finset α} (hs : s.PairwiseDisjoint f)
    {i j : ι} (hi : i ∈ s) (hj : j ∈ s) (a : α) (hai : a ∈ f i) (haj : a ∈ f j) : i = j
-- Mathlib/Algebra/Homology/Additive.lean
@[simp]
theorem sub_f_apply (f g : C ⟶ D) (i : ι) : (f - g).f i = f.f i - g.f i
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma not_even_bit1 (n : ℕ) : ¬Even (2 * n + 1)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem Subset.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ ⊆ l₂) (h₂ : l₂ ⊆ l₃) : l₁ ⊆ l₃
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- `m` is `n`-smooth if and only if `m` is nonzero and all prime divisors `≤ m` of `m`
are less than `n`. -/
lemma mem_smoothNumbers_iff_forall_le {n m : ℕ} :
    m ∈ smoothNumbers n ↔ m ≠ 0 ∧ ∀ p ≤ m, p.Prime → p ∣ m → p < n
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_top : (⊤ : L.Formula α).Realize v ↔ True
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem yz_succ_succ (n) : yz a1 (n + 2) = (2 * a : ℕ) * yz a1 (n + 1) - yz a1 n
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem nnnorm_def (a : 𝓜(𝕜, A)) : ‖a‖₊ = ‖toProdHom a‖₊
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem IsCompact.sInf_mem [ClosedIicTopology α] {s : Set α} (hs : IsCompact s)
    (ne_s : s.Nonempty) : sInf s ∈ s
-- Mathlib/RingTheory/Adjoin/Basic.lean
/-- Two algebra morphisms are equal on `Algebra.span s`iff they are equal on s -/
theorem eqOn_adjoin_iff {φ ψ : A →ₐ[R] B} {s : Set A}  :
    Set.EqOn φ ψ (adjoin R s) ↔ Set.EqOn φ ψ s
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem condCDF_ae_eq (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (r : ℚ) :
    (fun a ↦ condCDF ρ a r) =ᵐ[ρ.fst] fun a ↦ (preCDF ρ r a).toReal
-- Mathlib/Data/Finsupp/Antidiagonal.lean
@[simp]
theorem antidiagonal_zero : antidiagonal (0 : α →₀ ℕ) = singleton (0, 0)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Multiplying the first vector passed to `oangle` by a positive real does not change the
angle. -/
@[simp]
theorem oangle_smul_left_of_pos (x y : V) {r : ℝ} (hr : 0 < r) :
    o.oangle (r • x) y = o.oangle x y
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem map_range_eq_span_tprod :
    LinearMap.range (map f) =
      Submodule.span R {t | ∃ (m : Π i, s i), tprod R (fun i ↦ f i (m i)) = t}
-- Mathlib/Data/Complex/Exponential.lean
theorem cos_pos_of_le_one {x : ℝ} (hx : |x| ≤ 1) : 0 < cos x
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem ext_abs_arg {x y : ℂ} (h₁ : abs x = abs y) (h₂ : x.arg = y.arg) : x = y
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A vector added to the second point lies in the affine span of two points if and only if it is
a multiple of their difference. -/
theorem vadd_right_mem_affineSpan_pair {p₁ p₂ : P} {v : V} :
    v +ᵥ p₂ ∈ line[k, p₁, p₂] ↔ ∃ r : k, r • (p₁ -ᵥ p₂) = v
-- Mathlib/Data/Set/Sups.lean
@[simp]
theorem infs_eq_empty : s ⊼ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Order/Filter/Lift.lean
theorem lift'_inf_principal_eq {h : Set α → Set β} {s : Set β} :
    f.lift' h ⊓ 𝓟 s = f.lift' fun t => h t ∩ s
-- Mathlib/Data/Set/Finite.lean
@[simp]
theorem Finite.toFinset_insert [DecidableEq α] {s : Set α} {a : α} (hs : (insert a s).Finite) :
    hs.toFinset = insert a (hs.subset <| subset_insert _ _).toFinset
-- Mathlib/SetTheory/Game/Basic.lean
theorem zero_lf_inv' : ∀ x : PGame, 0 ⧏ inv' x
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_multiplicative : 𝓤 (Multiplicative α) = (𝓤 α).map (Prod.map ofAdd ofAdd)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem mem_sup_right {S T : NonUnitalSubalgebra R A} : ∀ {x : A}, x ∈ T → x ∈ S ⊔ T
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem lcongr_apply_apply {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) (f : ι →₀ M) (k : κ) :
    lcongr e₁ e₂ f k = e₂ (f (e₁.symm k))
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem functorPushforward_union (S R : Sieve X) :
    (S ⊔ R).functorPushforward F = S.functorPushforward F ⊔ R.functorPushforward F
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_eq_ring_closure (s : Set A) :
    (adjoin R s).toSubring = Subring.closure (Set.range (algebraMap R A) ∪ s)
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp]
lemma opcyclesMap'_id (h : S.RightHomologyData) :
    opcyclesMap' (𝟙 S) h h = 𝟙 _
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma not_boundaryLE_prev' [e.IsRelIff] {i j : ι} (hj : ¬ e.BoundaryLE j) (hk : c.prev j = i) :
    ¬ e.BoundaryLE i
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
@[simp]
lemma scaleRoots_C (r c : R) : (C c).scaleRoots r = C c
-- Mathlib/Data/Finset/Grade.lean
lemma covBy_iff_exists_erase : s ⋖ t ↔ ∃ a ∈ t, t.erase a = s
-- Mathlib/MeasureTheory/Integral/Marginal.lean
theorem _root_.Measurable.lmarginal (hf : Measurable f) : Measurable (∫⋯∫⁻_s, f ∂μ)