ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Compactness/Compact.lean
theorem hasBasis_cocompact : (cocompact X).HasBasis IsCompact compl
-- Mathlib/ModelTheory/Substructures.lean
theorem mem_map_of_mem (f : M →[L] N) {S : L.Substructure M} {x : M} (hx : x ∈ S) : f x ∈ S.map f
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem vsub_self_mono (h : s ⊆ t) : s -ᵥ s ⊆ t -ᵥ t
-- Mathlib/Algebra/Jordan/Basic.lean
@[simp]
theorem commute_lmul_rmul (a : A) : Commute (L a) (R a)
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast]
theorem coe_lt_coe : (a : WithTop α) < b ↔ a < b
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_bit1 [One α] [Add α] (n : PosNum) : (n.bit1 : α) = ((n : α) + n) + 1
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma _root_.AddEquiv.isWeaklyRegular_congr {e : M ≃+ M₂} {as bs}
    (h : List.Forall₂ (fun (r : R) (s : S) => ∀ x, e (r • x) = s • e x) as bs) :
    IsWeaklyRegular M as ↔ IsWeaklyRegular M₂ bs
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
    HasDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x
-- Mathlib/Topology/Instances/ENNReal.lean
theorem iSup_add_iSup_of_monotone {ι : Type*} [Preorder ι] [IsDirected ι (· ≤ ·)]
    {f g : ι → ℝ≥0∞} (hf : Monotone f) (hg : Monotone g) : iSup f + iSup g = ⨆ a, f a + g a
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
@[simp]
theorem to_affine_map_contLinear (f : V →L[R] W) : f.toContinuousAffineMap.contLinear = f
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem eraseNone_empty : eraseNone (∅ : Finset (Option α)) = ∅
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem _root_.IsFractional.sup {I J : Submodule R P} :
    IsFractional S I → IsFractional S J → IsFractional S (I ⊔ J)
-- Mathlib/Algebra/Lie/Weights/Linear.lean
/-- A weight of a Lie module, bundled as a linear map. -/
@[simps]
def toLinear : L →ₗ[R] R
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem le_rpow_inv_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y
-- Mathlib/Order/GaloisConnection.lean
theorem sInf_image2_eq_sSup_sSup (h₁ : ∀ b, GaloisConnection (toDual ∘ l₁ b) (swap u b ∘ ofDual))
    (h₂ : ∀ a, GaloisConnection (toDual ∘ l₂ a) (u a ∘ ofDual)) :
    sInf (image2 u s t) = u (sSup s) (sSup t)
-- Mathlib/Analysis/Calculus/Deriv/Star.lean
protected theorem deriv.star : deriv (fun y => star (f y)) x = star (deriv f x)
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
lemma threeAPFree_sphere {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [StrictConvexSpace ℝ E] (x : E) (r : ℝ) : ThreeAPFree (sphere x r)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
lemma tail_cons {t u v} (p : G.Walk u v) (h : G.Adj t u) :
    (p.cons h).tail not_nil_cons = p
-- Mathlib/Topology/Compactness/LocallyCompact.lean
/-- In a locally compact space, for every containment `K ⊆ U` of a compact set `K` in an open
  set `U`, there is a compact neighborhood `L` such that `K ⊆ L ⊆ U`: equivalently, there is a
  compact `L` such that `K ⊆ interior L` and `L ⊆ U`.
  See also `exists_compact_closed_between`, in which one guarantees additionally that `L` is closed
  if the space is regular. -/
theorem exists_compact_between [LocallyCompactSpace X] {K U : Set X} (hK : IsCompact K)
    (hU : IsOpen U) (h_KU : K ⊆ U) : ∃ L, IsCompact L ∧ K ⊆ interior L ∧ L ⊆ U
-- Mathlib/GroupTheory/Finiteness.lean
theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiffAt.fst {f : N → M × M'} {x : N} (hf : ContMDiffAt J (I.prod I') n f x) :
    ContMDiffAt J I n (fun x => (f x).1) x
