ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Span.lean
theorem closure_subset_span {s : Set M} : (AddSubmonoid.closure s : Set M) ⊆ span R s
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_list_prod (s : List (Finset α)) : (↑s.prod : Set α) = (s.map (↑)).prod
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] protected theorem lt_irrefl : ∀ (x : Bool), ¬ x < x
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem isSheafFor_arrows_iff : (ofArrows X π).IsSheafFor P ↔
    (∀ (x : (i : I) → P.obj (op (X i))), Arrows.Compatible P π x →
    ∃! t, ∀ i, P.map (π i).op t = x i)
-- Mathlib/Analysis/BoxIntegral/Basic.lean
/-- Integral sum of `f` over a tagged prepartition `π` such that `π.Union = π₀.Union` tends to the
sum of integrals of `f` over the boxes of `π₀`. -/
theorem tendsto_integralSum_sum_integral (h : Integrable I l f vol) (π₀ : Prepartition I) :
    Tendsto (integralSum f vol) (l.toFilteriUnion I π₀)
      (𝓝 <| ∑ J ∈ π₀.boxes, integral J l f vol)
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem BilinForm.mul_toMatrix (B : BilinForm R₂ M₂) (M : Matrix n n R₂) :
    M * BilinForm.toMatrix b B = BilinForm.toMatrix b (B.compLeft (Matrix.toLin b b Mᵀ))
-- Mathlib/Data/ENNReal/Operations.lean
/-- This is a special case of `WithTop.sub_top` in the `ENNReal` namespace -/
theorem sub_top : a - ∞ = 0
-- Mathlib/Data/Complex/Exponential.lean
theorem abs_cos_eq_sqrt_one_sub_sin_sq (x : ℝ) : |cos x| = √(1 - sin x ^ 2)
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem toZ_iterate_succ_le (n : ℕ) : toZ i0 (succ^[n] i0) ≤ n
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
theorem invOneSubPow_val_zero_eq_invUnitSub_one :
    (invOneSubPow 0).val = invUnitsSub (1 : Sˣ)
-- Mathlib/Algebra/Order/Module/Algebra.lean
@[simp] lemma algebraMap_le_algebraMap : algebraMap α β a₁ ≤ algebraMap α β a₂ ↔ a₁ ≤ a₂
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- All points lie in the circumsphere. -/
theorem mem_circumsphere {n : ℕ} (s : Simplex ℝ P n) (i : Fin (n + 1)) :
    s.points i ∈ s.circumsphere
-- Mathlib/Data/Finset/Grade.lean
protected lemma isCoatom_iff : IsCoatom s ↔ ∃ a, s = {a}ᶜ
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem exists_square_le' [PosMulStrictMono α] (a0 : 0 < a) : ∃ b : α, b * b ≤ a
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
    dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_zero (x : α) : ∑ i ∈ range 0, x ^ i = 0
-- Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
/-- Formula for `Λ 1`. Note that mathematically `Λ 1` is undefined, but our construction ascribes
this particular value to it. -/
lemma _root_.completedRiemannZeta_one :
    completedRiemannZeta 1 = (γ - Complex.log (4 * ↑π)) / 2
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_or_distrib_left  : ∀ (x y z : Bool), (x && (y || z)) = (x && y || x && z)
-- Mathlib/Data/Fintype/Fin.lean
@[simp]
theorem Ioi_succ (i : Fin n) : Ioi i.succ = (Ioi i).map (Fin.succEmb _)
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem Iic_disjoint_Ioc (h : a ≤ b) : Disjoint (Iic a) (Ioc b c)
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem parallelPair_obj_one (f g : X ⟶ Y) : (parallelPair f g).obj one = Y
-- Mathlib/Algebra/Algebra/Operations.lean
theorem mul_subset_mul : (↑M : Set A) * (↑N : Set A) ⊆ (↑(M * N) : Set A)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem?_concat_length (l : List α) (a : α) : (l ++ [a])[l.length]? = some a
-- Mathlib/Logic/Equiv/Defs.lean
protected lemma forall_congr_left : (∀ a, p a) ↔ ∀ b, p (e.symm b)
-- Mathlib/Data/Set/Lattice.lean
theorem biUnion_union (s t : Set α) (u : α → Set β) :
    ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x
