ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- When `S.f = 0`, this is the canonical isomorphism `S.cycles ≅ S.leftHomology` induced
by `S.leftHomologyπ`. -/
@[simps! hom]
noncomputable def cyclesIsoLeftHomology (hf : S.f = 0) : S.cycles ≅ S.leftHomology
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
nonrec theorem ContinuousAt.arsinh (h : ContinuousAt f a) :
    ContinuousAt (fun x => arsinh (f x)) a
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem mono_of_source_iso_zero {X Y : C} (f : X ⟶ Y) (i : X ≅ 0) : Mono f
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval_map (f : R →+* S₁) (g : σ → S₁) (p : MvPolynomial σ R) :
    eval g (map f p) = eval₂ f g p
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
@[simp] theorem LinearMap.comp_id_moduleCat
    {R} [Ring R] {G : ModuleCat.{u} R} {H : Type u} [AddCommGroup H] [Module R H] (f : G →ₗ[R] H) :
    f.comp (𝟙 G) = f
-- Mathlib/Algebra/Algebra/Basic.lean
theorem _root_.ULift.algebraMap_eq (r : R) :
    algebraMap R (ULift A) r = ULift.up (algebraMap R A r)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem add_right [T2Space M] [ContinuousAdd N] (h₁ : v ⟂ᵥ w₁) (h₂ : v ⟂ᵥ w₂) : v ⟂ᵥ w₁ + w₂
