ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem fromLoop_symm_toLoop {i : N} {p : Ω^ N X x} : fromLoop i (toLoop i p).symm = symmAt i p
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem curryLeft_compAlternatingMap {n : ℕ} (g : N'' →ₗ[R'] N₂'')
    (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') (m : M'') :
    (g.compAlternatingMap f).curryLeft m = g.compAlternatingMap (f.curryLeft m)
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
lemma IsHamiltonianCycle.support_count_of_ne (hp : p.IsHamiltonianCycle) (h : a ≠ b) :
    p.support.count b = 1
-- Mathlib/Topology/Sheaves/Skyscraper.lean
/-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def SkyscraperPresheafFunctor.map' {a b : C} (f : a ⟶ b) :
    skyscraperPresheaf p₀ a ⟶ skyscraperPresheaf p₀ b
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
theorem coe_ne_neg_one (z : 𝔻) : (z : ℂ) ≠ -1
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
/-- Convergence of finite measures implies the convergence of their total masses. -/
theorem _root_.Filter.Tendsto.mass {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    {μ : FiniteMeasure Ω} (h : Tendsto μs F (𝓝 μ)) : Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem comm_symm_tmul (m : M) (n : N) : (TensorProduct.comm R M N).symm (n ⊗ₜ m) = m ⊗ₜ n
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem not_isLeftDescent_iff {w : W} {i : B} :
    ¬cs.IsLeftDescent w i ↔ ℓ (s i * w) = ℓ w + 1
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ioo_Iio {a b : α} (c : Ioo a b) : Subtype.val '' Iio c = Ioo a c
-- Mathlib/Topology/Instances/Matrix.lean
theorem HasSum.matrix_blockDiagonal' [DecidableEq l] {f : X → ∀ i, Matrix (m' i) (n' i) R}
    {a : ∀ i, Matrix (m' i) (n' i) R} (hf : HasSum f a) :
    HasSum (fun x => blockDiagonal' (f x)) (blockDiagonal' a)
-- Mathlib/Algebra/GeomSum.lean
/-- $x^n-y^n = (x-y) \sum x^ky^{n-1-k}$ reformulated without `-` signs. -/
protected theorem Commute.geom_sum₂_mul_add {x y : α} (h : Commute x y) (n : ℕ) :
    (∑ i ∈ range n, (x + y) ^ i * y ^ (n - 1 - i)) * x + y ^ n = (x + y) ^ n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_le_sub_right {a b : Int} (h : a ≤ b) (c : Int) : a - c ≤ b - c
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem self_trans_symm (e : α ≃+*o β) : e.trans e.symm = OrderRingIso.refl α
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- Any entry of any member of `l.ranges` is strictly smaller than `l.sum`. -/
lemma mem_mem_ranges_iff_lt_sum (l : List ℕ) {n : ℕ} :
    (∃ s ∈ l.ranges, n ∈ s) ↔ n < l.sum
-- Mathlib/Data/Bool/Basic.lean
@[simp] lemma toNat_bne_zero (b : Bool) : (b.toNat != 0) =  b
-- Mathlib/CategoryTheory/Shift/Basic.lean
theorem shiftZero' : f⟦(0 : A)⟧' = (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv
-- Mathlib/CategoryTheory/Subobject/Basic.lean
@[simp]
theorem mapIsoToOrderIso_symm_apply (e : X ≅ Y) (Q : Subobject Y) :
    (mapIsoToOrderIso e).symm Q = (map e.inv).obj Q
-- Mathlib/SetTheory/Game/PGame.lean
@[trans]
theorem le_of_le_of_equiv {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm of an integer `m` is one iff `p` doesn't divide `m`. -/
theorem int_eq_one_iff (m : ℤ) : padicNorm p m = 1 ↔ ¬(p : ℤ) ∣ m
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the signs of two oriented angles between nonzero vectors are equal, the oriented angles are
equal if and only if the unoriented angles are equal. -/
theorem angle_eq_iff_oangle_eq_of_sign_eq {w x y z : V} (hw : w ≠ 0) (hx : x ≠ 0) (hy : y ≠ 0)
    (hz : z ≠ 0) (hs : (o.oangle w x).sign = (o.oangle y z).sign) :
    InnerProductGeometry.angle w x = InnerProductGeometry.angle y z ↔
    o.oangle w x = o.oangle y z
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
/-- This is a technical result to ensure that the image of the `ℂ`-basis of `ℂ^n` defined in
`canonicalEmbedding.latticeBasis` is a `ℝ`-basis of `ℝ^r₁ × ℂ^r₂`,
see `mixedEmbedding.latticeBasis`. -/
theorem disjoint_span_commMap_ker [NumberField K] :
    Disjoint (Submodule.span ℝ (Set.range (canonicalEmbedding.latticeBasis K)))
      (LinearMap.ker (commMap K))
-- Mathlib/Topology/Instances/EReal.lean
lemma limsup_le_limsup (h : u ≤ᶠ[f] v) :
    limsup u f ≤ limsup v f
-- Mathlib/Analysis/Calculus/SmoothSeries.lean
/-- Consider a series of functions `∑' n, f n x`. If the series converges at a
point, and all functions in the series are differentiable with a summable bound on the derivatives,
then the series converges everywhere. -/
theorem summable_of_summable_hasFDerivAt (hu : Summable u)
    (hf : ∀ n x, HasFDerivAt (f n) (f' n x) x) (hf' : ∀ n x, ‖f' n x‖ ≤ u n)
    (hf0 : Summable fun n => f n x₀) (x : E) : Summable fun n => f n x
-- Mathlib/Order/Filter/Basic.lean
theorem mem_of_superset {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
@[simp] lemma UniformFun.ofFun_toFun (f : α →ᵤ β) : ofFun (toFun f) = f
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem id_apply (a : α) : CoheytingHom.id α a = a
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mk_one : mk 1 (1 : S) = 1
-- Mathlib/Order/Monotone/Monovary.lean
@[simp]
theorem monovary_toDual_left : Monovary (toDual ∘ f) g ↔ Antivary f g
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma jacobiTheta₂_fderiv_undef (z : ℂ) {τ : ℂ} (hτ : im τ ≤ 0) : jacobiTheta₂_fderiv z τ = 0
-- Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean
theorem uniformContinuous_eval_const [∀ i, ContinuousSMul 𝕜 (E i)] (x : Π i, E i) :
    UniformContinuous fun f : ContinuousMultilinearMap 𝕜 E F ↦ f x
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean
@[continuity, fun_prop]
lemma continuous_log : Continuous log
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_map_left (f : α' → β → γ) (g : α → α') (A : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f (A.map g) B = kroneckerMap (fun a b => f (g a) b) A B
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
lemma ofReal_eq_natCast {r : ℝ} {n : ℕ} (h : n ≠ 0) : ENNReal.ofReal r = n ↔ r = n
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[norm_cast, simp]
theorem coe_coe (e : P₁ ≃ᵃ[k] P₂) : ((e : P₁ →ᵃ[k] P₂) : P₁ → P₂) = e
-- Mathlib/Data/List/Chain.lean
theorem Chain'.rel_head? {x l} (h : Chain' R (x :: l)) ⦃y⦄ (hy : y ∈ head? l) : R x y
-- Mathlib/LinearAlgebra/PerfectPairing.lean
theorem toDualLeft_of_toDualRight_symm (x : M) (f : Dual R M) :
    (p.toDualLeft x) (p.toDualRight.symm f) = f x
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasFDerivAt.const_cpow (hf : HasFDerivAt f f' x) (h0 : c ≠ 0 ∨ f x ≠ 0) :
    HasFDerivAt (fun x => c ^ f x) ((c ^ f x * Complex.log c) • f') x
-- Mathlib/Data/Multiset/Basic.lean
theorem replicate_one (a : α) : replicate 1 a = {a}
-- Mathlib/CategoryTheory/Comma/Over.lean
/-- To give a morphism in the over category, it suffices to give an arrow fitting in a commutative
    triangle. -/
@[simps!]
def homMk {U V : Over X} (f : U.left ⟶ V.left) (w : f ≫ V.hom = U.hom := by aesop_cat) : U ⟶ V
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem val_mul' {m n : ZMod 0} : (m * n).val = m.val * n.val
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem coe_map (f : F) (s : NonUnitalSubsemiring R) : (s.map f : Set S) = f '' s
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem support_mk'_subset {f : ∀ i, β i} {s : Multiset ι} {h} :
    (mk' f <| Trunc.mk ⟨s, h⟩).support ⊆ s.toFinset
-- Mathlib/Analysis/Convolution.lean
theorem convolution_smul [SMulCommClass ℝ 𝕜 F] {y : 𝕜} : f ⋆[L, μ] y • g = y • (f ⋆[L, μ] g)
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma BoundaryLE.not_mem {j : ι} (hj : e.BoundaryLE j) {k' : ι'} (hk' : c'.Rel (e.f j) k')
    (a : ι) : e.f a ≠ k'
-- Mathlib/Order/Basic.lean
protected theorem false [Preorder α] {x : α} : x < x → False
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_add_nonpos_left' (hf : ∀ᶠ x in l, f x ≤ 0) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot
-- Mathlib/NumberTheory/SiegelsLemma.lean
/-- The sup norm of a non-zero integer matrix is at least one  -/
lemma one_le_norm_A_of_ne_zero (hA : A ≠ 0) : 1 ≤ ‖A‖
-- Mathlib/Data/Finset/Basic.lean
lemma cons_sdiff_cons (hab : a ≠ b) (ha hb) : s.cons a ha \ s.cons b hb = {a}
-- Mathlib/Analysis/Seminorm.lean
theorem ball_zero_eq_preimage_ball {r : ℝ} : p.ball 0 r = p ⁻¹' Metric.ball 0 r
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- Reformulation of equicontinuity at `x₀` within a set `S`, comparing two variables near `x₀`
instead of comparing only one with `x₀`. -/
theorem equicontinuousWithinAt_iff_pair {F : ι → X → α} {S : Set X} {x₀ : X} (hx₀ : x₀ ∈ S) :
    EquicontinuousWithinAt F S x₀ ↔
      ∀ U ∈ 𝓤 α, ∃ V ∈ 𝓝[S] x₀, ∀ x ∈ V, ∀ y ∈ V, ∀ i, (F i x, F i y) ∈ U
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem support_single_subset : support (single a r) ⊆ {a}
-- Mathlib/Data/Part.lean
theorem get_eq_get_of_eq (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b) :
    a.get ha = b.get (h ▸ ha)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem IsProbabilityMeasure.ae_neBot [IsProbabilityMeasure μ] : NeBot (ae μ)
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem mrange_inl : mrange (inl M N) = prod ⊤ ⊥
-- Mathlib/Data/Finset/Image.lean
theorem image_mono (f : α → β) : Monotone (Finset.image f)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem toIdeal_iInf {κ : Sort*} (s : κ → HomogeneousIdeal 𝒜) :
    (⨅ i, s i).toIdeal = ⨅ i, (s i).toIdeal
-- Mathlib/Data/Set/Finite.lean
protected theorem subset (s : Set α) {t : Set α} [Finite s] (h : t ⊆ s) : Finite t
-- Mathlib/LinearAlgebra/LinearPMap.lean
/-- The graph of `z • f` as a pushforward. -/
theorem smul_graph (f : E →ₗ.[R] F) (z : M) :
    (z • f).graph =
      f.graph.map ((LinearMap.id : E →ₗ[R] E).prodMap (z • (LinearMap.id : F →ₗ[R] F)))
-- Mathlib/Probability/Distributions/Uniform.lean
@[simp]
theorem support_ofMultiset : (ofMultiset s hs).support = s.toFinset
-- Mathlib/Analysis/Convex/Cone/InnerDual.lean
/-- The dual cone of `s` equals the intersection of dual cones of the points in `s`. -/
theorem innerDualCone_eq_iInter_innerDualCone_singleton :
    (s.innerDualCone : Set H) = ⋂ i : s, (({↑i} : Set H).innerDualCone : Set H)
-- Mathlib/Order/UpperLower/Basic.lean
lemma fibration_iff_isUpperSet_image [Preorder α] [LE β] :
    Fibration (· ≥ ·) (· ≥ ·) f ↔ ∀ s, IsUpperSet s → IsUpperSet (f '' s)
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
@[ext]
lemma hom_ext (f g : F ⟶ G) (h : f.hom = g.hom) : f = g
-- Mathlib/Computability/Primrec.lean
theorem list_foldr {f : α → List β} {g : α → σ} {h : α → β × σ → σ} (hf : Primrec f)
    (hg : Primrec g) (hh : Primrec₂ h) :
    Primrec fun a => (f a).foldr (fun b s => h a (b, s)) (g a)
-- Mathlib/Topology/UniformSpace/Equiv.lean
theorem completeSpace_iff (h : α ≃ᵤ β) : CompleteSpace α ↔ CompleteSpace β
-- Mathlib/Data/Prod/Basic.lean
protected theorem ext_iff {p q : α × β} : p = q ↔ p.1 = q.1 ∧ p.2 = q.2
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- We can pull out a product over a list in the first argument of the Jacobi symbol. -/
theorem list_prod_left {l : List ℤ} {n : ℕ} : J(l.prod | n) = (l.map fun a => J(a | n)).prod
-- Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean
theorem finite_integral_one_add_norm {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    (∫⁻ x : E, ENNReal.ofReal ((1 + ‖x‖) ^ (-r)) ∂μ) < ∞
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem Matrix.toMatrix₂Aux_toLinearMap₂'Aux (f : Matrix n m N₂) :
    LinearMap.toMatrix₂Aux R (fun i => LinearMap.stdBasis R₁ (fun _ => R₁) i 1)
        (fun j => LinearMap.stdBasis R₂ (fun _ => R₂) j 1) (f.toLinearMap₂'Aux σ₁ σ₂) =
      f
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma mul_div_mul_right (a b : G₀) (hc : c ≠ 0) : a * c / (b * c) = a / b
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
private theorem eq_of_posPart_eq_posPart {j₁ j₂ : JordanDecomposition α}
    (hj : j₁.posPart = j₂.posPart) (hj' : j₁.toSignedMeasure = j₂.toSignedMeasure) : j₁ = j₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem?_cons_succ {l : List α} : (a::l)[n+1]? = l[n]?
-- Mathlib/Computability/Primrec.lean
theorem list_reverse : Primrec (@List.reverse α)
-- Mathlib/CategoryTheory/Limits/Lattice.lean
/-- The pushout in the category of a `SemilatticeSup` with `OrderBot` is the same as the supremum
over the objects.
-/
@[simp]
theorem pushout_eq_sup [SemilatticeSup α] [OrderBot α] (x y z : α) (f : z ⟶ x) (g : z ⟶ y) :
    pushout f g = x ⊔ y
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem tendsto_nhds_right {f : Filter β} {u : β → α} {a : α} :
    Tendsto u f (𝓝 a) ↔ Tendsto (fun x => (a, u x)) f (𝓤 α)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem lintegral_eq_of_subset' (f : α →ₛ ℝ≥0∞) {s : Finset ℝ≥0∞} (hs : f.range \ {0} ⊆ s) :
    f.lintegral μ = ∑ x ∈ s, x * μ (f ⁻¹' {x})
-- Mathlib/CategoryTheory/Extensive.lean
theorem finitaryExtensive_of_preserves_and_reflects_isomorphism (F : C ⥤ D) [FinitaryExtensive D]
    [HasFiniteCoproducts C] [HasPullbacks C] [PreservesLimitsOfShape WalkingCospan F]
    [PreservesColimitsOfShape (Discrete WalkingPair) F] [F.ReflectsIsomorphisms] :
    FinitaryExtensive C
-- Mathlib/Topology/Sheaves/Presheaf.lean
@[simp] theorem comp_app {X : TopCat} {U : (Opens X)ᵒᵖ} {P Q R : Presheaf C X}
    (f : P ⟶ Q) (g : Q ⟶ R) :
    (f ≫ g).app U = f.app U ≫ g.app U
-- Mathlib/Topology/Order.lean
/-- This lemma characterizes discrete topological spaces as those whose singletons are
neighbourhoods. -/
theorem discreteTopology_iff_nhds [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, 𝓝 x = pure x
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- `p` is a Taylor series of `f` up to `n+1` if and only if `p.shift` is a Taylor series up to `n`
for `p 1`, which is a derivative of `f`. -/
theorem hasFTaylorSeriesUpToOn_succ_iff_right {n : ℕ} :
    HasFTaylorSeriesUpToOn (n + 1 : ℕ) f p s ↔
      (∀ x ∈ s, (p x 0).uncurry0 = f x) ∧
        (∀ x ∈ s, HasFDerivWithinAt (fun y => p y 0) (p x 1).curryLeft s x) ∧
          HasFTaylorSeriesUpToOn n (fun x => continuousMultilinearCurryFin1 𝕜 E F (p x 1))
            (fun x => (p x).shift) s
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem ofDual_iSup (f : ι → αᵒᵈ) : ofDual (⨆ i, f i) = ⨅ i, ofDual (f i)
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
theorem Real.exp_eq_exp_ℝ : Real.exp = NormedSpace.exp ℝ
-- Mathlib/Computability/Primrec.lean
theorem option_getD : Primrec₂ (@Option.getD α)
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
@[simp]
theorem map (hφ : IsSymmetric φ) (f : R →+* S) : IsSymmetric (map f φ)
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma pow_eq_neg_one_iff : a ^ n = -1 ↔ a = -1 ∧ Odd n
-- Mathlib/Data/Multiset/Basic.lean
@[simp] lemma le_singleton : s ≤ {a} ↔ s = 0 ∨ s = {a}
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_toHomeomorph : ⇑e.toHomeomorph = e
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem equiv_symm : (equiv i j p).symm = equiv j i p
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem half_pos (h : a ≠ 0) : 0 < a / 2
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma compProd_zero_left (κ : Kernel (α × β) γ) :
    (0 : Kernel α β) ⊗ₖ κ = 0
-- Mathlib/Computability/TuringMachine.lean
theorem BlankExtends.below_of_le {Γ} [Inhabited Γ] {l l₁ l₂ : List Γ} :
    BlankExtends l l₁ → BlankExtends l l₂ → l₁.length ≤ l₂.length → BlankExtends l₁ l₂
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem le_antisymm {a b : ℤ√d} (ab : a ≤ b) (ba : b ≤ a) : a = b
-- Mathlib/Data/Set/Image.lean
theorem Nonempty.of_image {f : α → β} {s : Set α} : (f '' s).Nonempty → s.Nonempty
-- Mathlib/Algebra/GroupWithZero/Hom.lean
protected lemma map_one (f : α →*₀ β) : f 1 = 1
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem normalize_eq_zero {x : α} : normalize x = 0 ↔ x = 0
-- Mathlib/Order/Partition/Equipartition.lean
theorem IsEquipartition.filter_ne_average_add_one_eq_average (hP : P.IsEquipartition) :
    P.parts.filter (fun p ↦ ¬p.card = s.card / P.parts.card + 1) =
    P.parts.filter (fun p ↦ p.card = s.card / P.parts.card)
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem iUnion_eq : ⋃ n, K n = univ
-- Mathlib/GroupTheory/Perm/Fin.lean
theorem cycleRange_apply {n : ℕ} (i j : Fin n.succ) :
    cycleRange i j = if j < i then j + 1 else if j = i then 0 else j
-- Mathlib/Algebra/Category/ModuleCat/Free.lean
/-- In the commutative diagram
```
             f     g
    0 --→ X₁ --→ X₂ --→ X₃
          ↑      ↑      ↑
         v|     u|     w|
          ι  → ι ⊕ ι' ← ι'
```
where the top row is an exact sequence of modules and the maps on the bottom are `Sum.inl` and
`Sum.inr`. If `u` is injective and `v` and `w` are linearly independent, then `u` is linearly
independent. -/
theorem linearIndependent_leftExact : LinearIndependent R u
-- Mathlib/Data/Finset/Functor.lean
theorem map_traverse (g : α → G β) (h : β → γ) (s : Finset α) :
    Functor.map h <$> traverse g s = traverse (Functor.map h ∘ g) s
-- Mathlib/Data/Real/Hyperreal.lean
theorem IsSt.isSt_st {x : ℝ*} {r : ℝ} (hxr : IsSt x r) : IsSt x (st x)
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sup_sdiff_self (a b : α) : a ⊔ b \ a = a ⊔ b
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurable_of_le [TopologicalSpace ι] [MeasurableSpace ι] [BorelSpace ι]
    [OrderTopology ι] [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) {i : ι}
    (hτ_le : ∀ ω, τ ω ≤ i) : Measurable[f i] τ
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
protected theorem Multipliable.map [CommMonoid γ] [TopologicalSpace γ] (hf : Multipliable f) {G}
    [FunLike G α γ] [MonoidHomClass G α γ] (g : G) (hg : Continuous g) : Multipliable (g ∘ f)
-- Mathlib/Topology/CompactOpen.lean
theorem continuous_const' : Continuous (const X : Y → C(X, Y))
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem comap_comap (s : NonUnitalSubsemiring T) (g : G) (f : F) :
    ((s.comap g : NonUnitalSubsemiring S).comap f : NonUnitalSubsemiring R) =
      s.comap ((g : S →ₙ+* T).comp (f : R →ₙ+* S))
-- Mathlib/Algebra/Field/Basic.lean
theorem div_add_same (h : b ≠ 0) : (a + b) / b = a / b + 1
-- Mathlib/ModelTheory/ElementaryMaps.lean
@[simp]
theorem map_boundedFormula (f : M ↪ₑ[L] N) {α : Type*} {n : ℕ} (φ : L.BoundedFormula α n)
    (v : α → M) (xs : Fin n → M) : φ.Realize (f ∘ v) (f ∘ xs) ↔ φ.Realize v xs
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem subgroup_eq_top_of_swap_mem [DecidableEq α] {H : Subgroup (Perm α)}
    [d : DecidablePred (· ∈ H)] {τ : Perm α} (h0 : (Fintype.card α).Prime)
    (h1 : Fintype.card α ∣ Fintype.card H) (h2 : τ ∈ H) (h3 : IsSwap τ) : H = ⊤
-- Mathlib/Algebra/Group/Ext.lean
@[to_additive]
lemma CommGroup.toGroup_injective {G : Type*} : Injective (@CommGroup.toGroup G)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Nat.le_zero_eq (a : Nat) : (a ≤ 0) = (a = 0)
-- Mathlib/LinearAlgebra/Dual.lean
@[mono]
theorem dualAnnihilator_anti {U V : Submodule R M} (hUV : U ≤ V) :
    V.dualAnnihilator ≤ U.dualAnnihilator
-- Mathlib/Order/Heyting/Hom.lean
@[ext]
theorem ext {f g : BiheytingHom α β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem List.nnnorm_prod_le [NormOneClass α] (l : List α) : ‖l.prod‖₊ ≤ (l.map nnnorm).prod
-- Mathlib/NumberTheory/Liouville/Measure.lean
theorem setOf_liouvilleWith_subset_aux :
    { x : ℝ | ∃ p > 2, LiouvilleWith p x } ⊆
      ⋃ m : ℤ, (· + (m : ℝ)) ⁻¹' ⋃ n > (0 : ℕ),
        { x : ℝ | ∃ᶠ b : ℕ in atTop, ∃ a ∈ Finset.Icc (0 : ℤ) b,
          |x - (a : ℤ) / b| < 1 / (b : ℝ) ^ (2 + 1 / n : ℝ) }
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
/-- Convergence along filters for `WithSeminorms`.

Variant with `Finset.sup`. -/
theorem WithSeminorms.tendsto_nhds' (hp : WithSeminorms p) (u : F → E) {f : Filter F} (y₀ : E) :
    Filter.Tendsto u f (𝓝 y₀) ↔
    ∀ (s : Finset ι) (ε), 0 < ε → ∀ᶠ x in f, s.sup p (u x - y₀) < ε
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem transpose_eq_one [DecidableEq n] [Zero α] [One α] {M : Matrix n n α} : Mᵀ = 1 ↔ M = 1
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem basisFun_repr (x : PiLp p fun _ : ι => 𝕜) (i : ι) : (basisFun p 𝕜 ι).repr x i = x i
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp)]
theorem map₂_div : map₂ (· / ·) f g = f / g
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.diff_left (l : List α) {t₁ t₂ : List α} (h : t₁ ~ t₂) : l.diff t₁ = l.diff t₂
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Equitabilise.lean
theorem equitabilise_isEquipartition : (P.equitabilise h).IsEquipartition
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- Any map on a subsingleton is an isometry -/
@[nontriviality]
theorem _root_.isometry_subsingleton [Subsingleton α] : Isometry f
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
theorem inverse_mul_cancel (x : M₀) (h : IsUnit x) : inverse x * x = 1
-- Mathlib/Computability/DFA.lean
@[simp]
theorem eval_reindex (g : σ ≃ σ') (x : List α) : (reindex g M).eval x = g (M.eval x)
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem toAdd_pow [AddMonoid α] (a : Multiplicative α) (n : ℕ) : toAdd (a ^ n) = n • toAdd a
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_right_right_iff {x y z : R} : IsRelPrime x (z * x + y) ↔ IsRelPrime x y
-- Mathlib/Data/Nat/Squarefree.lean
theorem minSqFacProp_div (n) {k} (pk : Prime k) (dk : k ∣ n) (dkk : ¬k * k ∣ n) {o}
    (H : MinSqFacProp (n / k) o) : MinSqFacProp n o
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem eq_tsub_of_add_eq (h : a + c = b) : a = b - c
-- Mathlib/Topology/Basic.lean
theorem Set.Finite.closure_sUnion {S : Set (Set X)} (hS : S.Finite) :
    closure (⋃₀ S) = ⋃ s ∈ S, closure s
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem mk'_toSubsemigroup {s : Set R} {sm : Subsemigroup R} (hm : ↑sm = s) {sa : AddSubgroup R}
    (ha : ↑sa = s) : (NonUnitalSubring.mk' s sm sa hm ha).toSubsemigroup = sm
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem decompose_sub (x y : M) : decompose ℳ (x - y) = decompose ℳ x - decompose ℳ y
-- Mathlib/Data/Fintype/Card.lean
/-- `Fin` as a map from `ℕ` to `Type` is injective. Note that since this is a statement about
equality of types, using it should be avoided if possible. -/
theorem fin_injective : Function.Injective Fin
-- Mathlib/Analysis/Convex/Body.lean
/-- Let `K` be a convex body that contains `0` and let `u n` be a sequence of nonnegative real
numbers that tends to `0`. Then the intersection of the dilated bodies `(1 + u n) • K` is equal
to `K`. -/
theorem iInter_smul_eq_self [T2Space V] {u : ℕ → ℝ≥0} (K : ConvexBody V) (h_zero : 0 ∈ K)
    (hu : Tendsto u atTop (𝓝 0)) :
    ⋂ n : ℕ, (1 + (u n : ℝ)) • (K : Set V) = K
-- Mathlib/Topology/Order/LeftRightNhds.lean
/-- A set is a neighborhood of `a` within `(-∞, a]` if and only if it contains an interval `(l, a]`
with `l < a`. -/
theorem mem_nhdsWithin_Iic_iff_exists_Ioc_subset [NoMinOrder α] {a : α} {s : Set α} :
    s ∈ 𝓝[≤] a ↔ ∃ l ∈ Iio a, Ioc l a ⊆ s
-- Mathlib/CategoryTheory/Closed/Ideal.lean
theorem bijection_symm_apply_id (A B : C) :
    (bijection i A B _).symm (𝟙 _) = prodComparison _ _ _
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem mkReal_coe (φ : { φ : K →+* ℂ // ComplexEmbedding.IsReal φ }) :
    (mkReal φ : InfinitePlace K) = mk (φ : K →+* ℂ)
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive]
theorem measurableEmbedding_inv [InvolutiveInv α] [MeasurableInv α] :
    MeasurableEmbedding (Inv.inv (α := α))
-- Mathlib/Algebra/Star/Order.lean
lemma star_le_iff {x y : R} : star x ≤ y ↔ x ≤ star y
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
theorem closedEmbedding_smul_left {c : E} (hc : c ≠ 0) : ClosedEmbedding fun x : 𝕜 => x • c