-- Mathlib/ModelTheory/Substructures.lean
theorem map_sup (S T : L.Substructure M) (f : M →[L] N) : (S ⊔ T).map f = S.map f ⊔ T.map f
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem Subtype.volume_def : (volume : Measure u) = volume.comap Subtype.val
-- Mathlib/Topology/Bornology/Absorbs.lean
protected theorem absorbs (hs : Absorbent M s) {x : α} : Absorbs M s {x}
-- Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
/-- A morphism of schemes `f : X ⟶ Y` is universally closed if the base change `X ×[Y] Y' ⟶ Y'`
along any morphism `Y' ⟶ Y` is (topologically) a closed map.
-/
@[mk_iff]
class UniversallyClosed (f : X ⟶ Y) : Prop where
  out : universally (topologically @IsClosedMap) f
-- Mathlib/Analysis/Convex/SimplicialComplex/Basic.lean
theorem mem_space_iff : x ∈ K.space ↔ ∃ s ∈ K.faces, x ∈ convexHull 𝕜 (s : Set E)
-- Mathlib/CategoryTheory/Category/Factorisation.lean
/-- Composition of morphisms in `Factorisation f`. -/
@[simps]
protected def Hom.comp {d₁ d₂ d₃ : Factorisation f}
    (f : Factorisation.Hom d₁ d₂) (g : Factorisation.Hom d₂ d₃) : Factorisation.Hom d₁ d₃
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem leadingCoeff_one : leadingCoeff (1 : R[X]) = 1
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem ucs_eq_top_iff (k : ℕ) : N.ucs k = ⊤ ↔ LieModule.lowerCentralSeries R L M k ≤ N
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma tensorQuotEquivQuotSMul_comp_mkQ_lTensor (I : Ideal R) :
    tensorQuotEquivQuotSMul M I ∘ₗ I.mkQ.lTensor M =
      (I • ⊤ : Submodule R M).mkQ ∘ₗ TensorProduct.rid R M
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_atTop_isGLB (h_anti : Antitone f) (ha : IsGLB (Set.range f) a) :
    Tendsto f atTop (𝓝 a)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem rel_zero_right {a : Multiset α} : Rel r a 0 ↔ a = 0
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem inv_eq_iff_eq {f : Perm α} {x y : α} : f⁻¹ x = y ↔ x = f y
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc (attr := simp)]
theorem kernel.condition : kernel.ι f ≫ f = 0
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp]
theorem degree_zero : degree (0 : R[T;T⁻¹]) = ⊥
-- Mathlib/Topology/Order/Lattice.lean
/-- Let `L` be a topological space and let `L×L` be equipped with the product topology and let
`⊓:L×L → L` be a supremum. Then `L` is said to have *(jointly) continuous supremum* if the map
`⊓:L×L → L` is continuous.
-/
class ContinuousSup (L : Type*) [TopologicalSpace L] [Sup L] : Prop where
  /-- The supremum is continuous -/
  continuous_sup : Continuous fun p : L × L => p.1 ⊔ p.2
-- Mathlib/Order/MinMax.lean
@[simp]
theorem le_max_iff : a ≤ max b c ↔ a ≤ b ∨ a ≤ c
-- Mathlib/Algebra/Homology/Single.lean
@[simp]
lemma single₀ObjXSelf (X : V) :
    HomologicalComplex.singleObjXSelf (ComplexShape.up ℕ) 0 X = Iso.refl _
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem cos_eq_zero_iff {θ : ℝ} : cos θ = 0 ↔ ∃ k : ℤ, θ = (2 * k + 1) * π / 2
-- Mathlib/Topology/Category/Profinite/Limits.lean
theorem Sigma.ι_comp_toFiniteCoproduct (a : α) :
    (Limits.Sigma.ι X a) ≫ (coproductIsoCoproduct X).inv = finiteCoproduct.ι X a
-- Mathlib/Analysis/Convex/Deriv.lean
lemma slope_lt_derivWithin (hfc : StrictConvexOn ℝ S f) (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y)
    (hfd : DifferentiableWithinAt ℝ f S y) :
    slope f x y < derivWithin f S y
