ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Fin/Basic.lean
theorem succ_ne_last_iff (a : Fin (n + 1)) : succ a ≠ last (n + 1) ↔ a ≠ last n
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem continuousOn_extend : ContinuousOn (f.extend I) (f.extend I).source
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp, norm_cast]
theorem coeFn_add (μ ν : FiniteMeasure Ω) : (⇑(μ + ν) : Set Ω → ℝ≥0) = (⇑μ + ⇑ν : Set Ω → ℝ≥0)
-- Mathlib/Order/Minimal.lean
theorem RelIso.minimals_preimage_eq (f : r ≃r s) (y : Set β) :
    minimals r (f ⁻¹' y) = f ⁻¹' (minimals s y)
-- Mathlib/Topology/Algebra/Polynomial.lean
@[continuity, fun_prop]
protected theorem continuous_eval₂ [Semiring S] (p : S[X]) (f : S →+* R) :
    Continuous fun x => p.eval₂ f x
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Filter.Tendsto.subseq_mem_entourage {V : ℕ → Set (α × α)} (hV : ∀ n, V n ∈ 𝓤 α) {u : ℕ → α}
    {a : α} (hu : Tendsto u atTop (𝓝 a)) : ∃ φ : ℕ → ℕ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧
      ∀ n, (u <| φ (n + 1), u <| φ n) ∈ V (n + 1)
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem factorial_dvd_descFactorial (n k : ℕ) : k ! ∣ n.descFactorial k
-- Mathlib/AlgebraicTopology/DoldKan/Decomposition.lean
/-- In each positive degree, this lemma decomposes the idempotent endomorphism
`Q q` as a sum of morphisms which are postcompositions with suitable degeneracies.
As `Q q` is the complement projection to `P q`, this implies that in the case of
simplicial abelian groups, any $(n+1)$-simplex $x$ can be decomposed as
$x = x' + \sum (i=0}^{q-1} σ_{n-i}(y_i)$ where $x'$ is in the image of `P q` and
the $y_i$ are in degree $n$. -/
theorem decomposition_Q (n q : ℕ) :
    ((Q q).f (n + 1) : X _[n + 1] ⟶ X _[n + 1]) =
      ∑ i ∈ Finset.filter (fun i : Fin (n + 1) => (i : ℕ) < q) Finset.univ,
        (P i).f (n + 1) ≫ X.δ i.rev.succ ≫ X.σ (Fin.rev i)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_toLinearIsometry : ⇑e.toLinearIsometry = e
-- Mathlib/GroupTheory/GroupAction/Hom.lean
theorem ext_ring_iff {f g : R →ₑ+[σ] N'} : f = g ↔ f 1 = g 1
-- Mathlib/Control/LawfulFix.lean
theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[field_simps] lemma div_eq_iff (hb : b ≠ 0) : a / b = c ↔ a = c * b
-- Mathlib/Order/SuccPred/Limit.lean
@[simp]
theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₃_eq_zero_iff_mono₁ : T.mor₃ = 0 ↔ Mono T.mor₁
-- Mathlib/Algebra/Associated/Basic.lean
theorem bot_eq_one [Monoid α] : (⊥ : Associates α) = 1
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
theorem mapMono_eq_zero (i : Δ' ⟶ Δ) [Mono i] (h₁ : Δ ≠ Δ') (h₂ : ¬Isδ₀ i) : mapMono K i = 0
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem condexp_zero_or_one_of_measurableSet_limsup [StandardBorelSpace Ω] [Nonempty Ω]
    (hm : m ≤ m0) [IsFiniteMeasure μ]
    (h_le : ∀ n, s n ≤ m0) (h_indep : iCondIndep m hm s μ)
    (hf : ∀ t, p t → tᶜ ∈ f) (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a))
    (hns_univ : ∀ n, ∃ a, n ∈ ns a) {t : Set Ω} (ht_tail : MeasurableSet[limsup s f] t) :
    ∀ᵐ ω ∂μ, (μ⟦t | m⟧) ω = 0 ∨ (μ⟦t | m⟧) ω = 1
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem IsRefl.nondegenerate_of_separatingRight {B : M →ₗ[R] M →ₗ[R] M₁} (hB : B.IsRefl)
    (hB' : B.SeparatingRight) : B.Nondegenerate
-- Mathlib/Algebra/Order/Ring/Canonical.lean
lemma tsub_one_mul (a b : α) : (a - 1) * b = a * b - b
-- Mathlib/Data/List/MinMax.lean
@[simp]
theorem argAux_self (hr₀ : Irreflexive r) (a : α) : argAux r (some a) a = a
-- Mathlib/Topology/Sets/Closeds.lean
@[simp, norm_cast]
theorem coe_iInf {ι} (s : ι → Closeds α) : ((⨅ i, s i : Closeds α) : Set α) = ⋂ i, s i
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem coe_range : (f.range : Set S) = Set.range f
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
@[simp]
theorem coe_pointwise_smul (m : M) (S : Subring R) : ↑(m • S) = m • (S : Set R)
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem neg_pi_lt_log_im (x : ℂ) : -π < (log x).im
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem sup_eq_add (I J : FractionalIdeal S P) : I ⊔ J = I + J
-- Mathlib/CategoryTheory/Sigma/Basic.lean
/-- The inclusion functor into the disjoint union of categories. -/
@[simps map]
def incl (i : I) : C i ⥤ Σi, C i
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem Memℒp.norm_rpow {f : α → E} (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp (fun x : α => ‖f x‖ ^ p.toReal) 1 μ
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- A closed operator is trivially closable. -/
theorem IsClosed.isClosable {f : E →ₗ.[R] F} (hf : f.IsClosed) : f.IsClosable
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem of_iSup_eq_top
    {ι} (U : ι → Y.affineOpens) (hU : ⨆ i, (U i : Y.Opens) = ⊤)
    (hU' : ∀ i, Q (f ∣_ U i)) :
    P f
-- Mathlib/Topology/Connected/Basic.lean
theorem connectedComponentIn_univ (x : α) : connectedComponentIn univ x = connectedComponent x
-- Mathlib/Data/Fin/Basic.lean
/-- Embedding `Fin n` into `Fin (n + 1)` with a hole around `last n` embeds by `castSucc`. -/
@[simp] lemma succAbove_last : succAbove (last n) = castSucc
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_singleton_one : adjoin R ({1} : Set A) = ⊥
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem CauchySeq.mem_entourage {β : Type*} [SemilatticeSup β] {u : β → α} (h : CauchySeq u)
    {V : Set (α × α)} (hV : V ∈ 𝓤 α) : ∃ k₀, ∀ i j, k₀ ≤ i → k₀ ≤ j → (u i, u j) ∈ V
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[deprecated (since := "2024-06-09")] theorem card_divisors (n : ℕ) (hn : n ≠ 0) :
    n.divisors.card = n.primeFactors.prod (n.factorization · + 1)
-- Mathlib/Data/Num/Lemmas.lean
theorem zneg_pos (n : PosNum) : -pos n = neg n
-- Mathlib/Order/Filter/Basic.lean
theorem mem_map_seq_iff {f : Filter α} {g : Filter β} {m : α → β → γ} {s : Set γ} :
    s ∈ (f.map m).seq g ↔ ∃ t u, t ∈ g ∧ u ∈ f ∧ ∀ x ∈ u, ∀ y ∈ t, m x y ∈ s
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem isClique_map_iff_of_nontrivial {f : α ↪ β} {t : Set β} (ht : t.Nontrivial) :
    (G.map f).IsClique t ↔ ∃ (s : Set α), G.IsClique s ∧ f '' s = t
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem adj_comm (G' : Subgraph G) (v w : V) : G'.Adj v w ↔ G'.Adj w v
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- A rotation of a vector equals that vector if and only if the vector or the angle is zero. -/
theorem rotation_eq_self_iff (x : V) (θ : Real.Angle) : o.rotation θ x = x ↔ x = 0 ∨ θ = 0
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
@[reassoc (attr := simp, elementwise)]
lemma moduleCatCyclesIso_inv_π :
    S.moduleCatCyclesIso.inv ≫ S.homologyπ =
       S.moduleCatHomologyπ ≫ S.moduleCatHomologyIso.inv
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem self_trans_symm (e : α ≃o β) : e.trans e.symm = OrderIso.refl α
-- Mathlib/Algebra/Order/Nonneg/Field.lean
lemma NNRat.cast_nonneg (q : ℚ≥0) : 0 ≤ (q : α)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem Filter.Tendsto.edist {f g : β → α} {x : Filter β} {a b : α} (hf : Tendsto f x (𝓝 a))
    (hg : Tendsto g x (𝓝 b)) : Tendsto (fun x => edist (f x) (g x)) x (𝓝 (edist a b))
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
@[simp]
theorem mk_π_app_left {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) :
    (mk fst snd eq).π.app WalkingCospan.left = fst
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem le_nfpBFamily {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) (a) :
    a ≤ nfpBFamily.{u, v} o f a
-- Mathlib/Data/Complex/Exponential.lean
theorem tan_mul_I : tan (x * I) = tanh x * I
-- Mathlib/Topology/ContinuousOn.lean
theorem isOpenMap_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} :
    IsOpenMap f ↔ ∀ b, IsOpenMap (f ⟨·, b⟩)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem ofEquiv_aequiv {U : Type*} [CommRing U] [Algebra R U] (h : IsAdjoinRoot S f)
    (h' : IsAdjoinRoot U f) (e : S ≃ₐ[R] T) :
    (h.ofEquiv e).aequiv h' = e.symm.trans (h.aequiv h')
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Ioi : c ∉ Ioi a ↔ c ≤ a
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem preimage_Ioo {a b : α} (ha : 0 ≤ a) :
    (Nat.cast : ℕ → α) ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋₊ ⌈b⌉₊
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem gcd_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ∣ g b) : s.gcd f ∣ s.gcd g
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
/-- `gramSchmidt` produces linearly independent vectors when given linearly independent vectors. -/
theorem gramSchmidt_linearIndependent {f : ι → E} (h₀ : LinearIndependent 𝕜 f) :
    LinearIndependent 𝕜 (gramSchmidt 𝕜 f)
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- In a seminormed ring, the left-multiplication `AddMonoidHom` is bounded. -/
theorem mulLeft_bound (x : α) : ∀ y : α, ‖AddMonoidHom.mulLeft x y‖ ≤ ‖x‖ * ‖y‖
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma appLE_eq_app {U : Y.Opens} :
    f.appLE U (f ⁻¹ᵁ U) le_rfl = f.app U
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
/-- This is often the more useful lemma to rewrite the norm as opposed to `Unitization.norm_def`. -/
theorem norm_eq_sup (x : Unitization 𝕜 A) :
    ‖x‖ = ‖x.fst‖ ⊔ ‖algebraMap 𝕜 (A →L[𝕜] A) x.fst + mul 𝕜 A x.snd‖
-- Mathlib/Probability/Independence/Basic.lean
theorem indep_iSup_of_disjoint [IsProbabilityMeasure μ]
    (h_le : ∀ i, m i ≤ _mΩ) (h_indep : iIndep m μ) {S T : Set ι} (hST : Disjoint S T) :
    Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) μ
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem bsup_eq_sup' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → Ordinal.{max u v}) :
    bsup.{_, v} _ (bfamilyOfFamily' r f) = sup.{_, v} f
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma truncatedInf_of_isAntichain (hs : IsAntichain (· ≤ ·) (s : Set α)) (ha : a ∈ s) :
    truncatedInf s a = a
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem inv_empty : (∅ : Set α)⁻¹ = ∅
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The symbol `J(a | b)` takes the value `1` or `-1` if `a` and `b` are coprime. -/
theorem eq_one_or_neg_one {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) = 1 ∨ J(a | b) = -1
-- Mathlib/Order/Hom/Set.lean
@[simp]
theorem symm_preimage_preimage (e : α ≃o β) (s : Set β) : e.symm ⁻¹' (e ⁻¹' s) = s
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecting ↔ s ≠ {⊥}
-- Mathlib/CategoryTheory/IsConnected.lean
/-- If any functor to a discrete category is constant on objects, J is connected.
The converse of `any_functor_const_on_obj`.
-/
theorem IsConnected.of_any_functor_const_on_obj [Nonempty J]
    (h : ∀ {α : Type u₁} (F : J ⥤ Discrete α), ∀ j j' : J, F.obj j = F.obj j') : IsConnected J
-- Mathlib/Order/SymmDiff.lean
theorem sdiff_symmDiff : c \ a ∆ b = c ⊓ a ⊓ b ⊔ c \ a ⊓ c \ b
-- Mathlib/Topology/Order/OrderClosed.lean
@[deprecated isClosed_Iic (since := "2024-02-15")]
lemma ClosedIicTopology.isClosed_le' (a : α) : IsClosed {x | x ≤ a}
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
lemma inv_inter (s t : Finset α) : (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.mulVecLin_zero [Fintype n] : Matrix.mulVecLin (0 : Matrix m n R) = 0
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
theorem kernel_not_epi_of_nonzero (w : f ≠ 0) : ¬Epi (kernel.ι f)
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
protected theorem hasMFDerivAt {x} : HasMFDerivAt I 𝓘(𝕜, E) I x (ContinuousLinearMap.id _ _)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Cauchy.ultrafilter_of {l : Filter α} (h : Cauchy l) :
    Cauchy (@Ultrafilter.of _ l h.1 : Filter α)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_self (a : α) : Ioo a a = ∅
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
@[simp]
theorem foldl_ι (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (m : M) : foldl Q f hf n (ι Q m) = f m n
-- Mathlib/Topology/Maps/Basic.lean
protected theorem comp (hg : OpenEmbedding g)
    (hf : OpenEmbedding f) : OpenEmbedding (g ∘ f)
-- Mathlib/Data/ZMod/Basic.lean
theorem val_eq_ite_valMinAbs {n : ℕ} [NeZero n] (a : ZMod n) :
    (a.val : ℤ) = a.valMinAbs + if a.val ≤ n / 2 then 0 else n
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast]
theorem coe_inv (x : s) : (↑x⁻¹ : K) = (↑x)⁻¹
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem dot_smul_left (xs ys : IntList) (i : Int) : (i * xs).dot ys = i * xs.dot ys
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem prod_normalizedFactors_eq_self (hI : I ≠ ⊥) : (normalizedFactors I).prod = I
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem deleteEdges_adj (v w : V) : (G'.deleteEdges s).Adj v w ↔ G'.Adj v w ∧ ¬s(v, w) ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem mod_def' (m n : Int) : m % n = emod m n
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem ideal_span_singleton_smul (r : R) (N : Submodule R M) :
    (Ideal.span {r} : Ideal R) • N = r • N
-- Mathlib/CategoryTheory/Sigma/Basic.lean
@[simp]
lemma inclDesc_hom_app (i : I) (X : C i) : (inclDesc F i).hom.app X = 𝟙 ((F i).obj X)
-- Mathlib/Data/Set/Basic.lean
theorem union_inter_distrib_left (s t u : Set α) : s ∪ t ∩ u = (s ∪ t) ∩ (s ∪ u)
-- Mathlib/Order/Iterate.lean
/-- If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`. -/
theorem iterate_le_of_le {g : α → α} (hf : Monotone f) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n]
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
@[simp, mfld_simps]
theorem coe_achart (x : M) : (achart H x : PartialHomeomorph M H) = chartAt H x
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem map_mk {f : S' ⟶ T.obj Y} (g : S ⟶ S') : (map g).obj (mk f) = mk (g ≫ f)
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
/-- `OuterMeasure.trim` is antitone in the σ-algebra. -/
theorem trim_anti_measurableSpace (m : OuterMeasure α) {m0 m1 : MeasurableSpace α}
    (h : m0 ≤ m1) : @trim _ m1 m ≤ @trim _ m0 m
-- Mathlib/Data/Fin/Basic.lean
lemma size_positive' [Nonempty (Fin n)] : 0 < n
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
theorem inTangentCoordinates_eq (f : N → M) (g : N → M') (ϕ : N → E →L[𝕜] E') {x₀ x : N}
    (hx : f x ∈ (chartAt H (f x₀)).source) (hy : g x ∈ (chartAt H' (g x₀)).source) :
    inTangentCoordinates I I' f g ϕ x₀ x =
      (tangentBundleCore I' M').coordChange (achart H' (g x)) (achart H' (g x₀)) (g x) ∘L
        ϕ x ∘L (tangentBundleCore I M).coordChange (achart H (f x₀)) (achart H (f x)) (f x)
-- Mathlib/Data/Set/Basic.lean
theorem nonempty_compl : sᶜ.Nonempty ↔ s ≠ univ
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_zsmul [AddGroup α] [StarAddMonoid α] (c : ℤ) (M : Matrix m n α) :
    (c • M)ᴴ = c • Mᴴ
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousWithinAt_fst {s : Set (α × β)} {p : α × β} : ContinuousWithinAt Prod.fst s p
-- Mathlib/Topology/Instances/ENNReal.lean
@[simp]
theorem tendsto_ofReal_nhds_top {f : α → ℝ} {l : Filter α} :
    Tendsto (fun x ↦ ENNReal.ofReal (f x)) l (𝓝 ∞) ↔ Tendsto f l atTop
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma ceilDiv_def (f : ι →₀ β) (a : α) : f ⌈/⌉ a = f.mapRange (· ⌈/⌉ a) (zero_ceilDiv _)
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
/-- The Fourier integral of the Fréchet derivative of a function is obtained by multiplying the
Fourier integral of the original function by `2πI ⟪v, w⟫`. -/
theorem fourierIntegral_fderiv
    (hf : Integrable f) (h'f : Differentiable ℝ f) (hf' : Integrable (fderiv ℝ f)) :
    𝓕 (fderiv ℝ f) = fourierSMulRight (-innerSL ℝ) (𝓕 f)
-- Mathlib/RingTheory/Ideal/Quotient.lean
theorem mk_surjective : Function.Surjective (mk I)
-- Mathlib/CategoryTheory/Simple.lean
theorem Simple.of_iso {X Y : C} [Simple Y] (i : X ≅ Y) : Simple X
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem le_vanishingIdeal_zeroLocus (I : Ideal (MvPolynomial σ k)) :
    I ≤ vanishingIdeal (zeroLocus I)
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_castSucc_of_lt (p i : Fin n) (h : p < i) (hi := castSucc_ne_zero_of_lt h) :
    p.predAbove (castSucc i) = i.castSucc.pred hi
-- Mathlib/RingTheory/QuotSMulTop.lean
@[simp]
lemma map_apply_mk (f : M →ₗ[R] M') (x : M) :
    map r f (Submodule.Quotient.mk x) =
      (Submodule.Quotient.mk (f x) : QuotSMulTop r M')
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem dlookup_kerase (a) {l : List (Sigma β)} (nd : l.NodupKeys) :
    dlookup a (kerase a l) = none
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem ite_eq_false_distrib (p : Prop) [h : Decidable p] (t f : Bool) :
    (ite p t f = false) = ite p (t = false) (f = false)
-- Mathlib/Analysis/Complex/PhragmenLindelof.lean
/-- **Phragmen-Lindelöf principle** in the second quadrant. Let `f : ℂ → E` be a function such that

* `f` is differentiable in the open second quadrant and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * (abs z) ^ c)` on the open second quadrant
  for some `A`, `B`, and `c < 2`;
* `f` is equal to zero on the boundary of the second quadrant.

Then `f` is equal to zero on the closed second quadrant. -/
theorem eq_zero_on_quadrant_II (hd : DiffContOnCl ℂ f (Iio 0 ×ℂ Ioi 0))
    (hB : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 (Iio 0 ×ℂ Ioi 0)] fun z => expR (B * abs z ^ c))
    (hre : ∀ x : ℝ, x ≤ 0 → f x = 0) (him : ∀ x : ℝ, 0 ≤ x → f (x * I) = 0) :
    EqOn f 0 {z | z.re ≤ 0 ∧ 0 ≤ z.im}
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl) Prove that the lifted cocone is colimiting. -/
@[simps]
def liftedCoconeIsColimit : IsColimit (liftedCocone c t)
-- Mathlib/Data/Fin/Basic.lean
theorem cast_rev (i : Fin n) (h : n = m) :
    cast h i.rev = (i.cast h).rev
-- Mathlib/Topology/Instances/NNReal.lean
@[simp]
theorem _root_.Real.map_toNNReal_atTop : map Real.toNNReal atTop = atTop
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
/-- If `m u = ∞` for any set `u` that has nonempty intersection both with `s` and `t`, then
`μ (s ∪ t) = μ s + μ t`, where `μ = MeasureTheory.OuterMeasure.ofFunction m m_empty`.

E.g., if `α` is an (e)metric space and `m u = ∞` on any set of diameter `≥ r`, then this lemma
implies that `μ (s ∪ t) = μ s + μ t` on any two sets such that `r ≤ edist x y` for all `x ∈ s`
and `y ∈ t`.  -/
theorem ofFunction_union_of_top_of_nonempty_inter {s t : Set α}
    (h : ∀ u, (s ∩ u).Nonempty → (t ∩ u).Nonempty → m u = ∞) :
    OuterMeasure.ofFunction m m_empty (s ∪ t) =
      OuterMeasure.ofFunction m m_empty s + OuterMeasure.ofFunction m m_empty t
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp]
theorem fderivCLM_apply (f : 𝓢(E, F)) (x : E) : fderivCLM 𝕜 f x = fderiv ℝ f x
-- Mathlib/GroupTheory/MonoidLocalization/MonoidWithZero.lean
theorem mk_zero (x : S) : mk 0 (x : S) = 0
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem fst_sumFinsuppLEquivProdFinsupp {α β : Type*} (f : α ⊕ β →₀ M) (x : α) :
    (sumFinsuppLEquivProdFinsupp R f).1 x = f (Sum.inl x)
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
theorem χ₈'_int_eq_χ₄_mul_χ₈ (a : ℤ) : χ₈' a = χ₄ a * χ₈ a
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp, nolint simpNF]
theorem lift_umax_eq {a : Cardinal.{u}} {b : Cardinal.{v}} :
    lift.{max v w} a = lift.{max u w} b ↔ lift.{v} a = lift.{u} b
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem sq_add_sq_ne_zero {R : Type*} [LinearOrderedCommRing R] {a b : R} (h : IsCoprime a b) :
    a ^ 2 + b ^ 2 ≠ 0