-- Mathlib/Init/Algebra/Classes.lean
theorem erefl (a : α) : a ≈ a
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem liftHom_root : liftHom f a hfx (root f) = a
-- Mathlib/CategoryTheory/Shift/Induced.lean
@[simp]
lemma shiftFunctorAdd_hom_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorAdd D a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫
        F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫
        (s b).map ((i a).inv.app X)
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
@[simp 1100]
theorem ofHom_apply {R : Type u} [Ring R] {X Y : Type v} [AddCommGroup X] [Module R X]
    [AddCommGroup Y] [Module R Y] (f : X →ₗ[R] Y) (x : X) : ofHom f x = f x
-- Mathlib/Algebra/Ring/Equiv.lean
/-- makes a `NonUnitalRingHom` from the bijective inverse of a `NonUnitalRingHom` -/
@[simps] def NonUnitalRingHom.inverse
    [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S]
    (f : R →ₙ+* S) (g : S → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : S →ₙ+* R
-- Mathlib/Algebra/Order/ZeroLEOne.lean
/-- Typeclass for expressing that the `0` of a type is less or equal to its `1`. -/
class ZeroLEOneClass (α : Type*) [Zero α] [One α] [LE α] : Prop where
  /-- Zero is less than or equal to one. -/
  zero_le_one : (0 : α) ≤ 1
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem getElem_enumFrom (l : List α) (n) (i : Nat) (h : i < (l.enumFrom n).length) :
    (l.enumFrom n)[i] = (n + i, l[i]'(by simpa [enumFrom_length] using h))
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp, reassoc]
theorem braiding_tensor_left (X Y Z : C) :
    (β_ (X ⊗ Y) Z).hom  =
      (α_ X Y Z).hom ≫ X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫
        (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom
-- Mathlib/Data/Set/Basic.lean
theorem nonempty_iff_univ_nonempty : Nonempty α ↔ (univ : Set α).Nonempty
-- Mathlib/Algebra/Polynomial/Eval.lean
protected theorem map_prod {ι : Type*} (g : ι → R[X]) (s : Finset ι) :
    (∏ i ∈ s, g i).map f = ∏ i ∈ s, (g i).map f
-- Mathlib/Data/DFinsupp/Basic.lean
theorem erase_same {i : ι} {f : Π₀ i, β i} : (f.erase i) i = 0
-- Mathlib/Probability/Process/Stopping.lean
theorem IsStoppingTime.measurableSet_lt (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω < i}
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_eval_neg_eq_descPochhammer (r : R) : ∀ (k : ℕ),
    (ascPochhammer R k).eval (-r) = (-1)^k * (descPochhammer R k).eval r
-- Mathlib/Data/Set/Prod.lean
theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁.pi t₁ = s₂.pi t₂
-- Mathlib/Order/Filter/AtTopBot.lean
theorem eventually_atTop_curry [SemilatticeSup α] [SemilatticeSup β] {p : α × β → Prop}
    (hp : ∀ᶠ x : α × β in Filter.atTop, p x) : ∀ᶠ k in atTop, ∀ᶠ l in atTop, p (k, l)
-- Mathlib/MeasureTheory/Integral/Average.lean
@[simp]
theorem measure_mul_laverage [IsFiniteMeasure μ] (f : α → ℝ≥0∞) :
    μ univ * ⨍⁻ x, f x ∂μ = ∫⁻ x, f x ∂μ
-- Mathlib/GroupTheory/Sylow.lean
theorem Sylow.exists_comap_eq_of_ker_isPGroup {H : Type*} [Group H] (P : Sylow p H) {f : H →* G}
    (hf : IsPGroup p f.ker) : ∃ Q : Sylow p G, (Q : Subgroup G).comap f = P
-- Mathlib/Analysis/Convex/Body.lean
protected theorem nonempty (K : ConvexBody V) : (K : Set V).Nonempty
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
/-- If a function is polynomial on a set `s`, so are its successive Fréchet derivative. -/
theorem CPolynomialOn.iteratedFDeriv (h : CPolynomialOn 𝕜 f s) (n : ℕ) :
    CPolynomialOn 𝕜 (iteratedFDeriv 𝕜 n f) s
-- Mathlib/Data/Real/Irrational.lean
theorem of_one_div (h : Irrational (1 / x)) : Irrational x
-- Mathlib/Deprecated/Subfield.lean
theorem closure_mono {s t : Set F} (H : s ⊆ t) : closure s ⊆ closure t
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma op_associator (X Y Z : C) :
    (α_ X Y Z).op = (α_ (op X) (op Y) (op Z)).symm
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem zpow_of_gcd_eq_one (h : IsPrimitiveRoot ζ k) (i : ℤ) (hi : i.gcd k = 1) :
    IsPrimitiveRoot (ζ ^ i) k
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.mul_right (H1 : IsRelPrime x y) (H2 : IsRelPrime x z) :
    IsRelPrime x (y * z)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
/-- One can reformulate smoothness on a set as continuity on this set, and smoothness in any
extended chart in the target. -/
theorem contMDiffOn_iff_target :
    ContMDiffOn I I' n f s ↔
      ContinuousOn f s ∧
        ∀ y : M',
          ContMDiffOn I 𝓘(𝕜, E') n (extChartAt I' y ∘ f) (s ∩ f ⁻¹' (extChartAt I' y).source)
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
@[simp]
theorem totalDegree_X {R} [CommSemiring R] [Nontrivial R] (s : σ) :
    (X s : MvPolynomial σ R).totalDegree = 1
-- Mathlib/Computability/TuringMachine.lean
theorem Reaches₀.tail {σ} {f : σ → Option σ} {a b c : σ} (h₁ : Reaches₀ f a b) (h : c ∈ f b) :
    Reaches₀ f a c
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem equiv_iff :
    ∀ {x y : PSet},
      Equiv x y ↔ (∀ i, ∃ j, Equiv (x.Func i) (y.Func j)) ∧ ∀ j, ∃ i, Equiv (x.Func i) (y.Func j)
-- Mathlib/FieldTheory/SeparableDegree.lean
@[simp]
theorem natSepDegree_C (x : F) : (C x).natSepDegree = 0
-- Mathlib/Algebra/Homology/ImageToKernel.lean
@[reassoc (attr := simp)]
theorem imageToKernel_arrow (w : f ≫ g = 0) :
    imageToKernel f g w ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
@[simp]
theorem sum_left {ι : Type*} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν
-- Mathlib/Computability/Ackermann.lean
theorem ack_add_one_sq_lt_ack_add_four (m n : ℕ) : ack m ((n + 1) ^ 2) < ack (m + 4) n
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_succ' {x : α} {n : ℕ} :
    ∑ i ∈ range (n + 1), x ^ i = x ^ n + ∑ i ∈ range n, x ^ i
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem foldl_nil : [].foldl f b = b
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The L-series of the arithmetic function `ζ` does not vanish on the right half-plane
`re s > 1`. -/
lemma LSeries_zeta_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : L ↗ζ s ≠ 0
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_add_eq_max_of_ne {q r : ℤ_[p]} : ‖q‖ ≠ ‖r‖ → ‖q + r‖ = max ‖q‖ ‖r‖
-- Mathlib/Geometry/Euclidean/Angle/Sphere.lean
/-- Angle at center of a circle equals twice angle at circumference, oriented angle version. -/
theorem oangle_center_eq_two_zsmul_oangle {s : Sphere P} {p₁ p₂ p₃ : P} (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₂p₁ : p₂ ≠ p₁) (hp₂p₃ : p₂ ≠ p₃) :
    ∡ p₁ s.center p₃ = (2 : ℤ) • ∡ p₁ p₂ p₃
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
@[simp]
theorem toBasicOpen_to_map (s f : R) :
    toBasicOpen R s (algebraMap R (Localization.Away s) f) =
      const R f 1 (PrimeSpectrum.basicOpen s) fun _ _ => Submonoid.one_mem _
-- Mathlib/Topology/UrysohnsLemma.lean
theorem tendsto_approx_atTop (c : CU P) (x : X) :
    Tendsto (fun n => c.approx n x) atTop (𝓝 <| c.lim x)
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem le_tsub_iff_le_tsub (ha : AddLECancellable a) (hc : AddLECancellable c)
    (h₁ : a ≤ b) (h₂ : c ≤ b) : a ≤ b - c ↔ c ≤ b - a
-- Mathlib/Data/ENNReal/Basic.lean
theorem range_coe' : range ofNNReal = Iio ∞
-- Mathlib/Order/Monotone/Union.lean
/-- If `f` is antitone both on `s` and `t`, with `s` to the left of `t` and the center
point belonging to both `s` and `t`, then `f` is antitone on `s ∪ t` -/
protected theorem AntitoneOn.union_right {s t : Set α} {c : α} (h₁ : AntitoneOn f s)
    (h₂ : AntitoneOn f t) (hs : IsGreatest s c) (ht : IsLeast t c) : AntitoneOn f (s ∪ t)
-- Mathlib/Order/Monotone/Basic.lean
theorem Nat.rel_of_forall_rel_succ_of_le_of_lt (r : β → β → Prop) [IsTrans β r] {f : ℕ → β} {a : ℕ}
    (h : ∀ n, a ≤ n → r (f n) (f (n + 1))) ⦃b c : ℕ⦄ (hab : a ≤ b) (hbc : b < c) :
    r (f b) (f c)
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem trop_nsmul [AddMonoid R] (x : R) (n : ℕ) : trop (n • x) = trop x ^ n
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
theorem congr_congr (e : M' ≃ₗ[R] M'') (f : M ≃ₗ[R] M') (B : BilinForm R M) :
    congr e (congr f B) = congr (f.trans e) B
-- Mathlib/Algebra/Group/Int.lean
lemma mul_eq_one_iff_eq_one_or_neg_one : u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem ofIsComplProd_apply {p q : Submodule R₁ E} (h : IsCompl p q)
    (φ : (p →ₗ[R₁] F) × (q →ₗ[R₁] F)) : ofIsComplProd h φ = ofIsCompl h φ.1 φ.2
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_subtype : ∀ {p : ι → Prop} {f : Subtype p → α}, iInf f = ⨅ (i) (h : p i), f ⟨i, h⟩
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem coe_subtype : (subtype s : s → R) = ((↑) : s → R)
-- Mathlib/Analysis/Normed/Order/Lattice.lean
theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfp_le {a b} : (∀ n, f^[n] a ≤ b) → nfp f a ≤ b
-- Mathlib/Geometry/Manifold/InteriorBoundary.lean
/-- A manifold decomposes into interior and boundary. -/
lemma interior_union_boundary_eq_univ : (I.interior M) ∪ (I.boundary M) = (univ : Set M)
-- Mathlib/Algebra/Group/Int.lean
lemma even_pow' {n : ℕ} (h : n ≠ 0) : Even (m ^ n) ↔ Even m
-- Mathlib/Algebra/Module/Submodule/Range.lean
theorem comap_injective {f : F} (hf : range f = ⊤) : Injective (comap f)
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem gcd_eq_gcd_image [DecidableEq α] : s.gcd f = (s.image f).gcd id
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
@[simp]
theorem comp_factorThru {J X Y : C} [Injective J] (g : X ⟶ J) (f : X ⟶ Y) [Mono f] :
    f ≫ factorThru g f = g
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc]
theorem cokernel_map_comp_cokernelComparison {X' Y' : C} [HasCokernel f] [HasCokernel (G.map f)]
    (g : X' ⟶ Y') [HasCokernel g] [HasCokernel (G.map g)] (p : X ⟶ X') (q : Y ⟶ Y')
    (hpq : f ≫ q = p ≫ g) :
    cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) (by rw [← G.map_comp, hpq, G.map_comp]) ≫
        cokernelComparison _ G =
      cokernelComparison _ G ≫ G.map (cokernel.map f g p q hpq)