-- Mathlib/Order/Bounded.lean
theorem unbounded_gt_of_unbounded_ge [Preorder α] (h : Unbounded (· ≥ ·) s) : Unbounded (· > ·) s
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem comap_inf {N₂' : LieSubmodule R L M'} :
    (N' ⊓ N₂').comap f = N'.comap f ⊓ N₂'.comap f
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem RingHom.comp_id_ringCat
    {G : RingCat.{u}} {H : Type u} [Ring H] (f : G →+* H) : f.comp (𝟙 G) = f
-- Mathlib/Computability/TMToPartrec.lean
theorem trNat_default : trNat default = []
-- Mathlib/Data/List/Indexes.lean
theorem foldrIdx_eq_foldrIdxSpec (f : ℕ → α → β → β) (b as start) :
    foldrIdx f b as start = foldrIdxSpec f b as start
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_toInfTopHom (f : BoundedLatticeHom α β) : ⇑f.toInfTopHom = f
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
nonrec
theorem ContinuousWithinAt.cexp (h : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun y => exp (f y)) s x
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem skewProd_apply (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) (x) :
    e.skewProd e' f x = (e x.1, e' x.2 + f x.1)
-- Mathlib/Order/Filter/Partial.lean
@[simp]
theorem mem_pmap (f : α →. β) (l : Filter α) (s : Set β) : s ∈ l.pmap f ↔ f.core s ∈ l
-- Mathlib/Probability/IdentDistrib.lean
theorem lintegral_eq {f : α → ℝ≥0∞} {g : β → ℝ≥0∞} (h : IdentDistrib f g μ ν) :
    ∫⁻ x, f x ∂μ = ∫⁻ x, g x ∂ν
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive (attr := mono, gcongr) nsmul_lt_nsmul_right]
lemma pow_lt_pow_left' (hn : n ≠ 0) {a b : M} (hab : a < b) : a ^ n < b ^ n
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem mul_def (a b : Fin n) : a * b = Fin.mk ((a * b) % n) (Nat.mod_lt _ a.size_pos)
-- Mathlib/Topology/Algebra/GroupWithZero.lean
nonrec theorem ContinuousWithinAt.zpow₀ (hf : ContinuousWithinAt f s a) (m : ℤ)
    (h : f a ≠ 0 ∨ 0 ≤ m) : ContinuousWithinAt (fun x => f x ^ m) s a
-- Mathlib/LinearAlgebra/CliffordAlgebra/Grading.lean
/-- To show a property is true on the odd parts, it suffices to show it is true on the
vectors, closed under addition, and under left-multiplication by a pair of vectors. -/
@[elab_as_elim]
theorem odd_induction {P : ∀ x, x ∈ evenOdd Q 1 → Prop}
    (ι : ∀ v, P (ι Q v) (ι_mem_evenOdd_one _ _))
    (add : ∀ x y hx hy, P x hx → P y hy → P (x + y) (Submodule.add_mem _ hx hy))
    (ι_mul_ι_mul :
      ∀ m₁ m₂ x hx,
        P x hx →
          P (CliffordAlgebra.ι Q m₁ * CliffordAlgebra.ι Q m₂ * x)
            (zero_add (1 : ZMod 2) ▸ SetLike.mul_mem_graded (ι_mul_ι_mem_evenOdd_zero Q m₁ m₂) hx))
    (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 1) : P x hx