-- Mathlib/Data/Finset/MulAntidiagonal.lean
@[to_additive]
theorem mulAntidiagonal_mono_right (h : u ⊆ t) :
    mulAntidiagonal hs hu a ⊆ mulAntidiagonal hs ht a
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addZ_ne_zero_of_X_ne {P Q : Fin 3 → R} (hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2) : addZ P Q ≠ 0
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_withDensity_iff_integrable_smul₀ {f : α → ℝ≥0} (hf : AEMeasurable f μ)
    {g : α → E} : Integrable g (μ.withDensity fun x => f x) ↔ Integrable (fun x => f x • g x) μ
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The bundled derivative of a `C^{n+1}` function is `C^n`. -/
theorem ContDiff.contDiff_fderiv_apply {f : E → F} (hf : ContDiff 𝕜 n f) (hmn : m + 1 ≤ n) :
    ContDiff 𝕜 m fun p : E × E => (fderiv 𝕜 f p.1 : E →L[𝕜] F) p.2
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem distortion_le_iff {c : ℝ≥0} : π.distortion ≤ c ↔ ∀ J ∈ π, Box.distortion J ≤ c
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma nilRank_le_card (b : Basis ι R M) : nilRank φ ≤ Fintype.card ι
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiff_prod_iff (f : M → M' × N') :
    ContMDiff I (I'.prod J') n f ↔
      ContMDiff I I' n (Prod.fst ∘ f) ∧ ContMDiff I J' n (Prod.snd ∘ f)