-- Mathlib/Data/Finset/Basic.lean
theorem inter_left_comm (s₁ s₂ s₃ : Finset α) : s₁ ∩ (s₂ ∩ s₃) = s₂ ∩ (s₁ ∩ s₃)
-- Mathlib/Data/Fin/Basic.lean
theorem rev_castPred {i : Fin (n + 1)}
    (h : i ≠ last n) (h' := rev_ne_iff.mpr ((rev_zero _).symm ▸ h)) :
    rev (castPred i h) = pred (rev i) h'
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
/-- Extension of a natural transformation `φ` between functors
`C ⥤ karoubi D` to a natural transformation between the
extension of these functors to `karoubi C ⥤ karoubi D` -/
@[simps]
def map {F G : C ⥤ Karoubi D} (φ : F ⟶ G) : obj F ⟶ obj G
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
theorem over_coe_def {P Q : C} (a : Q ⟶ P) : (a : Pseudoelement P) = ⟦↑a⟧
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem isZero_zero : IsZero (0 : C)
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_le_sub {x y : R} {g : Γ₀} (hx : g ≤ v x) (hy : g ≤ v y) : g ≤ v (x - y)
-- Mathlib/LinearAlgebra/TensorProduct/DirectLimit.lean
@[simp] lemma directLimitRight_symm_of_tmul {i : ι} (m : M) (g : G i) :
    (directLimitRight f M).symm (of _ _ _ _ _ (m ⊗ₜ g)) = m ⊗ₜ of _ _ _ f _ g
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem add_left_aux8 (y z : E) :
    ‖(I : 𝕜) • y - 2 • z‖ * ‖(I : 𝕜) • y - 2 • z‖ =
    2 * (‖(I : 𝕜) • y - z‖ * ‖(I : 𝕜) • y - z‖ + ‖z‖ * ‖z‖) - ‖(I : 𝕜) • y‖ * ‖(I : 𝕜) • y‖
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_singleton (c : E) : Convex 𝕜 ({c} : Set E)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem restrict_le_restrict_of_subset_le {i : Set α}
    (h : ∀ ⦃j⦄, MeasurableSet j → j ⊆ i → v j ≤ w j) : v ≤[i] w
-- Mathlib/LinearAlgebra/Dual.lean
theorem quotDualCoannihilatorToDual_injective (W : Submodule R (Dual R M)) :
    Function.Injective W.quotDualCoannihilatorToDual
-- Mathlib/MeasureTheory/Function/SimpleFuncDense.lean
theorem nearestPtInd_succ (e : ℕ → α) (N : ℕ) (x : α) :
    nearestPtInd e (N + 1) x =
      if ∀ k ≤ N, edist (e (N + 1)) x < edist (e k) x then N + 1 else nearestPtInd e N x
-- Mathlib/Data/List/Sublists.lean
theorem sublists_perm_sublists' (l : List α) : sublists l ~ sublists' l
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem pow_dvd_nthHom_sub (r : R) (i j : ℕ) (h : i ≤ j) :
    (p : ℤ) ^ i ∣ nthHom f r j - nthHom f r i
-- Mathlib/GroupTheory/Sylow.lean
theorem ne_bot_of_dvd_card [Finite G] {p : ℕ} [hp : Fact p.Prime] (P : Sylow p G)
    (hdvd : p ∣ Nat.card G) : (P : Subgroup G) ≠ ⊥
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- On a compact space, locally uniform convergence is just uniform convergence. -/
theorem tendstoLocallyUniformly_iff_tendstoUniformly_of_compactSpace [CompactSpace α] :
    TendstoLocallyUniformly F f p ↔ TendstoUniformly F f p
-- Mathlib/Topology/Sets/Compacts.lean
@[simp, norm_cast] lemma coe_compl (s : CompactOpens α) : ↑sᶜ = (sᶜ : Set α)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem coe_im (z : ℍ) : (z : ℂ).im = z.im
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem mul_def (f g : Perm α) : f * g = g.trans f
-- Mathlib/RingTheory/Idempotents.lean
lemma CompleteOrthogonalIdempotents.map_injective_iff (hf : Function.Injective f) :
    CompleteOrthogonalIdempotents (f ∘ e) ↔ CompleteOrthogonalIdempotents e
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
@[simp]
lemma coe_transpose (A : SpecialLinearGroup n R) : ↑ₘAᵀ = (↑ₘA)ᵀ
-- Mathlib/GroupTheory/Coset.lean
@[to_additive]
theorem orbit_subgroup_eq_self_of_mem {a : α} (ha : a ∈ s) : MulAction.orbit s a = s
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem blunt_iff_not_pointed (S : ConvexCone 𝕜 E) : S.Blunt ↔ ¬S.Pointed
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
theorem sup_powerset_len {α : Type*} [DecidableEq α] (x : Multiset α) :
    (Finset.sup (Finset.range (card x + 1)) fun k => x.powersetCard k) = x.powerset
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma XYIdeal_eq₂ {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁)
    (h₂ : W.Equation x₂ y₂) (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) :
    XYIdeal W x₂ (C y₂) = XYIdeal W x₂ (linePolynomial x₁ y₁ <| W.slope x₁ x₂ y₁ y₂)
-- Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
@[simp]
theorem liftAlternating_ι (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) (m : M) :
    liftAlternating (R := R) (M := M) (N := N) f (ι R m) = f 1 ![m]
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_point (P Q : W.Point) : (P + Q).point = W.addMap P.point Q.point
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem IsCompact.div_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
    s / closedBall 1 δ = cthickening δ s
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- Showing one side of the equivalence between the definitions
`IsDedekindDomainInv` and `IsDedekindDomain` of Dedekind domains. -/
theorem isDedekindDomain : IsDedekindDomain A
-- Mathlib/Data/Finset/Basic.lean
theorem filter_cons_of_neg (a : α) (s : Finset α) (ha : a ∉ s) (hp : ¬p a) :
    filter p (cons a s ha) = filter p s
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
theorem quotientMap_comp_mk {J : Ideal R} {I : Ideal S} {f : R →+* S} (H : J ≤ I.comap f) :
    (quotientMap I f H).comp (Quotient.mk J) = (Quotient.mk I).comp f
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- If a set of points is affinely independent, so is any subset. -/
protected theorem AffineIndependent.mono {s t : Set P}
    (ha : AffineIndependent k (fun x => x : t → P)) (hs : s ⊆ t) :
    AffineIndependent k (fun x => x : s → P)
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
theorem injective_iff_preservesEpimorphisms_yoneda_obj (J : C) :
    Injective J ↔ (yoneda.obj J).PreservesEpimorphisms
-- Mathlib/LinearAlgebra/Prod.lean
theorem prodMap_add (f₁ : M →ₗ[R] M₃) (f₂ : M →ₗ[R] M₃) (g₁ : M₂ →ₗ[R] M₄) (g₂ : M₂ →ₗ[R] M₄) :
    (f₁ + f₂).prodMap (g₁ + g₂) = f₁.prodMap g₁ + f₂.prodMap g₂
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- If `f` maps a subspace `p` into itself, then the generalized eigenspace of the restriction
    of `f` to `p` is the part of the generalized eigenspace of `f` that lies in `p`. -/
theorem genEigenspace_restrict (f : End R M) (p : Submodule R M) (k : ℕ) (μ : R)
    (hfp : ∀ x : M, x ∈ p → f x ∈ p) :
    genEigenspace (LinearMap.restrict f hfp) μ k =
      Submodule.comap p.subtype (f.genEigenspace μ k)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffAt_prod {t : Finset ι} {f : ι → E → 𝔸'} (h : ∀ i ∈ t, ContDiffAt 𝕜 n (f i) x) :
    ContDiffAt 𝕜 n (fun y => ∏ i ∈ t, f i y) x
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp, norm_cast] lemma coe_one : ⇑(1 : α →+* α) = _root_.id
-- Mathlib/Order/GaloisConnection.lean
protected theorem compose [Preorder α] [Preorder β] [Preorder γ] {l1 : α → β} {u1 : β → α}
    {l2 : β → γ} {u2 : γ → β} (gc1 : GaloisConnection l1 u1) (gc2 : GaloisConnection l2 u2) :
    GaloisConnection (l2 ∘ l1) (u1 ∘ u2)
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem restrict_univ (m : OuterMeasure α) : restrict univ m = m
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- On pseudometric spaces, a map is an isometry if and only if it preserves distances. -/
theorem isometry_iff_dist_eq [PseudoMetricSpace α] [PseudoMetricSpace β] {f : α → β} :
    Isometry f ↔ ∀ x y, dist (f x) (f y) = dist x y
-- Mathlib/Topology/PartitionOfUnity.lean
theorem eventually_fintsupport_subset :
    ∀ᶠ y in 𝓝 x₀, ρ.fintsupport y ⊆ ρ.fintsupport x₀
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem le_of_le_of_eq {a b c : α} [LE α] (h₁ : a ≤ b) (h₂ : b = c) : a ≤ c
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem parallelPair_functor_obj {F : WalkingParallelPair ⥤ C} (j : WalkingParallelPair) :
    (parallelPair (F.map left) (F.map right)).obj j = F.obj j
-- Mathlib/Data/ULift.lean
@[ext]
theorem ext (x y : ULift α) (h : x.down = y.down) : x = y
-- Mathlib/Data/Nat/Bits.lean
lemma shiftLeft_sub : ∀ (m : Nat) {n k}, k ≤ n → m <<< (n - k) = (m <<< n) >>> k
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
@[simp]
theorem Differentiable.exp (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.exp (f x)
-- Mathlib/Order/SuccPred/Basic.lean
theorem Iio_succ_of_not_isMax (ha : ¬IsMax a) : Iio (succ a) = Iic a
-- Mathlib/Analysis/Convex/Combination.lean
theorem Finset.mem_convexHull {s : Finset E} {x : E} : x ∈ convexHull R (s : Set E) ↔
    ∃ w : E → R, (∀ y ∈ s, 0 ≤ w y) ∧ ∑ y ∈ s, w y = 1 ∧ s.centerMass w id = x
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem lift_succ (a : Ordinal.{v}) : lift.{u} (succ a) = succ (lift.{u} a)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem isOrtho_top_left {V : Submodule 𝕜 E} : ⊤ ⟂ V ↔ V = ⊥
-- Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
@[simp]
theorem liftAlternating_algebraMap (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) (r : R) :
    liftAlternating (R := R) (M := M) (N := N) f (algebraMap _ (ExteriorAlgebra R M) r) =
    r • f 0 0
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
/-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem mem_top (x : R) : x ∈ (⊤ : NonUnitalSubsemiring R)
-- Mathlib/RingTheory/EisensteinCriterion.lean
theorem eval_zero_mem_ideal_of_eq_mul_X_pow {n : ℕ} {P : Ideal R} {q : R[X]}
    {c : Polynomial (R ⧸ P)} (hq : map (mk P) q = c * X ^ n) (hn0 : n ≠ 0) : eval 0 q ∈ P
-- Mathlib/Data/Set/Image.lean
theorem injective_iff {α β} {f : Option α → β} :
    Injective f ↔ Injective (f ∘ some) ∧ f none ∉ range (f ∘ some)
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_sup : ⇑(p ⊔ q) = ⇑p ⊔ ⇑q
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMin.on (h : IsLocalMin f a) (s) : IsLocalMinOn f s a
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem cons_eq_insert (a s h) : @cons α a s h = insert a s
-- Mathlib/Topology/ContinuousFunction/Polynomial.lean
theorem polynomialFunctions.starClosure_eq_adjoin_X [StarRing R] [ContinuousStar R] (s : Set R) :
    (polynomialFunctions s).starClosure = adjoin R {toContinuousMapOnAlgHom s X}
-- Mathlib/Algebra/Group/Units.lean
@[field_simps]
theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : x /ₚ u₁ /ₚ u₂ = x /ₚ (u₂ * u₁)
-- Mathlib/Data/Finset/Card.lean
theorem card_insert_of_mem (h : a ∈ s) : card (insert a s) = s.card
-- Mathlib/Data/Rat/Lemmas.lean
theorem add_den_dvd (q₁ q₂ : ℚ) : (q₁ + q₂).den ∣ q₁.den * q₂.den
-- Mathlib/Data/Fin/Basic.lean
protected lemma lt_of_le_of_lt : a ≤ b → b < c → a < c
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Iio_mem_nhdsSet_Icc (h : b < c) : Iio c ∈ 𝓝ˢ (Icc a b)
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem filter_parts_partition_eq_cycleType {σ : Perm α} :
    ((partition σ).parts.filter fun n => 2 ≤ n) = σ.cycleType
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp)]
theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Icc_bot_coe : Icc (⊥ : WithBot α) b = insertNone (Iic b)
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem sInf_glb (S : Set (LieSubalgebra R L)) : IsGLB S (sInf S)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_comp_neg (hf : ContinuousOn f ((- ·) '' (spectrum R (a : A))) := by cfc_cont_tac)
    (ha : p a := by cfc_tac) : cfc (f <| - ·) a = cfc f (-a)