-- Mathlib/CategoryTheory/Functor/Category.lean
@[simp]
theorem comp_app {F G H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H) (X : C) :
    (α ≫ β).app X = α.app X ≫ β.app X
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- An orthonormal set is linearly independent. -/
theorem Orthonormal.linearIndependent {v : ι → E} (hv : Orthonormal 𝕜 v) :
    LinearIndependent 𝕜 v
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem aleph'_alephIdx (c : Cardinal) : aleph' c.alephIdx = c
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ((n : ℤ_[p]) : ℚ_[p]) = n
-- Mathlib/ModelTheory/LanguageMap.lean
/-- The composition of two language homomorphisms. -/
@[simps]
def comp (g : L' →ᴸ L'') (f : L →ᴸ L') : L →ᴸ L''
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_eq_integral_of_support_subset {a b} (h : support f ⊆ Ioc a b) :
    ∫ x in a..b, f x ∂μ = ∫ x, f x ∂μ
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciSup_le' {f : ι → α} {a : α} (h : ∀ i, f i ≤ a) : ⨆ i, f i ≤ a
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_def (a b : Ordinal) :
    a ♯ b = max (blsub.{u, u} a fun a' _ => a' ♯ b) (blsub.{u, u} b fun b' _ => a ♯ b')
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
@[simp]
theorem setOfIdeal_ofSet_eq_interior (s : Set X) : setOfIdeal (idealOfSet 𝕜 s) = interior s
-- Mathlib/Order/Interval/Finset/Defs.lean
private lemma aux (x : α) (p : α → Prop) :
    (∃ a : α, p a ∧ WithTop.some a = WithTop.some x) ↔ p x
-- Mathlib/Topology/Separation.lean
theorem pairwise_disjoint_nhds [T2Space X] : Pairwise (Disjoint on (𝓝 : X → Filter X))
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- On square matrices, `mul_right_comm` applies under `det`. -/
theorem det_mul_right_comm (M N P : Matrix m m R) : det (M * N * P) = det (M * P * N)
-- Mathlib/Order/Fin/Basic.lean
lemma strictMono_castPred_comp (hf : ∀ a, f a ≠ last n) (hf₂ : StrictMono f) :
    StrictMono (fun a => castPred (f a) (hf a))
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp, norm_cast]
theorem coe_multilinearMap : ⇑(f : MultilinearMap R (fun _ : ι => M) N) = f
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt64.toNat_modn (x : UInt64) (n) : (x.modn n).toNat = x.toNat % n
-- Mathlib/Deprecated/Submonoid.lean
@[to_additive]
theorem closure.isSubmonoid (s : Set M) : IsSubmonoid (Closure s)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.of_measure_le_smul {μ' : Measure α} (c : ℝ≥0∞) (hc : c ≠ ∞) (hμ'_le : μ' ≤ c • μ)
    {f : α → β} (hf : Integrable f μ) : Integrable f μ'
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp]
theorem smul_apply [IsScalarTower R ℝ≥0 ℝ≥0] (c : R) (μ : FiniteMeasure Ω) (s : Set Ω) :
    (c • μ) s = c • μ s
-- Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean
theorem incMatrix_of_not_mem_incidenceSet (h : e ∉ G.incidenceSet a) : G.incMatrix R a e = 0
-- Mathlib/MeasureTheory/MeasurableSpace/Invariants.lean
theorem measurable_invariants_of_semiconj {fa : α → α} {fb : β → β} {g : α → β} (hg : Measurable g)
    (hfg : Semiconj g fa fb) : @Measurable _ _ (invariants fa) (invariants fb) g
-- Mathlib/Order/Circular.lean
theorem sbtw_cyclic_right {a b c : α} (h : sbtw a b c) : sbtw c a b
-- Mathlib/Data/Multiset/Basic.lean
@[simp, norm_cast]
lemma filterMap_coe (f : α → Option β) (l : List α) : filterMap f l = l.filterMap f
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma cosKernel_undef (a : UnitAddCircle) {x : ℝ} (hx : x ≤ 0) : cosKernel a x = 0
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem nnnorm_lt_iff {M : ℝ≥0} (M0 : 0 < M) : ‖f‖₊ < M ↔ ∀ x : α, ‖f x‖₊ < M
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
/-- The `modify` function preserves the balance invariants. -/
protected theorem Balanced.modify {t : RBNode α}
    (h : t.Balanced c n) : ∃ c n, (t.modify cut f).Balanced c n
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp 1100, nolint simpNF]
theorem mem_map_iff_mem_of_injective {f : P₁ →ᵃ[k] P₂} {x : P₁} {s : AffineSubspace k P₁}
    (hf : Function.Injective f) : f x ∈ s.map f ↔ x ∈ s
-- Mathlib/Topology/Basic.lean
theorem accPt_sup (x : X) (F G : Filter X) :
    AccPt x (F ⊔ G) ↔ AccPt x F ∨ AccPt x G