-- Mathlib/Order/Partition/Finpartition.lean
/-- Changes the type of a finpartition to an equal one. -/
@[simps]
def copy {a b : α} (P : Finpartition a) (h : a = b) : Finpartition b
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
theorem trans_toLinearEquiv :
    (e₁₂.trans e₂₃ : A ≃ₗ[R] C) = (e₁₂ : A ≃ₗ[R] B) ≪≫ₗ e₂₃
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
/-- The uniform bound we have given is summable, and remains so after multiplying by any fixed
power of `|n|` (we shall need this for `k = 0, 1, 2`). -/
lemma summable_pow_mul_jacobiTheta₂_term_bound (S : ℝ) {T : ℝ} (hT : 0 < T) (k : ℕ) :
    Summable (fun n : ℤ ↦ (|n| ^ k : ℝ) * Real.exp (-π * (T * n ^ 2 - 2 * S * |n|)))
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem nil_eq_rotate_iff {l : List α} {n : ℕ} : [] = l.rotate n ↔ [] = l
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[simp]
theorem id_apply (x : A) : DistribMulActionHom.id M x = x
-- Mathlib/Analysis/SumIntegralComparisons.lean
theorem AntitoneOn.integral_le_sum_Ico (hab : a ≤ b) (hf : AntitoneOn f (Set.Icc a b)) :
    (∫ x in a..b, f x) ≤ ∑ x ∈ Finset.Ico a b, f x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem disjoint_nil_right (l : List α) : Disjoint l []
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
protected theorem IsBoundedBilinearMap.isBigO' (h : IsBoundedBilinearMap 𝕜 f) :
    f =O[⊤] fun p : E × F => ‖p‖ * ‖p‖