-- Mathlib/Topology/Instances/NNReal.lean
@[norm_cast]
theorem hasSum_coe {f : α → ℝ≥0} {r : ℝ≥0} : HasSum (fun a => (f a : ℝ)) (r : ℝ) ↔ HasSum f r
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_iff_eventually [UniformSpace β] {f : α → β} :
    UniformContinuous f ↔ ∀ r ∈ 𝓤 β, ∀ᶠ x : α × α in 𝓤 α, (f x.1, f x.2) ∈ r
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem max_some_none [Max α] {a : α} : max (some a) none = some a
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
@[simp]
theorem trace_transpose_mul [AddCommMonoid R] [Mul R] (A : Matrix m n R) (B : Matrix n m R) :
    trace (Aᵀ * Bᵀ) = trace (A * B)
-- Mathlib/Algebra/Group/Nat.lean
lemma succ_mod_two_eq_one_iff {m : ℕ} : (m + 1) % 2 = 1 ↔ m % 2 = 0
-- Mathlib/Topology/Instances/ENNReal.lean
theorem continuousAt_coe_iff {α : Type*} [TopologicalSpace α] {x : ℝ≥0} {f : ℝ≥0∞ → α} :
    ContinuousAt f ↑x ↔ ContinuousAt (f ∘ (↑) : ℝ≥0 → α) x
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- For a compact set `s`, locally uniform convergence on `s` is just uniform convergence on `s`. -/
theorem tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact (hs : IsCompact s) :
    TendstoLocallyUniformlyOn F f p s ↔ TendstoUniformlyOn F f p s