-- Mathlib/Topology/UniformSpace/Equiv.lean
theorem range_coe (h : α ≃ᵤ β) : range h = univ
-- Mathlib/Data/List/Sort.lean
protected theorem Sorted.gt_of_ge [PartialOrder α] {l : List α} (h₁ : l.Sorted (· ≥ ·))
    (h₂ : l.Nodup) : l.Sorted (· > ·)
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
/-- The kernel of `A →ₐ[R₁] I.quotient` is `I`. -/
@[simp]
theorem Quotient.mkₐ_ker (I : Ideal A) : RingHom.ker (Quotient.mkₐ R₁ I : A →+* A ⧸ I) = I
-- Mathlib/RingTheory/LocalProperties.lean
lemma RingHom.OfLocalizationSpanTarget.ofIsLocalization
    (hP : RingHom.OfLocalizationSpanTarget P) (hP' : RingHom.RespectsIso P)
    {R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) (s : Set S) (hs : Ideal.span s = ⊤)
    (hT : ∀ r : s, ∃ (T : Type u) (_ : CommRing T) (_ : Algebra S T)
      (_ : IsLocalization.Away (r : S) T), P ((algebraMap S T).comp f)) : P f
-- Mathlib/Data/Num/Lemmas.lean
theorem castNum_eq_bitwise {f : Num → Num → Num} {g : Bool → Bool → Bool}
    (p : PosNum → PosNum → Num)
    (gff : g false false = false) (f00 : f 0 0 = 0)
    (f0n : ∀ n, f 0 (pos n) = cond (g false true) (pos n) 0)
    (fn0 : ∀ n, f (pos n) 0 = cond (g true false) (pos n) 0)
    (fnn : ∀ m n, f (pos m) (pos n) = p m n) (p11 : p 1 1 = cond (g true true) 1 0)
    (p1b : ∀ b n, p 1 (PosNum.bit b n) = bit (g true b) (cond (g false true) (pos n) 0))
    (pb1 : ∀ a m, p (PosNum.bit a m) 1 = bit (g a true) (cond (g true false) (pos m) 0))
    (pbb : ∀ a b m n, p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)) :
    ∀ m n : Num, (f m n : ℕ) = Nat.bitwise g m n