-- Mathlib/RingTheory/Ideal/Maps.lean
/-- The pushforward `Ideal.map` as a monoid-with-zero homomorphism. -/
@[simps]
def mapHom : Ideal R →*₀ Ideal S
-- Mathlib/Algebra/BigOperators/Group/List.lean
lemma unop_list_prod (l : List Mᵐᵒᵖ) : l.prod.unop = (l.map unop).reverse.prod
-- Mathlib/Order/Hom/Set.lean
@[simp]
theorem preimage_image (e : α ≃o β) (s : Set α) : e ⁻¹' (e '' s) = s
-- Mathlib/Data/Finset/Basic.lean
theorem choose_spec (hp : ∃! a, a ∈ l ∧ p a) : choose p l hp ∈ l ∧ p (choose p l hp)
-- Mathlib/Data/Matroid/Map.lean
lemma mapEquiv_eq_map (f : α ≃ β) : M.mapEquiv f = M.map f f.injective.injOn
-- Mathlib/Order/Filter/NAry.lean
theorem map₂_comm {n : β → α → γ} (h_comm : ∀ a b, m a b = n b a) : map₂ m f g = map₂ n g f
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem map_iInf {ι β} {f : α → β} (hf : Injective f) (m : ι → OuterMeasure α) :
    map f (⨅ i, m i) = restrict (range f) (⨅ i, map f (m i))