-- Mathlib/Topology/Connected/Basic.lean
/-- The image of a preconnected set is preconnected as well. -/
protected theorem IsPreconnected.image [TopologicalSpace β] {s : Set α} (H : IsPreconnected s)
    (f : α → β) (hf : ContinuousOn f s) : IsPreconnected (f '' s)
-- Mathlib/Algebra/Order/Floor/Div.lean
/-- Typeclass for division rounded down. For each `a > 0`, this asserts the existence of a right
adjoint to the map `b ↦ a • b : β → β`. -/
class FloorDiv where
  /-- Flooring division. If `a > 0`, then `b ⌊/⌋ a` is the greatest `c` such that `a • c ≤ b`. -/
  floorDiv : β → α → β
  /-- Do not use this. Use `gc_floorDiv_smul` or `gc_floorDiv_mul` instead. -/
  protected floorDiv_gc ⦃a⦄ : 0 < a → GaloisConnection (a • ·) (floorDiv · a)
  /-- Do not use this. Use `floorDiv_nonpos` instead. -/
  protected floorDiv_nonpos ⦃a⦄ : a ≤ 0 → ∀ b, floorDiv b a = 0
  /-- Do not use this. Use `zero_floorDiv` instead. -/
  protected zero_floorDiv (a) : floorDiv 0 a = 0
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem neg_eq_top_iff {x : EReal} : -x = ⊤ ↔ x = ⊥
-- Mathlib/Topology/NoetherianSpace.lean
theorem noetherianSpace_iff_isCompact : NoetherianSpace α ↔ ∀ s : Set α, IsCompact s
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem cancel_right_of_respectsIso
    (P : AffineTargetMorphismProperty) [P.toProperty.RespectsIso]
    {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] [IsAffine Z] [IsAffine Y] :
    P (f ≫ g) ↔ P f
