ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
/-- The `n+1`-th iterated derivative can be obtained by differentiating the `n`-th
iterated derivative. -/
theorem iteratedDeriv_succ : iteratedDeriv (n + 1) f = deriv (iteratedDeriv n f)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem ofReal_integral_norm_eq_lintegral_nnnorm {P : Type*} [NormedAddCommGroup P] {f : α → P}
    (hf : Integrable f μ) : ENNReal.ofReal (∫ x, ‖f x‖ ∂μ) = ∫⁻ x, ‖f x‖₊ ∂μ
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem smul_mem_pointwise_smul (m : M) (a : α) (S : Submonoid M) : m ∈ S → a • m ∈ a • S
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_eq_self (h : s ⊆ t) : μ.restrict t s = μ s
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
theorem prod_Ico_add [OrderedCancelAddCommMonoid α] [ExistsAddOfLE α] [LocallyFiniteOrder α]
    (f : α → M) (a b c : α) : (∏ x ∈ Ico a b, f (c + x)) = ∏ x ∈ Ico (a + c) (b + c), f x
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.triangle (h₁ : (fun x => f₁ x - f₂ x) =o[l] g)
    (h₂ : (fun x => f₂ x - f₃ x) =o[l] g) : (fun x => f₁ x - f₃ x) =o[l] g
-- Mathlib/Topology/VectorBundle/Basic.lean
/-- The projection on the base of a vector bundle created from core is continuous -/
@[continuity]
theorem continuous_proj : Continuous Z.proj
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma rnDeriv_ne_top (μ ν : Measure α) [SigmaFinite μ] : ∀ᵐ x ∂ν, μ.rnDeriv ν x ≠ ∞
-- Mathlib/Topology/Order/Basic.lean
/-- For a function taking values in a second countable space, the set of points `x` for
which the image under `f` of `(-∞, x)` is separated above from `f x` is countable. -/
theorem countable_image_lt_image_Iio [OrderTopology α] [LinearOrder β] (f : β → α)
    [SecondCountableTopology α] : Set.Countable {x | ∃ z, f x < z ∧ ∀ y, y < x → z ≤ f y}
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_two_inv : round (2⁻¹ : α) = 1
-- Mathlib/Logic/Basic.lean
lemma forall_or_exists_not (P : α → Prop) : (∀ a, P a) ∨ ∃ a, ¬ P a
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive]
theorem oreDiv_mul_oreDiv_comm {r₁ r₂ : R} {s₁ s₂ : S} :
    r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r₂ /ₒ (s₁ * s₂)
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.affineCombination_of_mem_affineSpan_pair [NoZeroDivisors R] [NoZeroSMulDivisors R V]
    {ι : Type*} {p : ι → P} (ha : AffineIndependent R p) {w w₁ w₂ : ι → R} {s : Finset ι}
    (hw : ∑ i ∈ s, w i = 1) (hw₁ : ∑ i ∈ s, w₁ i = 1) (hw₂ : ∑ i ∈ s, w₂ i = 1)
    (h : s.affineCombination R p w ∈
      line[R, s.affineCombination R p w₁, s.affineCombination R p w₂])
    {i : ι} (his : i ∈ s) (hs : Sbtw R (w₁ i) (w i) (w₂ i)) :
    Sbtw R (s.affineCombination R p w₁) (s.affineCombination R p w)
      (s.affineCombination R p w₂)
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem mem_list_cycles_iff {α : Type*} [Finite α] {l : List (Perm α)}
    (h1 : ∀ σ : Perm α, σ ∈ l → σ.IsCycle) (h2 : l.Pairwise Disjoint) {σ : Perm α} :
    σ ∈ l ↔ σ.IsCycle ∧ ∀ a, σ a ≠ a → σ a = l.prod a
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem _root_.Set.infinite_iff_exists_lt [Nonempty α] : s.Infinite ↔ ∀ a, ∃ b ∈ s, b < a
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem BilinearForm.toMatrixAux_eq (B : BilinForm R₂ M₂) :
    BilinForm.toMatrixAux (R₂ := R₂) b B = BilinForm.toMatrix b B