-- Mathlib/Geometry/Manifold/VectorBundle/FiberwiseLinear.lean
/-- Compute the composition of two partial homeomorphisms induced by fiberwise linear
equivalences. -/
theorem trans_partialHomeomorph_apply (hU : IsOpen U)
    (hφ : ContinuousOn (fun x => φ x : B → F →L[𝕜] F) U)
    (h2φ : ContinuousOn (fun x => (φ x).symm : B → F →L[𝕜] F) U) (hU' : IsOpen U')
    (hφ' : ContinuousOn (fun x => φ' x : B → F →L[𝕜] F) U')
    (h2φ' : ContinuousOn (fun x => (φ' x).symm : B → F →L[𝕜] F) U') (b : B) (v : F) :
    (FiberwiseLinear.partialHomeomorph φ hU hφ h2φ ≫ₕ
      FiberwiseLinear.partialHomeomorph φ' hU' hφ' h2φ')
        ⟨b, v⟩ =
      ⟨b, φ' b (φ b v)⟩
-- Mathlib/Data/Subtype.lean
theorem mk_eq_mk {a h a' h'} : @mk α p a h = @mk α p a' h' ↔ a = a'
-- Mathlib/Data/Nat/Cast/Basic.lean
@[to_additive existing (attr := simp)]
lemma powersHom_apply (x : α) (n : Multiplicative ℕ) :
    powersHom α x n = x ^ Multiplicative.toAdd n
-- Mathlib/Data/TypeVec.lean
theorem nilFun_comp {α₀ : TypeVec 0} (f₀ : α₀ ⟹ Fin2.elim0) : nilFun ⊚ f₀ = f₀
-- .lake/packages/lean4/src/lean/Init/Data/Nat/MinMax.lean
protected theorem le_min {a b c : Nat} : a ≤ min b c ↔ a ≤ b ∧ a ≤ c
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem length_coe (l : List α) : length (l : Cycle α) = l.length