-- Mathlib/Analysis/Calculus/MeanValue.lean
theorem _root_.is_const_of_fderiv_eq_zero
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {f : E → G}
    (hf : Differentiable 𝕜 f) (hf' : ∀ x, fderiv 𝕜 f x = 0)
    (x y : E) : f x = f y
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem Coprime.eq_one_of_dvd {k m : Nat} (H : Coprime k m) (d : k ∣ m) : k = 1
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Completeness.lean
/-- If a dense embedding `e : E →L[𝕜] G` expands the norm by a constant factor `N⁻¹`, then the
norm of the extension of `f` along `e` is bounded by `N * ‖f‖`. -/
theorem opNorm_extend_le :
    ‖f.extend e h_dense (uniformEmbedding_of_bound _ h_e).toUniformInducing‖ ≤ N * ‖f‖
-- Mathlib/Data/List/Join.lean
@[simp]
theorem join_append (L₁ L₂ : List (List α)) : join (L₁ ++ L₂) = join L₁ ++ join L₂
-- Mathlib/Data/ENNReal/Basic.lean
lemma iSup_coe_lt_top : ⨆ i, (f i : ℝ≥0∞) < ⊤ ↔ BddAbove (range f)
-- Mathlib/RingTheory/Ideal/Operations.lean
lemma radical_pow : ∀ {n}, n ≠ 0 → radical (I ^ n) = radical I
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inclusion_le_inclusion [Preorder α] {s t : Set α} (h : s ⊆ t) {x y : s} :
    inclusion h x ≤ inclusion h y ↔ x ≤ y
-- Mathlib/RingTheory/Int/Basic.lean
theorem sq_of_coprime {a b c : ℤ} (h : IsCoprime a b) (heq : a * b = c ^ 2) :
    ∃ a0 : ℤ, a = a0 ^ 2 ∨ a = -a0 ^ 2
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma natCast_re (n : ℕ) : (n : ℂ).re = n
-- Mathlib/Algebra/Divisibility/Basic.lean
/-- A monoid is a decomposition monoid if every element is primal. An integral domain whose
multiplicative monoid is a decomposition monoid, is called a pre-Schreier domain; it is a
Schreier domain if it is moreover integrally closed. -/
@[mk_iff] class DecompositionMonoid : Prop where
  primal (a : α) : IsPrimal a
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
@[reassoc (attr := simp)]
theorem toSheafify_naturality {P Q : Cᵒᵖ ⥤ D} (η : P ⟶ Q) :
    η ≫ J.toSheafify _ = J.toSheafify _ ≫ J.sheafifyMap η
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma prod_galRestrict_eq_norm [IsGalois K L] [IsIntegrallyClosed A] (x : B) :
    (∏ σ : L ≃ₐ[K] L, galRestrict A K L B σ x) =
    algebraMap A B (IsIntegralClosure.mk' (R := A) A (Algebra.norm K <| algebraMap B L x)
      (Algebra.isIntegral_norm K (IsIntegralClosure.isIntegral A L x).algebraMap))
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem derivative_expand (f : R[X]) : Polynomial.derivative (expand R p f) =
    expand R p (Polynomial.derivative f) * (p * (X ^ (p - 1) : R[X]))
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem _root_.Subalgebra.toSubmodule_toSubalgebra (S : Subalgebra R A) :
    (S.toSubmodule.toSubalgebra S.one_mem fun _ _ => S.mul_mem) = S
-- Mathlib/Analysis/InnerProductSpace/Positive.lean
lemma le_def (f g : E →L[𝕜] E) : f ≤ g ↔ (g - f).IsPositive
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
@[simp]
theorem mem_full_iff {c d : C} {f : c ⟶ d} : f ∈ (full D).arrows c d ↔ c ∈ D ∧ d ∈ D
-- Mathlib/Data/Complex/Abs.lean
theorem lim_conj (f : CauSeq ℂ Complex.abs) : lim (cauSeqConj f) = conj (lim f)
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[simp]
theorem congr_tprod (f : Π i, s i ≃ₗ[R] t i) (m : Π i, s i) :
    congr f (tprod R m) = tprod R (fun (i : ι) ↦ (f i) (m i))
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_div_le_one_div_of_le (ha : 0 < a) (h : a ≤ b) : 1 / b ≤ 1 / a
-- Mathlib/Logic/Basic.lean
@[simp] theorem xor_not_right : Xor' a (¬b) ↔ (a ↔ b)
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem trim_mkMetric [MeasurableSpace X] [BorelSpace X] (m : ℝ≥0∞ → ℝ≥0∞) :
    (mkMetric m : OuterMeasure X).trim = mkMetric m
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
/-- Promote a finite products preserving functor to a monoidal functor between
categories equipped with the monoidal category structure given by finite products. -/
@[simps]
def Functor.toMonoidalFunctorOfHasFiniteProducts : MonoidalFunctor C D
-- Mathlib/Data/Set/Lattice.lean
/-- This rather trivial consequence of `iInter₂_subset` is convenient with `apply`, and has `i` and
`j` explicit for this purpose. -/
theorem iInter₂_subset_of_subset {s : ∀ i, κ i → Set α} {t : Set α} (i : ι) (j : κ i)
    (h : s i j ⊆ t) : ⋂ (i) (j), s i j ⊆ t
-- Mathlib/FieldTheory/PolynomialGaloisGroup.lean
/-- `Polynomial.Gal.restrict p E` is compatible with `Polynomial.Gal.galAction p E`. -/
@[simp]
theorem restrict_smul [Fact (p.Splits (algebraMap F E))] (ϕ : E ≃ₐ[F] E) (x : rootSet p E) :
    ↑(restrict p E ϕ • x) = ϕ x
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem mem_inf {S T : Subalgebra R A} {x : A} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T
-- Mathlib/Order/Zorn.lean
/-- A variant of Zorn's lemma. If every nonempty chain of a nonempty type has an upper bound, then
there is a maximal element.
-/
theorem exists_maximal_of_nonempty_chains_bounded [Nonempty α]
    (h : ∀ c, IsChain r c → c.Nonempty → ∃ ub, ∀ a ∈ c, a ≺ ub)
    (trans : ∀ {a b c}, a ≺ b → b ≺ c → a ≺ c) : ∃ m, ∀ a, m ≺ a → a ≺ m
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem integrableOn_Lp_of_measure_ne_top {E} [NormedAddCommGroup E] {p : ℝ≥0∞} {s : Set α}
    (f : Lp E p μ) (hp : 1 ≤ p) (hμs : μ s ≠ ∞) : IntegrableOn f s μ
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sdiff_inf_self_left (a b : α) : a \ (a ⊓ b) = a \ b
-- Mathlib/CategoryTheory/Sites/SheafOfTypes.lean
/--
The category of sheaves on the bottom (trivial) grothendieck topology is equivalent to the category
of presheaves.
-/
@[simps]
def sheafOfTypesBotEquiv : SheafOfTypes (⊥ : GrothendieckTopology C) ≌ Cᵒᵖ ⥤ Type w
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
/-- If a function is locally Lipschitz around a point, then it is continuous at this point. -/
theorem continuousAt_of_locally_lipschitz {x : α} {r : ℝ} (hr : 0 < r) (K : ℝ)
    (h : ∀ y, dist y x < r → dist (f y) (f x) ≤ K * dist y x) : ContinuousAt f x
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
/-- Formula for `hurwitzZetaOdd` as a Dirichlet series in the convergence range, with sum over `ℕ`
(version without absolute values, assuming `a ∈ Icc 0 1`) -/
lemma hasSum_nat_hurwitzZetaOdd_of_mem_Icc {a : ℝ} (ha : a ∈ Icc 0 1) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℕ ↦ (1 / (n + a : ℂ) ^ s - 1 / (n + 1 - a : ℂ) ^ s) / 2)
    (hurwitzZetaOdd a s)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a ≤ b