-- .lake/packages/lean4/src/lean/Init/SizeOf.lean
@[simp] theorem Name.num.sizeOf_spec (p : Name) (n : Nat) : sizeOf (num p n) = 1 + sizeOf p + sizeOf n
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_nat_add_iff : Irrational (n + x) ↔ Irrational x
-- Mathlib/Data/Finset/Sups.lean
lemma diffs_union_left : (s₁ ∪ s₂) \\ t = s₁ \\ t ∪ s₂ \\ t
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem abs_toReal_measure_sub_le_measure_symmDiff'
    (hs : MeasurableSet s) (ht : MeasurableSet t) (hs' : μ s ≠ ∞) (ht' : μ t ≠ ∞) :
    |(μ s).toReal - (μ t).toReal| ≤ (μ (s ∆ t)).toReal
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- `InvMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under inverses. -/
class InvMemClass (S G : Type*) [Inv G] [SetLike S G] : Prop where
  /-- `s` is closed under inverses -/
  inv_mem : ∀ {s : S} {x}, x ∈ s → x⁻¹ ∈ s
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
@[simp]
theorem coe_toEquiv_symm : e.toEquiv.symm = e.symm
-- Mathlib/CategoryTheory/Monoidal/Internal/Module.lean
/-- Converting a bundled algebra to a monoid object in `ModuleCat R`.
-/
@[simps]
def inverseObj (A : AlgebraCat.{u} R) : Mon_ (ModuleCat.{u} R)
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[continuity, fun_prop]
theorem Continuous.inv₀ (hf : Continuous f) (h0 : ∀ x, f x ≠ 0) : Continuous fun x => (f x)⁻¹
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem bot_coe : ((⊥ : LieSubmodule R L M) : Set M) = {0}
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem subperm_of_subset (d : Nodup l₁) (H : l₁ ⊆ l₂) : l₁ <+~ l₂
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerTMul_diagonal [DecidableEq n] (A : Matrix l m α) (b : n → α) :
    A ⊗ₖₜ[R] diagonal b = blockDiagonal fun i => A.map fun a => a ⊗ₜ[R] b i
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem isFractional_of_le {I : Submodule R P} {J : FractionalIdeal S P} (hIJ : I ≤ J) :
    IsFractional S I
-- Mathlib/Algebra/Ring/Semiconj.lean
@[simp]
theorem add_left [Distrib R] {a b x y : R} (ha : SemiconjBy a x y) (hb : SemiconjBy b x y) :
    SemiconjBy (a + b) x y
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem zero_tprodCoeff' (z : R) (f : Π i, s i) (i : ι) (hf : f i = 0) : tprodCoeff R z f = 0
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc]
lemma stalkMap_congr_hom (f g : X ⟶ Y) (hfg : f = g) (x : X) :
    f.stalkMap x = Y.presheaf.stalkSpecializes (specializes_of_eq <| hfg ▸ rfl) ≫
      g.stalkMap x
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem disjoint_nhds_cobounded (x : α) : Disjoint (𝓝 x) (cobounded α)
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
@[simp]
theorem whiskerRight_apply {L M : ModuleCat.{u} R} (f : L ⟶ M) (N : ModuleCat.{u} R)
    (l : L) (n : N) :
    (f ▷ N) (l ⊗ₜ n) = f l ⊗ₜ n
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma lift_lt_ofENat {x : Cardinal.{v}} {m : ℕ∞} : lift.{u} x < m ↔ x < m
-- Mathlib/RingTheory/Algebraic.lean
theorem isAlgebraic_iff_not_injective {x : A} :
    IsAlgebraic R x ↔ ¬Function.Injective (Polynomial.aeval x : R[X] →ₐ[R] A)
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem image_empty (f : α → β) : (∅ : Finset α).image f = ∅
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem HasDerivAt.sqrt (hf : HasDerivAt f f' x) (hx : f x ≠ 0) :
    HasDerivAt (fun y => √(f y)) (f' / (2 * √(f x))) x
-- Mathlib/Data/List/Destutter.lean
theorem destutter'_cons :
    (b :: l).destutter' R a = if R a b then a :: destutter' R b l else destutter' R a l
-- Mathlib/Algebra/Regular/SMul.lean
theorem IsRightRegular.isSMulRegular [Mul R] {c : R} (h : IsRightRegular c) :
    IsSMulRegular R (MulOpposite.op c)
-- Mathlib/Topology/Compactness/Compact.lean
lemma Inducing.isCompact_preimage_iff {f : X → Y} (hf : Inducing f) {K : Set Y}
    (Kf : K ⊆ range f) : IsCompact (f ⁻¹' K) ↔ IsCompact K
-- Mathlib/Algebra/Homology/HomotopyCategory/ShortExact.lean
@[reassoc (attr := simp)]
lemma inl_v_descShortComplex_f (i j : ℤ) (h : i + (-1) = j) :
    (inl S.f).v i j h ≫ (descShortComplex S).f j = 0
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- If `n` is positive, then `(χ ^ n) a = (χ a) ^ n`. -/
theorem pow_apply' (χ : MulChar R R') {n : ℕ} (hn : n ≠ 0) (a : R) : (χ ^ n) a = χ a ^ n
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem deriv_norm_ne_zero : ‖F.derivative.eval a‖ ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem inv_cpow (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : x⁻¹ ^ n = (x ^ n)⁻¹
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
theorem biproduct.fromSubtype_eq_lift [DecidablePred p] :
    biproduct.fromSubtype f p =
      biproduct.lift fun j => if h : p j then biproduct.π (Subtype.restrict p f) ⟨j, h⟩ else 0
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem false_ne_true : False ≠ True
-- Mathlib/Topology/Algebra/FilterBasis.lean
theorem smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x ↦ x₀ • x) ⁻¹' U
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability, fun_prop]
theorem Measurable.indicator [Zero β] (hf : Measurable f) (hs : MeasurableSet s) :
    Measurable (s.indicator f)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma coeff_Ψ₃_ne_zero (h : (3 : R) ≠ 0) : W.Ψ₃.coeff 4 ≠ 0
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_sdiff_right : x \ (y \ z) = x \ y ⊔ x ⊓ y ⊓ z
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
/-- A clique is a set of vertices whose induced graph is complete. -/
theorem isClique_iff_induce_eq : G.IsClique s ↔ G.induce s = ⊤
-- Mathlib/Analysis/Analytic/Basic.lean
protected theorem HasFPowerSeriesAt.continuousAt (hf : HasFPowerSeriesAt f p x) :
    ContinuousAt f x
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem sphere_subset_preimage_metric_sphere : (sphere n d k : Set (Fin n → ℕ)) ⊆
    (fun x : Fin n → ℕ => (WithLp.equiv 2 _).symm ((↑) ∘ x : Fin n → ℝ)) ⁻¹'
      Metric.sphere (0 : PiLp 2 fun _ : Fin n => ℝ) (√↑k)
-- Mathlib/Analysis/Normed/MulAction.lean
theorem dist_smul₀ (s : α) (x y : β) : dist (s • x) (s • y) = ‖s‖ * dist x y
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem mem_bot (x : L) : x ∈ (⊥ : LieSubalgebra R L) ↔ x = 0
-- Mathlib/FieldTheory/Adjoin.lean
theorem le_sup_toSubalgebra : E1.toSubalgebra ⊔ E2.toSubalgebra ≤ (E1 ⊔ E2).toSubalgebra
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem normNoninc_of_isometry (hf : Isometry f) : f.NormNoninc
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
theorem HasImage.mk {f : X ⟶ Y} (F : ImageFactorisation f) : HasImage f
-- Mathlib/Data/List/AList.lean
@[simp]
theorem mem_replace {a a' : α} {b : β a} {s : AList β} : a' ∈ replace a b s ↔ a' ∈ s
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitesimal_neg_iff_infiniteNeg_inv {x : ℝ*} :
    InfiniteNeg x⁻¹ ↔ Infinitesimal x ∧ x < 0
-- Mathlib/Data/Set/Basic.lean
theorem subset_inter {s t r : Set α} (rs : r ⊆ s) (rt : r ⊆ t) : r ⊆ s ∩ t
-- Mathlib/Analysis/Complex/Hadamard.lean
/-- When the function `f` is bounded above on a vertical strip, then so is `F`. -/
lemma F_BddAbove (f : ℂ → E) (ε : ℝ) (hε : ε > 0)
    (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) :
    BddAbove ((norm ∘ (F f ε)) '' (verticalClosedStrip 0 1))
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_mono : Monotone (pred : α → α)
-- Mathlib/Topology/Sober.lean
/-- A space is quasi sober if it can be covered by open quasi sober subsets. -/
theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s : Set α))
    [hS' : ∀ s : S, QuasiSober s] (hS'' : ⋃₀ S = ⊤) : QuasiSober α
-- Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
theorem toDirectSum_comp_ofDirectSum :
    toDirectSum.comp ofDirectSum = AlgHom.id R (⨁ n, ⨂[R]^n M)
-- Mathlib/CategoryTheory/Limits/IndYoneda.lean
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda_inv_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda F).inv ≫ coyoneda.map (colimit.ι F i).op
      = limit.π (F.op.comp coyoneda) ⟨i⟩
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
protected theorem sup_apply {C : β → Type*} [∀ b : β, SemilatticeSup (C b)]
    [∀ b : β, OrderBot (C b)] (s : Finset α) (f : α → ∀ b : β, C b) (b : β) :
    s.sup f b = s.sup fun a => f a b
-- Mathlib/Data/Ordmap/Ordset.lean
theorem findMin'_all {P : α → Prop} : ∀ (t) (x : α), All P t → P x → P (findMin' t x)
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem Submonoid.coe_topologicalClosure (s : Submonoid M) :
    (s.topologicalClosure : Set M) = _root_.closure (s : Set M)
-- Mathlib/CategoryTheory/Sites/CoversTop.lean
lemma exists_unique_section (hx : x.IsCompatible) (hY : J.CoversTop Y) (hF : IsSheaf J F) :
    ∃! (s : F.sections), ∀ (i : I), s.1 (Opposite.op (Y i)) = x i