-- Mathlib/Dynamics/OmegaLimit.lean
theorem isInvariant_omegaLimit (hf : ∀ t, Tendsto (t + ·) f f) : IsInvariant ϕ (ω f ϕ s)
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem opProductIsoCoproduct'_comp_self {f f' : Fan Z} {c : Cofan (op <| Z ·)}
    (hf : IsLimit f) (hf' : IsLimit f') (hc : IsColimit c) :
    (opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv =
    (hf.conePointUniqueUpToIso hf').op.inv
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem FamilyOfElements.IsAmalgamation.compPresheafMap {x : FamilyOfElements P R} {t} (f : P ⟶ Q)
    (h : x.IsAmalgamation t) : (x.compPresheafMap f).IsAmalgamation (f.app (op X) t)
-- Mathlib/GroupTheory/Commutator.lean
theorem map_commutator (f : G →* G') : map f ⁅H₁, H₂⁆ = ⁅map f H₁, map f H₂⁆
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem toList_formPerm_nontrivial (l : List α) (hl : 2 ≤ l.length) (hn : Nodup l) :
    toList (formPerm l) (l.get ⟨0, (zero_lt_two.trans_le hl)⟩) = l
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isVonNBounded_of_isBounded {s : Set E} (h : Bornology.IsBounded s) :
    Bornology.IsVonNBounded 𝕜 s
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
/-- The Lax functor associated with a pseudofunctor. -/
@[simps]
def toLax : LaxFunctor B C
-- Mathlib/Algebra/Homology/Homotopy.lean
/-- Tautological construction of the `Homotopy` to zero for maps constructed by
`nullHomotopicMap`, at least when we have the `zero` condition. -/
@[simps]
def nullHomotopy (hom : ∀ i j, C.X i ⟶ D.X j) (zero : ∀ i j, ¬c.Rel j i → hom i j = 0) :
    Homotopy (nullHomotopicMap hom) 0
-- Mathlib/Data/List/Rotate.lean
theorem head?_rotate {l : List α} {n : ℕ} (h : n < l.length) : head? (l.rotate n) = l[n]?
-- Mathlib/Data/Matroid/Basic.lean
@[simp] theorem not_dep_iff (hX : X ⊆ M.E := by aesop_mat) : ¬ M.Dep X ↔ M.Indep X
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma succAbove_castSucc_self (j : Fin n) : succAbove j.castSucc j = j.succ
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodySum_compact : IsCompact (convexBodySum K B)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_toContinuousLinearMap : ⇑f.toContinuousLinearMap = f
-- Mathlib/Data/Nat/Factors.lean
/-- `primeFactorsList` can be constructed inductively by extracting `minFac`, for sufficiently
large `n`. -/
theorem primeFactorsList_add_two (n : ℕ) :
    primeFactorsList (n + 2) = minFac (n + 2) :: primeFactorsList ((n + 2) / minFac (n + 2))
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem bind₂_map (f : S →+* MvPolynomial σ T) (g : R →+* S) (φ : MvPolynomial σ R) :
    bind₂ f (map g φ) = bind₂ (f.comp g) φ
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem mem_mk {s : Set G} {x : G} (h_one) (h_mul) (h_inv) :
    x ∈ mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv ↔ x ∈ s
-- Mathlib/Order/RelSeries.lean
@[simp] lemma last_append (p q : RelSeries r) (connect : r p.last q.head) :
    (p.append q connect).last = q.last
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem constantCoeff_zero : constantCoeff σ R 0 = 0
-- Mathlib/Order/Interval/Set/OrdConnected.lean
@[instance]
theorem dual_ordConnected {s : Set α} [OrdConnected s] : OrdConnected (ofDual ⁻¹' s)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mem_powerset : ∀ {x y : PSet}, y ∈ powerset x ↔ y ⊆ x
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem mem_closure {a : G} : a ∈ s → a ∈ closure s
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
@[simp]
theorem coe_matrix_coe (g : SpecialLinearGroup n ℤ) :
    ↑(g : SpecialLinearGroup n R) = (↑g : Matrix n n ℤ).map (Int.castRingHom R)
-- Mathlib/SetTheory/Surreal/Multiplication.lean
/-- P2 follows from specialized induction hypotheses (one half of the equality). -/
theorem mul_right_le_of_equiv (h₁ : x₁.Numeric) (h₂ : x₂.Numeric)
    (h₁₂ : IH24 x₁ x₂ y) (h₂₁ : IH24 x₂ x₁ y) (he : x₁ ≈ x₂) : x₁ * y ≤ x₂ * y
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem edist_pi_def [∀ b, EDist (π b)] (f g : ∀ b, π b) :
    edist f g = Finset.sup univ fun b => edist (f b) (g b)
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
theorem compRight_apply (f : M₂ →ₗ[R] M₃) (g : M →ₗ[R] M₂) : compRight f g = f.comp g
-- Mathlib/Algebra/Group/Hom/Basic.lean
@[to_additive (attr := simp)]
theorem comp_inv (φ : G →* H) (ψ : M →* G) : φ.comp ψ⁻¹ = (φ.comp ψ)⁻¹
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem Nonempty.of_mul_left : (s * t).Nonempty → s.Nonempty
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem subset_lieSpan : s ⊆ lieSpan R L s
-- Mathlib/GroupTheory/Coset.lean
@[to_additive mem_leftAddCoset_leftAddCoset]
theorem mem_leftCoset_leftCoset {a : α} (ha : a • (s : Set α) = s) : a ∈ s
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
nonrec theorem UniqueMDiffWithinAt.mono_nhds {s t : Set M} {x : M} (hs : UniqueMDiffWithinAt I s x)
    (ht : 𝓝[s] x ≤ 𝓝[t] x) : UniqueMDiffWithinAt I t x
-- Mathlib/Data/Matroid/Closure.lean
lemma closure_def' (M : Matroid α) (X : Set α) (hX : X ⊆ M.E := by aesop_mat) :
    M.closure X = ⋂₀ {F | M.Flat F ∧ X ⊆ F}
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem aestronglyMeasurable_uIoc_iff [LinearOrder α] [PseudoMetrizableSpace β] {f : α → β}
    {a b : α} :
    AEStronglyMeasurable f (μ.restrict <| uIoc a b) ↔
      AEStronglyMeasurable f (μ.restrict <| Ioc a b) ∧
        AEStronglyMeasurable f (μ.restrict <| Ioc b a)
-- Mathlib/Algebra/Group/ULift.lean
@[to_additive (attr := simp)]
theorem one_down [One α] : (1 : ULift α).down = 1
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropAt_iff_comp_inclusion (hG : LocalInvariantProp G G' P) {U V : Opens M} (hUV : U ≤ V)
    (f : V → M') (x : U) :
    LiftPropAt P f (Set.inclusion hUV x) ↔ LiftPropAt P (f ∘ Set.inclusion hUV : U → M') x
-- Mathlib/Topology/Separation.lean
/-- For point `x` in a discrete subset `s` of a topological space, there is a set `U`
such that
1. `U` is a punctured neighborhood of `x` (ie. `U ∪ {x}` is a neighbourhood of `x`),
2. `U` is disjoint from `s`.
-/
theorem disjoint_nhdsWithin_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X} (hx : x ∈ s) :
    ∃ U ∈ 𝓝[≠] x, Disjoint U s
-- Mathlib/Order/UpperLower/Basic.lean
theorem isUpperSet_iff_Ioi_subset : IsUpperSet s ↔ ∀ ⦃a⦄, a ∈ s → Ioi a ⊆ s
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_subtype {p : α → Prop} [UniformSpace α] :
    𝓤 (Subtype p) = comap (fun q : Subtype p × Subtype p => (q.1.1, q.2.1)) (𝓤 α)
-- Mathlib/SetTheory/Game/PGame.lean
theorem moveRight_neg_symm' {x : PGame} (i) :
    x.moveRight i = -(-x).moveLeft (toLeftMovesNeg i)
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem continuum_mul_self : 𝔠 * 𝔠 = 𝔠
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem findIdx?_append :
    (xs ++ ys : List α).findIdx? p =
      (xs.findIdx? p <|> (ys.findIdx? p).map fun i => i + xs.length)
-- Mathlib/Order/GameAdd.lean
@[simp]
theorem gameAdd_swap_swap : ∀ a b : α × β, GameAdd rβ rα a.swap b.swap ↔ GameAdd rα rβ a b
-- Mathlib/Order/CompleteLattice.lean
theorem IsGLB.iInf_eq (h : IsGLB (range f) a) : ⨅ j, f j = a
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
theorem comap_pure {m : α → β} (a : α) (inj : Injective m) (large) :
    comap (pure <| m a) inj large = pure a
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem symm_trans_self (e : r ≃r s) : e.symm.trans e = RelIso.refl s
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- The projection into `U` from an orthogonal submodule `V` is the zero map. -/
theorem Submodule.IsOrtho.orthogonalProjection_comp_subtypeL {U V : Submodule 𝕜 E}
    [HasOrthogonalProjection U] (h : U ⟂ V) : orthogonalProjection U ∘L V.subtypeL = 0
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
/-- Induct using `tprodCoeff` -/
@[elab_as_elim]
protected theorem induction_on' {motive : (⨂[R] i, s i) → Prop} (z : ⨂[R] i, s i)
    (tprodCoeff : ∀ (r : R) (f : Π i, s i), motive (tprodCoeff R r f))
    (add : ∀ x y, motive x → motive y → motive (x + y)) :
    motive z
-- Mathlib/Data/Finset/Prod.lean
theorem subset_product_image_snd [DecidableEq β] : (s ×ˢ t).image Prod.snd ⊆ t
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasStrictFDerivAt_cpow' {x y : ℂ} (hp : x ∈ slitPlane) :
    HasStrictFDerivAt (fun x : ℂ × ℂ => x.1 ^ x.2)
      ((y * x ^ (y - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ +
        (x ^ y * log x) • ContinuousLinearMap.snd ℂ ℂ ℂ) (x, y)
-- .lake/packages/batteries/Batteries/Data/Array/Match.lean
/-- Prefix table for the Knuth-Morris-Pratt matching algorithm

  This is an array of the form `t = [(x₀,n₀), (x₁,n₁), (x₂, n₂), ...]` where for each `i`, `nᵢ` is
  the length of the longest proper prefix of `xs = [x₀,x₁,...,xᵢ]` which is also a suffix of `xs`.
-/
structure PrefixTable (α : Type _) extends Array (α × Nat) where
  /-- Validity condition to help with termination proofs -/
  valid : (h : i < toArray.size) → toArray[i].2 ≤ i
-- Mathlib/Order/BoundedOrder.lean
theorem antitone_lt {x : α} : Antitone (· < x)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem deriv_add_const (c : F) : deriv (fun y => f y + c) x = deriv f x
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem union_insert : s ∪ insert a t = insert a (s ∪ t)
-- Mathlib/Data/Complex/Module.lean
lemma star_mul_self_add_self_mul_star {A : Type*} [NonUnitalRing A] [StarRing A]
    [Module ℂ A] [IsScalarTower ℂ A A] [SMulCommClass ℂ A A] [StarModule ℂ A] (a : A) :
    star a * a + a * star a = 2 • (ℜ a * ℜ a + ℑ a * ℑ a)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem IsInfix.eq_of_length (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
protected theorem MonoidHom.map_zpow' [DivInvMonoid M] [DivInvMonoid N] (f : M →* N)
    (hf : ∀ x, f x⁻¹ = (f x)⁻¹) (a : M) (n : ℤ) :
    f (a ^ n) = f a ^ n
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem exists_fin_one {p : Fin 1 → Prop} : (∃ i, p i) ↔ p 0
-- Mathlib/Data/Real/Pi/Wallis.lean
theorem W_succ (k : ℕ) :
    W (k + 1) = W k * ((2 * k + 2) / (2 * k + 1) * ((2 * k + 2) / (2 * k + 3)))
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem mod_opow_log_lt_self (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : o % (b ^ log b o) < o
-- Mathlib/Data/Fin/Basic.lean
lemma nonempty_embedding_iff : Nonempty (Fin n ↪ Fin m) ↔ n ≤ m
-- Mathlib/Topology/MetricSpace/Bounded.lean
@[simp]
theorem diam_univ_of_noncompact [ProperSpace α] [NoncompactSpace α] : diam (univ : Set α) = 0
-- Mathlib/LinearAlgebra/Span.lean
theorem span_iUnion {ι} (s : ι → Set M) : span R (⋃ i, s i) = ⨆ i, span R (s i)
-- Mathlib/Init/Logic.lean
theorem false_or_iff : False ∨ p ↔ p
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma nonsingular_smul (P : Fin 3 → R) {u : R} (hu : IsUnit u) :
    W'.Nonsingular (u • P) ↔ W'.Nonsingular P
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem Step.cons_not_rev {x b} : Red.Step ((x, !b) :: (x, b) :: L) L
-- Mathlib/CategoryTheory/GradedObject/Single.lean
lemma single_map_singleObjApplyIsoOfEq_hom (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j) :
    (single j).map f i ≫ (singleObjApplyIsoOfEq j Y i h).hom =
      (singleObjApplyIsoOfEq j X i h).hom ≫ f
-- Mathlib/Algebra/Order/CompleteField.lean
theorem cutMap_mono (h : a₁ ≤ a₂) : cutMap β a₁ ⊆ cutMap β a₂
-- Mathlib/Data/QPF/Multivariate/Constructions/Comp.lean
theorem get_map (x : Comp F G α) :
    Comp.get (f <$$> x) = (fun i (x : G i α) ↦ f <$$> x) <$$> Comp.get x
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1S_neg {T : Set α → E →L[ℝ] F} (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) (f : α →₁ₛ[μ] E) : setToL1S T (-f) = -setToL1S T f
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem continuous_div_const (c : ℝ≥0∞) (c_ne_zero : c ≠ 0) :
    Continuous fun x : ℝ≥0∞ => x / c
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem of_sub_of [Sub α] (f g : m → n → α) : of f - of g = of (f - g)
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem succ_zero_eq_one' [NeZero n] : Fin.succ (0 : Fin n) = 1
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
@[simp]
theorem nndist_vadd_left (v : V) (x : P) : nndist (v +ᵥ x) x = ‖v‖₊
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem AdjoinSimple.coe_gen : (AdjoinSimple.gen F α : E) = α
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@[simp, mfld_simps]
theorem tangentBundleModelSpaceHomeomorph_coe_symm :
    ((tangentBundleModelSpaceHomeomorph H I).symm : ModelProd H E → TangentBundle I H) =
      (TotalSpace.toProd H E).symm
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_sdiff (a b c : α) : (a \ b) \ c = a \ (b ⊔ c)
-- Mathlib/Dynamics/PeriodicPts.lean
theorem trans_dvd (hm : IsPeriodicPt f m x) {n : ℕ} (hn : m ∣ n) : IsPeriodicPt f n x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arccos_eq_arcsin {x : ℝ} (h : 0 ≤ x) : arccos x = arcsin (√(1 - x ^ 2))
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_apply : cfc f a = cfcHom (a := a) ha ⟨_, hf.restrict⟩
-- Mathlib/Data/TypeVec.lean
theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ' : Type u}
    {f₀ : α ⟹ α'} {g₀ : β ⟹ β'} {f₁ : φ → φ'} {g₁ : ψ → ψ'} :
    ((f₀ ⊗' g₀) ::: (_root_.Prod.map f₁ g₁)) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁))
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure `C` of `A` in `L` is
Noetherian over `A`. -/
theorem IsIntegralClosure.isNoetherian [IsIntegrallyClosed A] [IsNoetherianRing A] :
    IsNoetherian A C
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem _root_.stronglyMeasurable_of_stronglyMeasurable_union_cover {m : MeasurableSpace α}
    [TopologicalSpace β] {f : α → β} (s t : Set α) (hs : MeasurableSet s) (ht : MeasurableSet t)
    (h : univ ⊆ s ∪ t) (hc : StronglyMeasurable fun a : s => f a)
    (hd : StronglyMeasurable fun a : t => f a) : StronglyMeasurable f
-- Mathlib/Topology/Algebra/Polynomial.lean
@[fun_prop]
protected theorem continuousOn {s} : ContinuousOn (fun x => p.eval x) s
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp]
theorem bmod_mul_bmod : Int.bmod (Int.bmod x n * y) n = Int.bmod (x * y) n
-- Mathlib/Order/Concept.lean
@[simp]
theorem swap_lt_swap_iff : c.swap < d.swap ↔ d < c
-- Mathlib/Order/SuccPred/Basic.lean
theorem succ_mono : Monotone (succ : α → α)
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
@[simp]
lemma normEDS_four : normEDS b c d 4 = d * b
-- Mathlib/RingTheory/Bialgebra/Hom.lean
/-- Composition of bialgebra homomorphisms. -/
@[simps!] def comp (φ₁ : B →ₐc[R] C) (φ₂ : A →ₐc[R] B) : A →ₐc[R] C
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
/--
The well formedness predicate for a `FindMin` value.
This is not actually a predicate, as it contains an additional data value
`rank` corresponding to the rank of the returned node, which is omitted from `findMin`.
-/
structure FindMin.WF (le : α → α → Bool) (res : FindMin α) where
  /-- The rank of the minimum element -/
  rank : Nat
  /-- `before` is a difference list which can be appended to a binomial heap
  with ranks at least `rank` to produce another well formed heap. -/
  before : ∀ {s}, s.WF le rank → (res.before s).WF le 0
  /-- `node` is a well formed forest of rank `rank` with `val` at the root. -/
  node : res.node.WF le res.val rank
  /-- `next` is a binomial heap with ranks above `rank + 1`. -/
  next : res.next.WF le (rank + 1)
-- Mathlib/Analysis/MellinTransform.lean
theorem mellin_comp_inv (f : ℝ → E) (s : ℂ) : mellin (fun t => f t⁻¹) s = mellin f (-s)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem comp_X : p.comp X = p
-- Mathlib/Order/Filter/Pi.lean
@[simp]
theorem pi_inf_principal_univ_pi_neBot :
    NeBot (pi f ⊓ 𝓟 (Set.pi univ s)) ↔ ∀ i, NeBot (f i ⊓ 𝓟 (s i))
-- Mathlib/Algebra/Associated/Basic.lean
theorem dvd_pow_iff_dvd {a : α} {n : ℕ} (hn : n ≠ 0) : p ∣ a ^ n ↔ p ∣ a
-- Mathlib/GroupTheory/Perm/Support.lean
theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support
-- Mathlib/Algebra/Module/Submodule/Map.lean
@[simp]
protected theorem map_neg (f : M →ₗ[R] M₂) : map (-f) p = map f p
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem g_apply_infinity (x : B) : (g x) ∞ = ∞
-- Mathlib/Data/Fin/Basic.lean
theorem pred_le_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0) : pred i hi ≤ j ↔ i ≤ succ j
-- Mathlib/CategoryTheory/Shift/Basic.lean
@[reassoc]
lemma shiftFunctorAdd'_assoc_inv_app (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A)
    (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃) (X : C) :
    ((shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂).inv.app X)⟦a₃⟧' ≫
      (shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ (by rw [← h₁₂, h₁₂₃])).inv.app X =
    (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃).inv.app (X⟦a₁⟧) ≫
      (shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃])).inv.app X
-- Mathlib/Data/List/ToFinsupp.lean
@[deprecated (since := "2023-04-10")]
theorem toFinsupp_apply_lt' (hn : n < l.length) : l.toFinsupp n = l.nthLe n hn
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_node3L {P l x m y r} :
    @All α P (node3L l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
/-- A prefunctor canonically defines a prefunctor of the symmetrifications. -/
@[simps]
def _root_.Prefunctor.symmetrify (φ : U ⥤q V) : Symmetrify U ⥤q Symmetrify V
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `K / E / F` is a field extension tower, such that `E / F` is purely inseparable, then
for any intermediate field `S` of `K / F` such that `S / F` is algebraic, the `E(S) / E` and
`S / F` have the same separable degree. -/
theorem IntermediateField.sepDegree_adjoin_eq_of_isAlgebraic_of_isPurelyInseparable'
    (S : IntermediateField F K) [Algebra.IsAlgebraic F S] [IsPurelyInseparable F E] :
    sepDegree E (adjoin E (S : Set K)) = sepDegree F S
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
@[simp]
lemma _root_.AlgebraicGeometry.affineOpensRestrict_symm_apply_coe
    {X : Scheme.{u}} (U : X.Opens) (V) :
    ((affineOpensRestrict U).symm V).1 = U.ι ⁻¹ᵁ V
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem lxor_bit (a m b n) : Int.xor (bit a m) (bit b n) = bit (xor a b) (Int.xor m n)
-- .lake/packages/lean4/src/lean/Init/Data/List/BasicAux.lean
theorem append_cancel_right {as bs cs : List α} (h : as ++ bs = cs ++ bs) : as = cs
-- Mathlib/LinearAlgebra/Lagrange.lean
@[simp]
theorem nodal_empty : nodal ∅ v = 1
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y
-- Mathlib/GroupTheory/GroupAction/FixingSubgroup.lean
theorem mem_fixingSubmonoid_iff {s : Set α} {m : M} :
    m ∈ fixingSubmonoid M s ↔ ∀ y ∈ s, m • y = y
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma isClosed_sUnion (hS : ∀ s ∈ S, IsClosed s) : IsClosed (⋃₀ S)
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem IsPreconnected.intermediate_value_Ioo {s : Set X} (hs : IsPreconnected s) {l₁ l₂ : Filter X}
    [NeBot l₁] [NeBot l₂] (hl₁ : l₁ ≤ 𝓟 s) (hl₂ : l₂ ≤ 𝓟 s) {f : X → α} (hf : ContinuousOn f s)
    {v₁ v₂ : α} (ht₁ : Tendsto f l₁ (𝓝 v₁)) (ht₂ : Tendsto f l₂ (𝓝 v₂)) :
    Ioo v₁ v₂ ⊆ f '' s
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- The affine span of the orthocenter and a vertex is contained in
the altitude. -/
theorem affineSpan_orthocenter_point_le_altitude (t : Triangle ℝ P) (i : Fin 3) :
    line[ℝ, t.orthocenter, t.points i] ≤ t.altitude i
-- Mathlib/RingTheory/Filtration.lean
theorem Ideal.iInf_pow_smul_eq_bot_of_localRing [IsNoetherianRing R] [LocalRing R]
    [Module.Finite R M] (h : I ≠ ⊤) : (⨅ i : ℕ, I ^ i • ⊤ : Submodule R M) = ⊥
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem fst_dual (s : NonemptyInterval α) : s.dual.fst = toDual s.snd
-- Mathlib/Algebra/Lie/Abelian.lean
theorem abelian_of_le_center (I : LieIdeal R L) (h : I ≤ center R L) : IsLieAbelian I
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem orderIsoRpow_symm_eq (y : ℝ) (hy : 0 < y) :
    (orderIsoRpow y hy).symm = orderIsoRpow (1 / y) (one_div_pos.2 hy)
-- Mathlib/Data/Multiset/NatAntidiagonal.lean
theorem antidiagonal_succ' {n : ℕ} :
    antidiagonal (n + 1) = (n + 1, 0) ::ₘ (antidiagonal n).map (Prod.map id Nat.succ)
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem map_id_apply (a : F.obj X) : (F.map (𝟙 X)) a = a
-- Mathlib/Analysis/Calculus/LogDeriv.lean
lemma logDeriv_fun_pow {f : 𝕜 → 𝕜'} {x : 𝕜} (hdf : DifferentiableAt 𝕜 f x) (n : ℕ) :
    logDeriv (f · ^ n) x = n * logDeriv f x
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem dropLast_take {n : Nat} {l : List α} (h : n < l.length) :
    (l.take n).dropLast = l.take n.pred
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem span_neg (s : Set M) : span R (-s) = span R s