-- Mathlib/Data/Set/Card.lean
theorem encard_singleton_inter (s : Set α) (x : α) : ({x} ∩ s).encard ≤ 1
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mk'_eq_iff_eq {x₁ x₂} {y₁ y₂ : S} :
    f.mk' x₁ y₁ = f.mk' x₂ y₂ ↔ f.toMap (y₂ * x₁) = f.toMap (y₁ * x₂)
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem init_snoc : init (snoc p x) = p
-- Mathlib/Analysis/Convex/Side.lean
theorem SSameSide.trans_wOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SSameSide x y)
    (hyz : s.WOppSide y z) : s.WOppSide x z
-- Mathlib/Probability/Kernel/Composition.lean
theorem comap_apply' (κ : Kernel α β) (hg : Measurable g) (c : γ) (s : Set β) :
    comap κ g hg c s = κ (g c) s
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive]
theorem prod_hom₂ [CommMonoid β] [CommMonoid γ] (s : Multiset ι) (f : α → β → γ)
    (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d) (hf' : f 1 1 = 1) (f₁ : ι → α)
    (f₂ : ι → β) : (s.map fun i => f (f₁ i) (f₂ i)).prod = f (s.map f₁).prod (s.map f₂).prod
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem coe_countAddMonoidHom {a : α} : (countAddMonoidHom a : Multiset α → ℕ) = count a
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
@[simp]
theorem cof_zero : cof 0 = 0
-- Mathlib/Order/Fin/Basic.lean
/-- A function `f` on `Fin (n + 1)` is strictly antitone if and only if `f (i + 1) < f i`
for all `i`. -/
lemma strictAnti_iff_succ_lt : StrictAnti f ↔ ∀ i : Fin n, f i.succ < f (castSucc i)
-- Mathlib/Order/OmegaCompletePartialOrder.lean
/-- The supremum of a chain in the product `ω`-CPO. -/
@[simps]
protected def ωSup (c : Chain (α × β)) : α × β
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem Differentiable.const_smul (h : Differentiable 𝕜 f) (c : R) :
    Differentiable 𝕜 fun y => c • f y
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioc_filter_lt_of_lt_right {a b c : α} [DecidablePred (· < c)] (h : b < c) :
    (Ioc a b).filter (· < c) = Ioc a b
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma zero_mem : 0 ∈ I
-- Mathlib/Order/Disjoint.lean
theorem sup_inf {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') : IsCompl (x ⊔ x') (y ⊓ y')
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem einfsep_pos_of_finite [Finite s] : 0 < s.einfsep