-- Mathlib/Analysis/Seminorm.lean
theorem smul_ball_zero {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} (hk : k ≠ 0) :
    k • p.ball 0 r = p.ball 0 (‖k‖ * r)
-- Mathlib/Data/Complex/Basic.lean
theorem smul_im (r : R) (z : ℂ) : (r • z).im = r • z.im
-- Mathlib/Order/Monotone/Union.lean
/-- If `f` is antitone both on `(-∞, a]` and `[a, ∞)`, then it is antitone on the whole line. -/
protected theorem AntitoneOn.Iic_union_Ici (h₁ : AntitoneOn f (Iic a)) (h₂ : AntitoneOn f (Ici a)) :
    Antitone f
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast]
protected theorem coe_mul (r₁ r₂ : ℝ≥0) : ((r₁ * r₂ : ℝ≥0) : ℝ) = r₁ * r₂
-- Mathlib/Data/Fin/Basic.lean
theorem one_pos' [NeZero n] : (0 : Fin (n + 1)) < 1
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_one_left' [GCDMonoid α] (a : α) : Associated (gcd 1 a) 1
-- Mathlib/Order/Filter/Cofinite.lean
theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
    (∃ᶠ n in atTop, p n) ↔ Set.Infinite { n | p n }
-- Mathlib/Logic/Equiv/Defs.lean
theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem top_toSubring {R A : Type*} [CommRing R] [Ring A] [Algebra R A] :
    (⊤ : Subalgebra R A).toSubring = ⊤
