ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Instances/NNReal.lean
theorem summable_nat_add (f : ℕ → ℝ≥0) (hf : Summable f) (k : ℕ) : Summable fun i => f (i + k)
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map₂Right'_cons_cons :
    map₂Right' f (a :: as) (b :: bs) =
      let r := map₂Right' f as bs
      (f (some a) b :: r.fst, r.snd)
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem of_natCast {α} [AddMonoidWithOne α] (n : ℕ) : ((n : Num) : α) = n
-- .lake/packages/lean4/src/lean/Init/Grind/Norm.lean
@[grind_norm] theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b
-- Mathlib/RingTheory/Multiplicity.lean
theorem finite_mul {p a b : α} (hp : Prime p) : Finite p a → Finite p b → Finite p (a * b)
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_image_right (f : α → γ → δ) (g : β → γ) :
    image₂ f s (t.image g) = image₂ (fun a b => f a (g b)) s t
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The category of bicones on a given diagram. -/
@[simps]
instance Bicone.category : Category (Bicone F)
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem inter_div_union_subset_union : s₁ ∩ s₂ / (t₁ ∪ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem innerContent_le (U : Opens G) (K : Compacts G) (h2 : (U : Set G) ⊆ K) :
    μ.innerContent U ≤ μ K
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_right (h : s.Nonempty) : image2 (fun _ y => y) s t = t
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem range_toProdMulOpposite :
    Set.range toProdMulOpposite =
      { lr : (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ | ∀ x y, unop lr.2 x * y = x * lr.1 y }
-- Mathlib/Logic/Basic.lean
theorem em' (p : Prop) : ¬p ∨ p
-- Mathlib/Algebra/Order/Archimedean.lean
theorem archimedean_iff_int_le : Archimedean α ↔ ∀ x : α, ∃ n : ℤ, x ≤ n
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- Canonical isomorphism between linear combinations and the span of linearly independent vectors.
-/
@[simps (config := { rhsMd := default }) symm_apply]
def LinearIndependent.totalEquiv (hv : LinearIndependent R v) :
    (ι →₀ R) ≃ₗ[R] span R (range v)
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
protected theorem Continuous.inversion (hc : Continuous c) (hR : Continuous R) (hx : Continuous x)
    (hne : ∀ a, x a ≠ c a) : Continuous (fun a ↦ inversion (c a) (R a) (x a))
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
lemma measurable_preCDF' {ρ : Measure (α × ℝ)} :
    Measurable fun a r ↦ (preCDF ρ r a).toReal
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.mul_right_iff : IsCoprime x (y * z) ↔ IsCoprime x y ∧ IsCoprime x z
-- Mathlib/Topology/Order/Basic.lean
/-- The set of points which are isolated on the left is countable when the space is
second-countable. -/
theorem countable_setOf_covBy_left [OrderTopology α] [SecondCountableTopology α] :
    Set.Countable { x : α | ∃ y, y ⋖ x }
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
theorem isSheaf_iff_isSheaf_comp (s : A ⥤ B) [HasLimitsOfSize.{v₁, max v₁ u₁} A]
    [PreservesLimitsOfSize.{v₁, max v₁ u₁} s] [s.ReflectsIsomorphisms] :
    IsSheaf J P ↔ IsSheaf J (P ⋙ s)
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
theorem mono_iff_injective_of_preservesPullback {X Y : C} (f : X ⟶ Y)
    [PreservesLimitsOfShape WalkingCospan (forget C)] : Mono f ↔ Function.Injective f
-- Mathlib/Algebra/ContinuedFractions/Computation/ApproximationCorollaries.lean
theorem of_convergence_epsilon :
    ∀ ε > (0 : K), ∃ N : ℕ, ∀ n ≥ N, |v - (of v).convs n| < ε
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem ne_zero_of_mul_eq_one (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) : I ≠ 0
-- Mathlib/NumberTheory/WellApproximable.lean
@[to_additive mem_approx_add_orderOf_iff]
theorem mem_approxOrderOf_iff {A : Type*} [SeminormedGroup A] {n : ℕ} {δ : ℝ} {a : A} :
    a ∈ approxOrderOf A n δ ↔ ∃ b : A, orderOf b = n ∧ a ∈ ball b δ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem natAbs_eq_zero : natAbs a = 0 ↔ a = 0
-- Mathlib/Topology/Order/ExtrClosure.lean
protected theorem IsMaxOn.closure (h : IsMaxOn f s a) (hc : ContinuousOn f (closure s)) :
    IsMaxOn f (closure s) a
-- Mathlib/Topology/Bases.lean
/-- A topological space with discrete topology is separable iff it is countable. -/
theorem separableSpace_iff_countable [DiscreteTopology α] : SeparableSpace α ↔ Countable α
-- Mathlib/Logic/Equiv/Set.lean
theorem coe_ofInjective_symm {α β} {f : α → β} (hf : Injective f) :
    ((ofInjective f hf).symm : range f → α) = rangeSplitting f
-- Mathlib/Order/WellFoundedSet.lean
theorem isPWO_iff_exists_monotone_subseq :
    s.IsPWO ↔ ∀ f : ℕ → α, (∀ n, f n ∈ s) → ∃ g : ℕ ↪o ℕ, Monotone (f ∘ g)
-- Mathlib/RingTheory/EuclideanDomain.lean
theorem dvd_or_coprime (x y : α) (h : Irreducible x) :
    x ∣ y ∨ IsCoprime x y
-- Mathlib/Algebra/Ring/Action/Invariant.lean
@[simp]
theorem IsInvariantSubring.coe_subtypeHom :
    (IsInvariantSubring.subtypeHom M U : U → R') = Subtype.val
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
protected theorem OpenEmbedding.measurableEmbedding {f : α → β} (h : OpenEmbedding f) :
    MeasurableEmbedding f
-- Mathlib/Data/Prod/TProd.lean
@[ext]
theorem ext :
    ∀ {l : List ι} (_ : l.Nodup) {v w : TProd α l}
      (_ : ∀ (i) (hi : i ∈ l), v.elim hi = w.elim hi), v = w
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem self_trans_symm (f : M₁ ≃ₛₗ[σ₁₂] M₂) : f.trans f.symm = LinearEquiv.refl R₁ M₁
-- Mathlib/Topology/Order/LeftRight.lean
theorem continuousWithinAt_Iio_iff_Iic {a : α} {f : α → β} :
    ContinuousWithinAt f (Iio a) a ↔ ContinuousWithinAt f (Iic a) a
-- Mathlib/Data/Finset/Finsupp.lean
/-- When `t` is supported on `s`, `f ∈ s.finsupp t` precisely means that `f` is pointwise in `t`. -/
@[simp]
theorem mem_finsupp_iff_of_support_subset {t : ι →₀ Finset α} (ht : t.support ⊆ s) :
    f ∈ s.finsupp t ↔ ∀ i, f i ∈ t i
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The sup of the directions of two nonempty affine subspaces with empty intersection is less than
the direction of their sup. -/
theorem sup_direction_lt_of_nonempty_of_inter_empty {s1 s2 : AffineSubspace k P}
    (h1 : (s1 : Set P).Nonempty) (h2 : (s2 : Set P).Nonempty) (he : (s1 ∩ s2 : Set P) = ∅) :
    s1.direction ⊔ s2.direction < (s1 ⊔ s2).direction
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
@[simp]
theorem IsSymm.sub {A B : Matrix n n α} [Sub α] (hA : A.IsSymm) (hB : B.IsSymm) : (A - B).IsSymm
-- Mathlib/Data/Option/Basic.lean
@[simp]
lemma bnot_isNone (a : Option α) : (! a.isNone) = a.isSome
-- Mathlib/Analysis/Convex/AmpleSet.lean
/-- Pre-images of ample sets under continuous affine equivalences are ample. -/
theorem preimage {s : Set F} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F) : AmpleSet (L ⁻¹' s)
-- Mathlib/Combinatorics/SetFamily/Shadow.lean
/-- The upper shadow of the empty set is empty. -/
@[simp]
theorem upShadow_empty : ∂⁺ (∅ : Finset (Finset α)) = ∅
-- Mathlib/Topology/Bases.lean
theorem IsTopologicalBasis.open_iff_eq_sUnion {B : Set (Set α)} (hB : IsTopologicalBasis B)
    {u : Set α} : IsOpen u ↔ ∃ S ⊆ B, u = ⋃₀ S
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem le_lt_asymm {x y : Int} (h₁ : y ≤ x) (h₂ : x < y) : False
-- Mathlib/Analysis/Normed/Group/Bounded.lean
@[to_additive isBounded_iff_forall_norm_le]
lemma isBounded_iff_forall_norm_le' : Bornology.IsBounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C
-- Mathlib/Data/Ordmap/Ordset.lean
theorem rotateR_node (sz : ℕ) (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α) :
    rotateR (node sz l x m) y r =
      if size m < ratio * size l then node3R l x m y r else node4R l x m y r
-- Mathlib/Data/Seq/Computation.lean
theorem liftRel_map {δ} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Computation α}
    {s2 : Computation β} {f1 : α → γ} {f2 : β → δ} (h1 : LiftRel R s1 s2)
    (h2 : ∀ {a b}, R a b → S (f1 a) (f2 b)) : LiftRel S (map f1 s1) (map f2 s2)
-- Mathlib/CategoryTheory/WithTerminal.lean
@[aesop safe destruct (rule_sets := [CategoryTheory])]
lemma false_of_to_star {X : C} (f : of X ⟶ star) : False
-- Mathlib/Analysis/Convex/Function.lean
/-- Left translation preserves concavity. -/
theorem ConcaveOn.translate_left (hf : ConcaveOn 𝕜 s f) (c : E) :
    ConcaveOn 𝕜 ((fun z => c + z) ⁻¹' s) (f ∘ fun z => z + c)
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bodd_bit (b n) : bodd (bit b n) = b
-- Mathlib/Algebra/Ring/Defs.lean
theorem two_mul (n : α) : 2 * n = n + n
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem ucs_eq_self_of_normalizer_eq_self (h : N₁.normalizer = N₁) (k : ℕ) : N₁.ucs k = N₁
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem map_inl (f : M →ₗ[R'] N) (r : R') : map f (inl r) = inl r
-- Mathlib/Analysis/Convex/Segment.lean
theorem segment_subset_iff :
    [x -[𝕜] y] ⊆ s ↔ ∀ a b : 𝕜, 0 ≤ a → 0 ≤ b → a + b = 1 → a • x + b • y ∈ s
-- Mathlib/Analysis/Convex/Gauge.lean
@[deprecated gauge_ball (since := "2023-07-24")]
theorem gauge_ball' (hr : 0 < r) (x : E) : gauge (ball (0 : E) r) x = ‖x‖ / r
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
theorem mkPiRing_eq_iff {z₁ z₂ : M} :
    ContinuousMultilinearMap.mkPiRing R ι z₁ = ContinuousMultilinearMap.mkPiRing R ι z₂ ↔
      z₁ = z₂
-- Mathlib/Order/Filter/SmallSets.lean
theorem eventually_smallSets' {p : Set α → Prop} (hp : ∀ ⦃s t⦄, s ⊆ t → p t → p s) :
    (∀ᶠ s in l.smallSets, p s) ↔ ∃ s ∈ l, p s
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem cancel_left {g : SupBotHom β γ} {f₁ f₂ : SupBotHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Probability/CondCount.lean
@[simp]
theorem condCount_empty_meas : (condCount ∅ : Measure Ω) = 0
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
@[simp]
theorem opensRange_fromSpec : Scheme.Hom.opensRange hU.fromSpec = U
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, norm_cast]
lemma ofReal_lt_zero {x : ℝ} : (x : K) < 0 ↔ x < 0
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Name.lean
@[simp] theorem quickCmpAux_iff_eq : ∀ {n n'}, quickCmpAux n n' = .eq ↔ n = n'
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop (e : α ≃o β) : Tendsto e atTop atTop
-- Mathlib/Data/Fintype/Basic.lean
theorem image_univ_of_surjective [Fintype β] {f : β → α} (hf : Surjective f) :
    univ.image f = univ
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem cthickening_mem_nhdsSet (E : Set α) {δ : ℝ} (hδ : 0 < δ) : cthickening δ E ∈ 𝓝ˢ E
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma Algebra.intTrace_eq_trace [Module.Free A B] : Algebra.intTrace A B = Algebra.trace A B
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma totalShift₂Iso_hom_naturality [L.HasTotal (up ℤ)] :
    total.map ((shiftFunctor₂ C y).map f) (up ℤ) ≫ (L.totalShift₂Iso y).hom =
      (K.totalShift₂Iso y).hom ≫ (total.map f (up ℤ))⟦y⟧'
-- Mathlib/Analysis/Normed/Module/Ray.lean
/-- Two nonzero vectors `x y` in a real normed space are on the same ray if and only if the unit
vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
    SameRay ℝ x y ↔ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma isIso_opcyclesMap_of_isIso_of_epi' (φ : S₁ ⟶ S₂) (h₂ : IsIso φ.τ₂) (h₁ : Epi φ.τ₁)
    [S₁.HasRightHomology] [S₂.HasRightHomology] :
    IsIso (opcyclesMap φ)
-- Mathlib/Topology/Defs/Induced.lean
/-- A function `f : X → Y` between topological spaces is inducing if the topology on `X` is induced
by the topology on `Y` through `f`, meaning that a set `s : Set X` is open iff it is the preimage
under `f` of some open set `t : Set Y`. -/
@[mk_iff]
structure Inducing (f : X → Y) : Prop where
  /-- The topology on the domain is equal to the induced topology. -/
  induced : tX = tY.induced f
-- Mathlib/Topology/Basic.lean
theorem IsClosed.closure_interior_subset {s : Set X} (s_closed : IsClosed s) :
    closure (interior s) ⊆ s
-- Mathlib/LinearAlgebra/Ray.lean
/-- If vectors `v₁` and `v₂` are on the same ray, then for some nonnegative `a b`, `a + b = 1`, we
have `v₁ = a • (v₁ + v₂)` and `v₂ = b • (v₁ + v₂)`. -/
theorem exists_eq_smul_add (h : SameRay R v₁ v₂) :
    ∃ a b : R, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ v₁ = a • (v₁ + v₂) ∧ v₂ = b • (v₁ + v₂)
-- Mathlib/Data/Nat/Dist.lean
theorem dist_tri_left (n m : ℕ) : m ≤ dist n m + n
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem isEmpty_nil : ([] : List α).isEmpty = true
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
theorem toLinearEquiv_toLinearMap : ((e : A ≃ₗ[R] B) : A →ₗ[R] B) = (e : A →ₗc[R] B)
-- Mathlib/RingTheory/WittVector/Frobenius.lean
@[ghost_simps]
theorem ghostComponent_frobeniusFun (n : ℕ) (x : 𝕎 R) :
    ghostComponent n (frobeniusFun x) = ghostComponent (n + 1) x
-- Mathlib/Logic/Equiv/Fin.lean
theorem finRotate_last' : finRotate (n + 1) ⟨n, by omega⟩ = ⟨0, Nat.zero_lt_succ _⟩
-- Mathlib/CategoryTheory/UnivLE.lean
theorem UnivLE.ofEssSurj (w : (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj) :
    UnivLE.{max u v, v}
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
@[simp]
theorem cycleOf_zpow_apply_self (f : Perm α) [DecidableRel f.SameCycle] (x : α) :
    ∀ n : ℤ, (cycleOf f x ^ n) x = (f ^ n) x
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem add_tsub_cancel_iff_le : a + (b - a) = b ↔ a ≤ b
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@[simp] theorem Proj.add_apply : (s + t).1 x = s.1 x + t.1 x
-- Mathlib/Data/List/Destutter.lean
theorem destutter'_of_chain (h : l.Chain R a) : l.destutter' R a = a :: l
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_add_left [Add α] [Add γ] (f : α → β → γ)
    (hf : ∀ a₁ a₂ b, f (a₁ + a₂) b = f a₁ b + f a₂ b) (A₁ A₂ : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f (A₁ + A₂) B = kroneckerMap f A₁ B + kroneckerMap f A₂ B
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem lowerClosure_union (s t : Set α) : lowerClosure (s ∪ t) = lowerClosure s ⊔ lowerClosure t
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_sub_nat (a : α) (n : ℕ) : ⌊a - n⌋ = ⌊a⌋ - n
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem antilipschitzWith_equiv [∀ i, PseudoEMetricSpace (β i)] :
    AntilipschitzWith ((Fintype.card ι : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (∀ i, β i))
-- Mathlib/Data/Multiset/Basic.lean
theorem card_eq_card_of_rel {r : α → β → Prop} {s : Multiset α} {t : Multiset β} (h : Rel r s t) :
    card s = card t
-- Mathlib/Data/Finsupp/Defs.lean
/--
If `α` has a unique term, the type of finitely supported functions `α →₀ β` is equivalent to `β`.
-/
@[simps!]
noncomputable def _root_.Equiv.finsuppUnique {ι : Type*} [Unique ι] : (ι →₀ M) ≃ M
-- Mathlib/Data/Nat/Factorization/Basic.lean
/-- If the factorization of `n` contains just one number `p` then `n` is a power of `p` -/
theorem eq_pow_of_factorization_eq_single {n p k : ℕ} (hn : n ≠ 0)
    (h : n.factorization = Finsupp.single p k) : n = p ^ k
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem Perm.subtypeCongr.left_apply {a : ε} (h : p a) : ep.subtypeCongr en a = ep ⟨a, h⟩
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma tail_add (a b : Fin n.succ → α) : vecTail (a + b) = vecTail a + vecTail b
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- Type class for additive monoid actions. -/
class AddAction (G : Type*) (P : Type*) [AddMonoid G] extends VAdd G P where
  /-- Zero is a neutral element for `+ᵥ` -/
  protected zero_vadd : ∀ p : P, (0 : G) +ᵥ p = p
  /-- Associativity of `+` and `+ᵥ` -/
  add_vadd : ∀ (g₁ g₂ : G) (p : P), g₁ + g₂ +ᵥ p = g₁ +ᵥ (g₂ +ᵥ p)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.repr_range : LinearMap.range hv.repr = ⊤
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet (hτ : IsStoppingTime f τ) (s : Set Ω) :
    MeasurableSet[hτ.measurableSpace] s ↔ ∀ i : ι, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i})
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.nsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℕ) :
    f (n • c - x) = f (-x)
-- Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean
lemma monotone_isoClosure (h : P ≤ Q) : isoClosure P ≤ isoClosure Q
-- Mathlib/Analysis/Subadditive.lean
/-- Fekete's lemma: a subadditive sequence which is bounded below converges. -/
theorem tendsto_lim (hbdd : BddBelow (range fun n => u n / n)) :
    Tendsto (fun n => u n / n) atTop (𝓝 h.lim)
-- Mathlib/Probability/Distributions/Gamma.lean
/-- The gamma pdf is strongly measurable -/
@[measurability]
 lemma stronglyMeasurable_gammaPDFReal (a r : ℝ) :
     StronglyMeasurable (gammaPDFReal a r)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
/-- If `f^n x - x`, `n > 0`, is an integer number `m` for some point `x`, then
`τ f = m / n`. On the circle this means that a map with a periodic orbit has
a rational rotation number. -/
theorem translationNumber_of_map_pow_eq_add_int {x : ℝ} {n : ℕ} {m : ℤ} (h : (f ^ n) x = x + m)
    (hn : 0 < n) : τ f = m / n
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem valuation_le_one_iff (x : K) : A.valuation x ≤ 1 ↔ x ∈ A
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
@[reassoc (attr := simp)]
theorem w {s t : RightExtension f g} (η : s ⟶ t) :
    f ◁ η.left ≫ t.counit = s.counit
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem ae_eq_mk (hf : AEStronglyMeasurable f μ) : f =ᵐ[μ] hf.mk f
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem isPrimitive_iff_content_eq_one {p : R[X]} : p.IsPrimitive ↔ p.content = 1
-- Mathlib/CategoryTheory/Category/Pointed.lean
/-- Constructs an isomorphism between pointed types from an equivalence that preserves the point
between them. -/
@[simps]
def Iso.mk {α β : Pointed} (e : α ≃ β) (he : e α.point = β.point) : α ≅ β
-- Mathlib/Algebra/MvPolynomial/Derivation.lean
theorem mkDerivationₗ_monomial (f : σ → A) (s : σ →₀ ℕ) (r : R) :
    mkDerivationₗ R f (monomial s r) =
      r • s.sum fun i k => monomial (s - Finsupp.single i 1) (k : R) • f i
-- Mathlib/Algebra/Group/Units/Equiv.lean
@[to_additive]
theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem neg_pi_div_two_eq_arcsin {x} : -(π / 2) = arcsin x ↔ x ≤ -1
-- Mathlib/Probability/Distributions/Gaussian.lean
@[simp]
lemma gaussianReal_zero_var (μ : ℝ) : gaussianReal μ 0 = Measure.dirac μ
-- Mathlib/Topology/Separation.lean
theorem continuousWithinAt_update_of_ne [T1Space X] [DecidableEq X] [TopologicalSpace Y] {f : X → Y}
    {s : Set X} {x x' : X} {y : Y} (hne : x' ≠ x) :
    ContinuousWithinAt (Function.update f x y) s x' ↔ ContinuousWithinAt f s x'
-- Mathlib/SetTheory/Ordinal/Notation.lean
private theorem exists_lt_omega_opow' {α} {o b : Ordinal} (hb : 1 < b) (ho : o.IsLimit)
    {f : α → Ordinal} (H : ∀ ⦃a⦄, a < o → ∃ i, a < f i) ⦃a⦄ (h : a < b ^ o) :
        ∃ i, a < b ^ f i
-- Mathlib/Algebra/Star/Basic.lean
/-- Note that since `starMulOfComm` is reducible, `simp` can already prove this. -/
theorem star_id_of_comm {R : Type*} [CommSemiring R] {x : R} : star x = x
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isOpen_basicOpen {a : R} : IsOpen (basicOpen a : Set (PrimeSpectrum R))
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ⇑(n : CentroidHom α) = n • (CentroidHom.id α)
-- Mathlib/Data/Nat/Totient.lean
theorem totient_prime {p : ℕ} (hp : p.Prime) : φ p = p - 1
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem natCast (n : ℕ) : mapFun f (n : 𝕎 R) = n
-- Mathlib/Order/Hom/CompleteLattice.lean
@[ext]
theorem ext {f g : FrameHom α β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/NumberTheory/VonMangoldt.lean
@[simp]
theorem vonMangoldt_nonneg {n : ℕ} : 0 ≤ Λ n
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem Filter.Tendsto.rexp {l : Filter α} {f : α → ℝ} {z : ℝ} (hf : Tendsto f l (𝓝 z)) :
    Tendsto (fun x => exp (f x)) l (𝓝 (exp z))
-- Mathlib/Combinatorics/SetFamily/Shadow.lean
/-- Being in the upper shadow of `𝒜` means we have a superset in `𝒜`. -/
theorem exists_subset_of_mem_upShadow (hs : s ∈ ∂⁺ 𝒜) : ∃ t ∈ 𝒜, t ⊆ s
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem decide_eq_false : [Decidable p] → Not p → Eq (decide p) false
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem HasFTaylorSeriesUpToOn.add {q g} (hf : HasFTaylorSeriesUpToOn n f p s)
    (hg : HasFTaylorSeriesUpToOn n g q s) : HasFTaylorSeriesUpToOn n (f + g) (p + q) s
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_eq_of_sub_lt (h : v (y - x) < v x) : v y = v x
-- Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
theorem liftAlternating_ι_mul (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) (m : M)
    (x : ExteriorAlgebra R M) :
    liftAlternating (R := R) (M := M) (N := N) f (ι R m * x) =
    liftAlternating (R := R) (M := M) (N := N) (fun i => (f i.succ).curryLeft m) x
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem coe_inv_of_nonzero {J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
    (↑J⁻¹ : Submodule R₁ K) = IsLocalization.coeSubmodule K ⊤ / (J : Submodule R₁ K)
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
@[ext]
lemma FunctorsInverting.hom_ext {W : MorphismProperty C} {F₁ F₂ : FunctorsInverting W D}
    {α β : F₁ ⟶ F₂} (h : α.app = β.app) : α = β
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem mem_top (x : M) : x ∈ (⊤ : L.Substructure M)
-- Mathlib/Algebra/Lie/OfAssociative.lean
@[simp]
theorem toLieHom_comp : (g.comp f : A →ₗ⁅R⁆ C) = (g : B →ₗ⁅R⁆ C).comp (f : A →ₗ⁅R⁆ B)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_empty {α β : Type*} [CommMonoid β] [IsEmpty α] [Fintype α] (f : α → β) :
    ∏ x : α, f x = 1
-- Mathlib/Data/Set/Image.lean
/-- We make this the simp lemma instead of `range_coe`. The reason is that if we write
  for `s : Set α` the function `(↑) : s → α`, then the inferred implicit arguments of `(↑)` are
  `↑α (fun x ↦ x ∈ s)`. -/
@[simp]
theorem range_coe_subtype {p : α → Prop} : range ((↑) : Subtype p → α) = { x | p x }
-- Mathlib/Data/Finset/Powerset.lean
/-- **Formula for the Number of Combinations** -/
@[simp]
theorem card_powersetCard (n : ℕ) (s : Finset α) :
    card (powersetCard n s) = Nat.choose (card s) n
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem MulPosMono.toMulPosStrictMono [MulPosMono α] : MulPosStrictMono α
-- Mathlib/Data/Sum/Order.lean
theorem inr_mono : Monotone (inr : β → α ⊕ β)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem add_right_comm (n m k : Nat) : (n + m) + k = (n + k) + m
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem cons_empty (a : α) : cons a ∅ (not_mem_empty _) = {a}
-- Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean
@[simp]
theorem antidiagonalTuple_one (n : ℕ) : antidiagonalTuple 1 n = {![n]}
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_eq_false_iff : ∀ (x y : Bool), (x && y) = false ↔ x = false ∨ y = false
-- Mathlib/Order/Hom/Basic.lean
/-- If `α` and `β` are order-isomorphic then the two orders of order-homomorphisms
from `α` and `β` to themselves are order-isomorphic. -/
@[simps! apply symm_apply]
def conj {α β} [Preorder α] [Preorder β] (f : α ≃o β) : (α →o α) ≃ (β →o β)
-- Mathlib/RingTheory/Localization/NormTrace.lean
theorem Algebra.map_leftMulMatrix_localization {ι : Type*} [Fintype ι] [DecidableEq ι]
    (b : Basis ι R S) (a : S) :
    (algebraMap R Rₘ).mapMatrix (leftMulMatrix b a) =
    leftMulMatrix (b.localizationLocalization Rₘ M Sₘ) (algebraMap S Sₘ a)
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.DLinearMap_apply (s : S) :
    KaehlerDifferential.DLinearMap R S s =
      (KaehlerDifferential.ideal R S).toCotangent
        ⟨1 ⊗ₜ s - s ⊗ₜ 1, KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R s⟩
-- Mathlib/CategoryTheory/Sites/Equivalence.lean
theorem eq_inducedTopology_of_transports : K = e.inverse.inducedTopology J
-- Mathlib/Algebra/CharP/Defs.lean
lemma natCast_eq_natCast_mod (a : ℕ) : (a : R) = a % p
-- Mathlib/Data/Set/Card.lean
theorem ncard_mono [Finite α] : @Monotone (Set α) _ _ _ ncard
-- Mathlib/Algebra/SMulWithZero.lean
lemma ite_zero_smul (a : R) (b : M) : (if p then a else 0 : R) • b = if p then a • b else 0