-- Mathlib/Data/Set/Finite.lean
theorem iUnion_pi_of_monotone {ι ι' : Type*} [LinearOrder ι'] [Nonempty ι'] {α : ι → Type*}
    {I : Set ι} {s : ∀ i, ι' → Set (α i)} (hI : I.Finite) (hs : ∀ i ∈ I, Monotone (s i)) :
    ⋃ j : ι', I.pi (fun i => s i j) = I.pi fun i => ⋃ j, s i j
-- Mathlib/Data/Complex/Exponential.lean
@[simp, norm_cast]
theorem ofReal_cos (x : ℝ) : (Real.cos x : ℂ) = cos x
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem smul_eval (x) (p : MvPolynomial σ R) (s) : eval x (s • p) = s * eval x p
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
protected theorem map_zero : Q 0 = 0
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem comp_assoc (f : BotHom γ δ) (g : BotHom β γ) (h : BotHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma op_hom_rightUnitor (X : C) : (ρ_ X).hom.op = (ρ_ (op X)).inv
-- Mathlib/Tactic/Positivity/Basic.lean
private lemma int_div_nonneg_of_pos_of_nonneg {a b : ℤ} (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ a / b
-- Mathlib/Algebra/Group/AddChar.lean
@[simp] lemma toMonoidHom_apply (ψ : AddChar A M) (a : Multiplicative A) :
  ψ.toMonoidHom a = ψ (Multiplicative.toAdd a)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.not_imp_symm [Decidable a] (h : ¬a → b) (hb : ¬b) : a
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycle.ne_one (h : IsCycle f) : f ≠ 1
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `vectorSpan` of a single point is `⊥`. -/
@[simp]
theorem vectorSpan_singleton (p : P) : vectorSpan k ({p} : Set P) = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem getElem?_eq_getElem (a : Array α) (i : Nat) (h : i < a.size) : a[i]? = a[i]
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem ContDiff.arctan (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => arctan (f x)
-- Mathlib/Order/Cover.lean
theorem WCovBy.refl (a : α) : a ⩿ a
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- Let `X` be a topological space, `𝔖` a family of compact subsets of `X`, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the uniform
structures of uniform convergence on `𝔖` and pointwise convergence on `⋃₀ 𝔖` induce the same
uniform structure on `ι`.

In particular, pointwise convergence and compact convergence coincide on an equicontinuous
subset of `X → α`.

Consider using `EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi'` and
`EquicontinuousOn.inducing_uniformOnFun_iff_pi'` instead to avoid rewriting instances,
as well as their unprimed versions in case `𝔖` covers `X`. -/
theorem EquicontinuousOn.comap_uniformOnFun_eq {𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
    (F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
    (UniformOnFun.uniformSpace X α 𝔖).comap F =
    (Pi.uniformSpace _).comap ((⋃₀ 𝔖).restrict ∘ F)
-- Mathlib/Topology/Category/TopCat/Opens.lean
/-- The functor `Opens X ⥤ Opens X` given by taking preimages under the identity function
is naturally isomorphic to the identity functor.
-/
@[simps]
def mapId : map (𝟙 X) ≅ 𝟭 (Opens X)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[norm_cast]
theorem coe_fn_coe' (f : A →ₑ+[φ] B) : ⇑(f : A →ₑ[φ] B) = f
-- Mathlib/Logic/Function/Defs.lean
theorem Injective.comp {g : β → φ} {f : α → β} (hg : Injective g) (hf : Injective f) :
    Injective (g ∘ f)
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma Odd.strictMono_pow (hn : Odd n) : StrictMono fun a : R => a ^ n
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.toLin'_submatrix [Fintype l] [DecidableEq l] (f₁ : m → k) (e₂ : n ≃ l)
    (M : Matrix k l R) :
    Matrix.toLin' (M.submatrix f₁ e₂) =
      funLeft R R f₁ ∘ₗ (Matrix.toLin' M) ∘ₗ funLeft _ _ e₂.symm
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma le_smul_ceilDiv (ha : 0 < a) : b ≤ a • (b ⌈/⌉ a)
-- Mathlib/Algebra/BigOperators/Ring.lean
theorem prod_range_natCast_sub (n k : ℕ) :
    ∏ i ∈ range k, (n - i : α) = (∏ i ∈ range k, (n - i) : ℕ)
-- Mathlib/Order/WithBot.lean
theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b : α, x = ↑b → a < b
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem iUnion_compactCovering : ⋃ n, compactCovering X n = univ
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma sinZeta_neg (a : UnitAddCircle) (s : ℂ) :
    sinZeta (-a) s = -sinZeta a s
-- Mathlib/Data/Set/Sups.lean
theorem image_subset_sups_left : b ∈ t → (fun a => a ⊔ b) '' s ⊆ s ⊻ t
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp]
theorem rpow_le_rpow_left_iff_of_base_lt_one (hx0 : 0 < x) (hx1 : x < 1) :
    x ^ y ≤ x ^ z ↔ z ≤ y
-- Mathlib/Data/Seq/WSeq.lean
theorem liftRel_flatten {R : α → β → Prop} {c1 : Computation (WSeq α)} {c2 : Computation (WSeq β)}
    (h : c1.LiftRel (LiftRel R) c2) : LiftRel R (flatten c1) (flatten c2)
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem natDegree_hasseDeriv [NoZeroSMulDivisors ℕ R] (p : R[X]) (n : ℕ) :
    natDegree (hasseDeriv n p) = natDegree p - n
-- Mathlib/Algebra/Group/Action/Defs.lean
lemma smul_zpow (g : G) (a : H) (n : ℤ) : (g • a) ^ n = g ^ n • a ^ n
-- Mathlib/Data/Int/Defs.lean
@[simp] lemma toNat_eq_zero : ∀ {n : ℤ}, n.toNat = 0 ↔ n ≤ 0
-- Mathlib/Order/WithBot.lean
@[simp]
theorem ofDual_apply_bot : WithBot.ofDual (⊥ : WithBot α) = ⊤
-- Mathlib/Logic/Function/Basic.lean
lemma Injective.dite (p : α → Prop) [DecidablePred p]
    {f : {a : α // p a} → β} {f' : {a : α // ¬ p a} → β}
    (hf : Injective f) (hf' : Injective f')
    (im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬ p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩) :
    Function.Injective (fun x ↦ if h : p x then f ⟨x, h⟩ else f' ⟨x, h⟩)
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem GrothendieckTopology.sheafify_isSheaf (P : Cᵒᵖ ⥤ D) : Presheaf.IsSheaf J (J.sheafify P)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma preΨ_neg (n : ℤ) : W.preΨ (-n) = -W.preΨ n
-- Mathlib/Data/List/Basic.lean
theorem choose_property (hp : ∃ a, a ∈ l ∧ p a) : p (choose p l hp)
-- Mathlib/Analysis/RCLike/Basic.lean
theorem normSq_apply (z : K) : normSq z = re z * re z + im z * im z
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
lemma Set.MapsTo.lipschitzOnWith_iff_restrict {t : Set β} (h : MapsTo f s t) :
    LipschitzOnWith K f s ↔ LipschitzWith K (h.restrict f s t)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem not_irreducible_C (x : R) : ¬Irreducible (C x)
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
/-- Let `X` be a topological space, and suppose that for all distinct `x,y ∈ X`, there
  is some clopen set `U` such that `x ∈ U` and `y ∉ U`. Then `X` is totally disconnected. -/
theorem isTotallyDisconnected_of_isClopen_set {X : Type*} [TopologicalSpace X]
    (hX : Pairwise fun x y => ∃ (U : Set X), IsClopen U ∧ x ∈ U ∧ y ∉ U) :
    IsTotallyDisconnected (Set.univ : Set X)
-- Mathlib/Order/UpperLower/Basic.lean
lemma erase_le : s.erase a ≤ s
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem coe_nsmul (r : ℕ) (f : NormedAddGroupHom V₁ V₂) : ⇑(r • f) = r • ⇑f
-- Mathlib/RingTheory/Norm/Basic.lean
theorem _root_.IntermediateField.AdjoinSimple.norm_gen_eq_one {x : L} (hx : ¬IsIntegral K x) :
    norm K (AdjoinSimple.gen K x) = 1
-- Mathlib/Analysis/Normed/Order/Lattice.lean
/--
Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say, for `a` and `b` in
`α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`. Then `α` is
said to be a normed lattice ordered group.
-/
class NormedLatticeAddCommGroup (α : Type*) extends
    NormedAddCommGroup α, Lattice α, HasSolidNorm α where
  add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
-- Mathlib/Data/Set/Function.lean
@[simp] theorem bijOn_empty_iff_left : BijOn f s ∅ ↔ s = ∅
-- Mathlib/CategoryTheory/Opposites.lean
/-- The opposite of a natural transformation. -/
@[simps]
protected def op (α : F ⟶ G) : G.op ⟶ F.op
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_trim (hm : m ≤ m0) {f : β → G} (hf : StronglyMeasurable[m] f) :
    ∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm
-- Mathlib/Data/Multiset/Basic.lean
private theorem add_le_add_iff_left' {s t u : Multiset α} : s + t ≤ s + u ↔ t ≤ u
-- Mathlib/Order/Filter/Basic.lean
theorem map_bind {α β} (m : β → γ) (f : Filter α) (g : α → Filter β) :
    map m (bind f g) = bind f (map m ∘ g)
-- Mathlib/Order/Bounds/Basic.lean
/-- In a codirected order, the union of two sets is bounded below if and only if both sets are. -/
theorem bddBelow_union [IsDirected α (· ≥ ·)] {s t : Set α} :
    BddBelow (s ∪ t) ↔ BddBelow s ∧ BddBelow t
-- Mathlib/Algebra/Ring/Hom/Defs.lean
/-- Ring homomorphisms map one to one. -/
protected theorem map_one (f : α →+* β) : f 1 = 1
-- Mathlib/LinearAlgebra/Span.lean
/-- If the range of `v : ι → M` generates the whole module and linear maps `f`, `g` are equal at
each `v i`, then they are equal. -/
theorem ext_on_range {ι : Sort*} {v : ι → M} {f g : F} (hv : span R (Set.range v) = ⊤)
    (h : ∀ i, f (v i) = g (v i)) : f = g
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_lt_smul_of_lt_of_le' [PosSMulMono α β] [SMulPosStrictMono α β] (ha : a₁ < a₂)
    (hb : b₁ ≤ b₂) (h₂ : 0 ≤ a₂) (h₁ : 0 < b₁) : a₁ • b₁ < a₂ • b₂