ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Interval/Set/Image.lean
lemma AntitoneOn.mapsTo_Icc (h : AntitoneOn f (Icc a b)) : MapsTo f (Icc a b) (Icc (f b) (f a))
-- Mathlib/NumberTheory/PellMatiyasevic.lean
@[simp]
theorem pellZd_succ (n : ℕ) : pellZd a1 (n + 1) = pellZd a1 n * ⟨a, 1⟩
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem eventually_no_roots (hP : P ≠ 0) : ∀ᶠ x in atTop, ¬P.IsRoot x
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem zero_toNat : toNat 0 = 0
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem irreducible_of_span_eq_maximalIdeal {R : Type*} [CommRing R] [LocalRing R] [IsDomain R]
    (ϖ : R) (hϖ : ϖ ≠ 0) (h : maximalIdeal R = Ideal.span {ϖ}) : Irreducible ϖ
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
lemma prod_sum_left {ι : Type*} (m : ι → Measure α) (μ : Measure β) [SFinite μ] :
    (Measure.sum m).prod μ = Measure.sum (fun i ↦ (m i).prod μ)
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_ge_eq_iInter_nat_add (u : ℕ → Set α) (n : ℕ) : ⋂ i ≥ n, u i = ⋂ i, u (i + n)
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/--
The substitution principle for equality. If `a = b ` and `P a` holds,
then `P b` also holds. We conventionally use the name `motive` for `P` here,
so that you can specify it explicitly using e.g.
`Eq.subst (motive := fun x => x < 5)` if it is not otherwise inferred correctly.

This theorem is the underlying mechanism behind the `rw` tactic, which is
essentially a fancy algorithm for finding good `motive` arguments to usefully
apply this theorem to replace occurrences of `a` with `b` in the goal or
hypotheses.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
-/
theorem Eq.subst {α : Sort u} {motive : α → Prop} {a b : α} (h₁ : Eq a b) (h₂ : motive a) : motive b
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.prod_rightl (h : f =o[l] g') : f =o[l] fun x => (g' x, k' x)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Filter.Tendsto.cauchySeq [SemilatticeSup β] [Nonempty β] {f : β → α} {x}
    (hx : Tendsto f atTop (𝓝 x)) : CauchySeq f
-- Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean
theorem Gamma_mul_Gamma_add_half (s : ℂ) :
    Gamma s * Gamma (s + 1 / 2) = Gamma (2 * s) * (2 : ℂ) ^ (1 - 2 * s) * ↑(√π)
-- Mathlib/Order/Monotone/Basic.lean
theorem strictMono_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
    (h : ∀ x y, x ≤ y ↔ f x ≤ f y) : StrictMono f
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
theorem differentiable_polynomial_eval_inv_mul (p : ℝ[X]) :
    Differentiable ℝ (fun x ↦ p.eval x⁻¹ * expNegInvGlue x)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem shiftLeft_zero : n <<< 0 = n
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem lineDifferentiableWithinAt_univ :
    LineDifferentiableWithinAt 𝕜 f univ x v ↔ LineDifferentiableAt 𝕜 f x v
-- Mathlib/Algebra/Group/Int.lean
@[simp] lemma natAbs_of_isUnit (hu : IsUnit u) : natAbs u = 1
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem comp_whiskerLeft_symm (f : a ⟶ b) (g : b ⟶ c) {h h' : c ⟶ d} (η : h ⟶ h') :
    f ◁ g ◁ η = (α_ f g h).inv ≫ (f ≫ g) ◁ η ≫ (α_ f g h').hom
-- Mathlib/Data/Finset/Card.lean
theorem card_filter_le (s : Finset α) (p : α → Prop) [DecidablePred p] :
    (s.filter p).card ≤ s.card
-- Mathlib/Order/Interval/Set/OrdConnected.lean
theorem ordConnected_iInter {ι : Sort*} {s : ι → Set α} (hs : ∀ i, OrdConnected (s i)) :
    OrdConnected (⋂ i, s i)
-- Mathlib/Analysis/Fourier/FourierTransform.lean
lemma fourierIntegral_comp_linearIsometry (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W) :
    𝓕 (f ∘ A) w = (𝓕 f) (A w)
-- Mathlib/Topology/Instances/Matrix.lean
theorem Summable.matrix_blockDiagonal' [DecidableEq l] {f : X → ∀ i, Matrix (m' i) (n' i) R}
    (hf : Summable f) : Summable fun x => blockDiagonal' (f x)
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
lemma fromColumns_inj : Function.Injective2 (@fromColumns R m n₁ n₂)
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem toCycle_eq_toList (f : Perm α) (hf : IsCycle f) (x : α) (hx : f x ≠ x) :
    toCycle f hf = toList f x
-- Mathlib/RingTheory/Finiteness.lean
/-- Finitely generated submodules are precisely compact elements in the submodule lattice. -/
theorem fg_iff_compact (s : Submodule R M) : s.FG ↔ CompleteLattice.IsCompactElement s
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem div_inter_subset : s / (t₁ ∩ t₂) ⊆ s / t₁ ∩ (s / t₂)
-- Mathlib/AlgebraicGeometry/Noetherian.lean
/-- If a scheme `X` has a cover by affine opens whose sections are Noetherian rings,
then `X` is locally Noetherian. -/
theorem isLocallyNoetherian_of_affine_cover {ι} {S : ι → X.affineOpens}
    (hS : (⨆ i, S i : X.Opens) = ⊤)
    (hS' : ∀ i, IsNoetherianRing Γ(X, S i)) : IsLocallyNoetherian X
-- Mathlib/Data/Complex/Exponential.lean
theorem sin_eq (z : ℂ) : sin z = sin z.re * cosh z.im + cos z.re * sinh z.im * I
-- Mathlib/Data/Set/Subsingleton.lean
theorem Nontrivial.ne_singleton {x} (hs : s.Nontrivial) : s ≠ {x}
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
@[simp]
theorem bot_arrow {X : C} : (⊥ : MonoOver X).arrow = initial.to X
-- Mathlib/Analysis/Complex/Arg.lean
theorem abs_sub_eq_iff : abs (x - y) = |abs x - abs y| ↔ x = 0 ∨ y = 0 ∨ x.arg = y.arg
-- Mathlib/Logic/Equiv/Basic.lean
theorem eq_of_prodExtendRight_ne {e : Perm β₁} {a a' : α₁} {b : β₁}
    (h : prodExtendRight a e (a', b) ≠ (a', b)) : a' = a
-- Mathlib/GroupTheory/Perm/Fin.lean
/-- The set of all permutations of `Fin (n + 1)` can be constructed by augmenting the set of
permutations of `Fin n` by each element of `Fin (n + 1)` in turn. -/
theorem Finset.univ_perm_fin_succ {n : ℕ} :
    @Finset.univ (Perm <| Fin n.succ) _ =
      (Finset.univ : Finset <| Fin n.succ × Perm (Fin n)).map
        Equiv.Perm.decomposeFin.symm.toEmbedding
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
/-- The inclusion of the image sheaf to the target. -/
@[simps]
def imageSheafι {F F' : Sheaf J (Type w)} (f : F ⟶ F') : imageSheaf f ⟶ F'
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- Concatenating the first element of a tuple with its tail gives back the original tuple -/
@[simp]
theorem snoc_init_self : snoc (init q) (q (last n)) = q
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma coe_birkhoffFinset (a : α) : birkhoffFinset a = birkhoffSet a
-- Mathlib/Data/List/NatAntidiagonal.lean
/-- The antidiagonal of `n` does not contain duplicate entries. -/
theorem nodup_antidiagonal (n : ℕ) : Nodup (antidiagonal n)
-- Mathlib/Data/Set/Lattice.lean
theorem image_eq_iUnion (f : α → β) (s : Set α) : f '' s = ⋃ i ∈ s, {f i}
-- Mathlib/Order/Hom/CompleteLattice.lean
lemma toFun_eq_coe (f : FrameHom α β) : f.toFun = f
-- Mathlib/RingTheory/MvPolynomial/Tower.lean
theorem aeval_algebraMap_eq_zero_iff [NoZeroSMulDivisors A B] [Nontrivial B] (x : σ → A)
    (p : MvPolynomial σ R) : aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**, strict differentiability at filter in both endpoints.

If `f` is a measurable function integrable on `a..b`, `(la, la')` is an `intervalIntegral.FTCFilter`
pair around `a`, and `(lb, lb')` is an `intervalIntegral.FTCFilter` pair around `b`, and `f` has
finite limits `ca` and `cb` almost surely at `la'` and `lb'`, respectively, then
`(∫ x in va..vb, f x) - ∫ x in ua..ub, f x = (vb - ub) • cb - (va - ua) • ca +
  o(‖va - ua‖ + ‖vb - ub‖)` as `ua` and `va` tend to `la` while `ub` and `vb` tend to `lb`.

This lemma could've been formulated using `HasStrictFDerivAtFilter` if we had this
definition. -/
theorem integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae
    (hab : IntervalIntegrable f volume a b) (hmeas_a : StronglyMeasurableAtFilter f la')
    (hmeas_b : StronglyMeasurableAtFilter f lb') (ha_lim : Tendsto f (la' ⊓ ae volume) (𝓝 ca))
    (hb_lim : Tendsto f (lb' ⊓ ae volume) (𝓝 cb)) (hua : Tendsto ua lt la) (hva : Tendsto va lt la)
    (hub : Tendsto ub lt lb) (hvb : Tendsto vb lt lb) :
    (fun t =>
        ((∫ x in va t..vb t, f x) - ∫ x in ua t..ub t, f x) -
          ((vb t - ub t) • cb - (va t - ua t) • ca)) =o[lt]
      fun t => ‖va t - ua t‖ + ‖vb t - ub t‖
-- Mathlib/Analysis/Fourier/ZMod.lean
lemma dft_def (Φ : ZMod N → ℂ) : 𝓕 Φ = fun k ↦ ∑ j : ZMod N, toCircle (-(j * k)) • Φ j
-- Mathlib/FieldTheory/NormalClosure.lean
lemma normal_iff_forall_map_eq : Normal F K ↔ ∀ σ : L →ₐ[F] L, K.map σ = K
-- Mathlib/Data/Finset/Piecewise.lean
@[simp]
lemma piecewise_erase_univ [DecidableEq ι] (i : ι) (f g : ∀ i, π i) :
    (Finset.univ.erase i).piecewise f g = Function.update f i (g i)
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma inv_smul_le_iff_of_pos [PosSMulMono α β] [PosSMulReflectLE α β] (ha : 0 < a) :
    a⁻¹ • b₁ ≤ b₂ ↔ b₁ ≤ a • b₂
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
lemma norm_iteratedFDerivComponent_le {α : Type*} [Fintype α]
    (f : ContinuousMultilinearMap 𝕜 E₁ G) {s : Set ι} (e : α ≃ s) [DecidablePred (· ∈ s)]
    (x : (i : ι) → E₁ i) :
    ‖f.iteratedFDerivComponent e (x ·)‖ ≤ ‖f‖ * ‖x‖ ^ (Fintype.card ι - Fintype.card α)
-- Mathlib/Topology/Compactness/Compact.lean
theorem finite_cover_nhds [CompactSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Finset X, ⋃ x ∈ t, U x = univ
-- Mathlib/Analysis/PSeries.lean
theorem le_sum_condensed' (hf : ∀ ⦃m n⦄, 0 < m → m ≤ n → f n ≤ f m) (n : ℕ) :
    (∑ k ∈ Ico 1 (2 ^ n), f k) ≤ ∑ k ∈ range n, 2 ^ k • f (2 ^ k)
-- Mathlib/ModelTheory/ElementaryMaps.lean
@[simp]
theorem toElementaryEmbedding_toEmbedding (f : M ≃[L] N) :
    f.toElementaryEmbedding.toEmbedding = f.toEmbedding
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma coreflection_apply_self :
    P.coreflection i (P.coroot i) = - P.coroot i
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma ΓSpecIso_inv : (ΓSpecIso R).inv = StructureSheaf.toOpen R ⊤
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem mk_ne_zero_of_natDegree_lt (hf : Monic f) {g : R[X]} (h0 : g ≠ 0)
    (hd : natDegree g < natDegree f) : mk f g ≠ 0
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
lemma shiftShortComplexFunctorIso_zero_add_hom_app (a : ℤ) (K : CochainComplex C ℤ) :
    (shiftShortComplexFunctorIso C 0 a a (zero_add a)).hom.app K =
      (shortComplexFunctor C (ComplexShape.up ℤ) a).map
        ((shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app K)
-- Mathlib/Topology/Algebra/GroupCompletion.lean
@[norm_cast]
theorem coe_add (a b : α) : ((a + b : α) : Completion α) = a + b
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem head_fin_const (a : α) : (vecHead fun _ : Fin (n + 1) => a) = a
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem append_prod {i j k l} {w₁ : NeWord M i j} {hne : j ≠ k} {w₂ : NeWord M k l} :
    (append w₁ hne w₂).prod = w₁.prod * w₂.prod
-- Mathlib/Data/Fin/Basic.lean
theorem rev_bijective : Bijective (@rev n)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem coe_imAddGroupHom : (imAddGroupHom : ℂ → ℝ) = im
-- Mathlib/Order/Bounds/Basic.lean
theorem image_upperBounds_subset_upperBounds_image (Hf : Monotone f) :
    f '' upperBounds s ⊆ upperBounds (f '' s)
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem HasFDerivAt.eventually_ne (h : HasFDerivAt f f' x) (hf' : ∃ C, ∀ z, ‖z‖ ≤ C * ‖f' z‖) :
    ∀ᶠ z in 𝓝[≠] x, f z ≠ f x
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Iic_mem_nhdsSet_Iic (h : a < b) : Iic b ∈ 𝓝ˢ (Iic a)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_singleton {x : M} (hx : x ≠ 0) :
    LinearIndependent R (fun x => x : ({x} : Set M) → M)
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- In this situation, `C` is also cofiltered, see
    `IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful`. -/
theorem Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful [IsCofilteredOrEmpty D] [F.Full]
    [Faithful F] (h : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) : Initial F
-- Mathlib/Algebra/Group/Fin/Tuple.lean
lemma cons_sub_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    vecCons x v - vecCons y w = vecCons (x - y) (v - w)
-- Mathlib/Data/Set/Basic.lean
theorem mem_dite (p : Prop) [Decidable p] (s : p → Set α) (t : ¬ p → Set α) (x : α) :
    (x ∈ if h : p then s h else t h) ↔ (∀ h : p, x ∈ s h) ∧ ∀ h : ¬p, x ∈ t h
-- Mathlib/GroupTheory/Nilpotent.lean
/-- A group `G` is nilpotent iff there exists an ascending central series which reaches `G` in
  finitely many steps. -/
theorem nilpotent_iff_finite_ascending_central_series :
    IsNilpotent G ↔ ∃ n : ℕ, ∃ H : ℕ → Subgroup G, IsAscendingCentralSeries H ∧ H n = ⊤
-- Mathlib/Topology/LocalAtTarget.lean
theorem embedding_iff_embedding_of_iSup_eq_top (h : Continuous f) :
    Embedding f ↔ ∀ i, Embedding ((U i).1.restrictPreimage f)
-- Mathlib/Data/Finset/Sups.lean
lemma inter_mem_infs : s ∈ 𝒜 → t ∈ ℬ → s ∩ t ∈ 𝒜 ⊼ ℬ
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
lemma map_apply (ν : FiniteMeasure Ω) {f : Ω → Ω'} (f_mble : Measurable f)
    {A : Set Ω'} (A_mble : MeasurableSet A) :
    ν.map f A = ν (f ⁻¹' A)
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem coe_lt_one (x : Ico (0 : α) 1) : (x : α) < 1
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem get?_enum (s : Seq α) (n : ℕ) : get? (enum s) n = Option.map (Prod.mk n) (get? s n)
-- Mathlib/Topology/Algebra/StarSubalgebra.lean
theorem topologicalClosure_map_le [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
    (s : StarSubalgebra R A) (φ : A →⋆ₐ[R] B) (hφ : IsClosedMap φ) :
    (map φ s).topologicalClosure ≤ map φ s.topologicalClosure
-- Mathlib/GroupTheory/Perm/Support.lean
@[simp]
theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbedding
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
@[simp] lemma comm_coe_tmul_coe {i j : ι} (a : 𝒜 i) (b : ℬ j) :
    comm 𝒜 ℬ (a ᵍ⊗ₜ b) = (-1 : ℤˣ)^(j * i) • (b ᵍ⊗ₜ a : ℬ ᵍ⊗[R] 𝒜)
-- Mathlib/FieldTheory/IsSepClosed.lean
theorem exists_eval₂_eq_zero [IsSepClosed K] (f : k →+* K)
    (p : k[X]) (hp : p.degree ≠ 0) (hsep : p.Separable) :
    ∃ x, p.eval₂ f x = 0
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- The `nonsing_inv` of `A` is a left inverse. -/
@[simp]
theorem nonsing_inv_mul (h : IsUnit A.det) : A⁻¹ * A = 1
-- Mathlib/Algebra/Group/Defs.lean
/-- A mixin for left cancellative multiplication. -/
class IsLeftCancelMul (G : Type u) [Mul G] : Prop where
  /-- Multiplication is left cancellative. -/
  protected mul_left_cancel : ∀ a b c : G, a * b = a * c → b = c
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
/-- We can evaluate the pushforward on measurable sets. For non-measurable sets, see
  `MeasureTheory.Measure.le_map_apply` and `MeasurableEquiv.map_apply`. -/
@[simp]
theorem map_apply_of_aemeasurable (hf : AEMeasurable f μ) {s : Set β} (hs : MeasurableSet s) :
    μ.map f s = μ (f ⁻¹' s)
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem toEuclideanLin_apply (M : Matrix m n 𝕜) (v : EuclideanSpace 𝕜 n) :
    toEuclideanLin M v = (WithLp.equiv 2 (m → 𝕜)).symm (M *ᵥ (WithLp.equiv 2 (n → 𝕜)) v)
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[ext]
lemma ext {n : ℕ} {α β : Ext X Y n} (h : α.hom = β.hom) : α = β
-- Mathlib/CategoryTheory/Shift/CommShift.lean
lemma commShiftIso_add (a b : A) :
    F.commShiftIso (a + b) = CommShift.isoAdd (F.commShiftIso a) (F.commShiftIso b)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the angle between two vectors is `π`, the first vector is nonzero. -/
theorem left_ne_zero_of_oangle_eq_pi {x y : V} (h : o.oangle x y = π) : x ≠ 0
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- The two step comparison map
  `image (f ≫ (g ≫ h)) ⟶ image (g ≫ h) ⟶ image h`
agrees with the one step comparison map
  `image (f ≫ (g ≫ h)) ≅ image ((f ≫ g) ≫ h) ⟶ image h`.
 -/
theorem image.preComp_comp {W : C} (h : Z ⟶ W) [HasImage (g ≫ h)] [HasImage (f ≫ g ≫ h)]
    [HasImage h] [HasImage ((f ≫ g) ≫ h)] :
    image.preComp f (g ≫ h) ≫ image.preComp g h =
      image.eqToHom (Category.assoc f g h).symm ≫ image.preComp (f ≫ g) h
-- Mathlib/Data/Set/Prod.lean
theorem univ_pi_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t
-- Mathlib/Order/Filter/Basic.lean
theorem EventuallyEq.exists_mem {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) :
    ∃ s ∈ l, EqOn f g s
-- Mathlib/Data/PNat/Basic.lean
@[simp, norm_cast]
theorem pow_coe (m : ℕ+) (n : ℕ) : ↑(m ^ n) = (m : ℕ) ^ n
-- Mathlib/LinearAlgebra/Contraction.lean
@[simp]
theorem dualTensorHomEquivOfBasis_symm_cancel_right (x : M →ₗ[R] N) :
    dualTensorHom R M N ((dualTensorHomEquivOfBasis (N := N) b).symm x) = x
-- Mathlib/Data/Set/Prod.lean
theorem range_dcomp (f : ∀ i, α i → β i) :
    (range fun g : ∀ i, α i => fun i => f i (g i)) = pi univ fun i => range (f i)
-- Mathlib/Algebra/Polynomial/Expand.lean
@[simp]
theorem expand_monomial (r : R) : expand R p (monomial q r) = monomial (q * p) r
-- Mathlib/Data/List/Join.lean
/-- See `List.length_bind` for the corresponding statement using `List.sum`. -/
lemma length_bind' (l : List α) (f : α → List β) :
    length (l.bind f) = Nat.sum (map (length ∘ f) l)
-- Mathlib/Data/Sym/Sym2/Order.lean
/-- In a linear order, symmetric squares are canonically identified with ordered pairs. -/
@[simps!]
def sortEquiv [LinearOrder α] : Sym2 α ≃ { p : α × α // p.1 ≤ p.2 }
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
lemma cons_val_three (x : α) (u : Fin m.succ.succ.succ → α) :
    vecCons x u 3 = vecHead (vecTail (vecTail u))
-- .lake/packages/batteries/Batteries/Classes/Order.lean
/-- `LECmp cmp` asserts that `cmp x y ≠ .gt` and `x ≤ y` coincide. -/
class LECmp [LE α] (cmp : α → α → Ordering) extends OrientedCmp cmp : Prop where
  /-- `cmp x y ≠ .gt` holds iff `x ≤ y` is true. -/
  cmp_iff_le : cmp x y ≠ .gt ↔ x ≤ y
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem Measurable.carg : Measurable fun x => arg (f x)
-- Mathlib/Topology/UniformSpace/Basic.lean
@[simp]
theorem comap_swap_uniformity : comap (@Prod.swap α α) (𝓤 α) = 𝓤 α
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem nil_append (as : List α) : [] ++ as = as
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- The angle between the negation of a nonzero vector and that vector is `π`. -/
@[simp]
theorem oangle_neg_self_left {x : V} (hx : x ≠ 0) : o.oangle (-x) x = π
-- Mathlib/Algebra/GroupWithZero/Divisibility.lean
/-- Given two elements `a`, `b` of a commutative `CancelMonoidWithZero` and a nonzero
  element `c`, `a*c` divides `b*c` iff `a` divides `b`. -/
theorem mul_dvd_mul_iff_right [CancelCommMonoidWithZero α] {a b c : α} (hc : c ≠ 0) :
    a * c ∣ b * c ↔ a ∣ b
-- Mathlib/CategoryTheory/GradedObject/Unitor.lean
@[reassoc]
lemma mapBifunctorRightUnitor_inv_naturality :
    φ ≫ (mapBifunctorRightUnitor F Y e p hp X').inv =
      (mapBifunctorRightUnitor F Y e p hp X).inv ≫ mapBifunctorMapMap F p φ (𝟙 _)
-- Mathlib/Order/Directed.lean
theorem Antitone.directed_ge [Preorder α] [IsDirected α (· ≤ ·)] [Preorder β] {f : α → β}
    (hf : Antitone f) : Directed (· ≥ ·) f
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Real.lean
theorem rnDeriv_ae_eq_condexp {hm : m ≤ m0} [hμm : SigmaFinite (μ.trim hm)] {f : α → ℝ}
    (hf : Integrable f μ) :
    SignedMeasure.rnDeriv ((μ.withDensityᵥ f).trim hm) (μ.trim hm) =ᵐ[μ] μ[f|m]
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
protected theorem _root_.Pairwise.aedisjoint {f : ι → Set α} (hf : Pairwise (Disjoint on f)) :
    Pairwise (AEDisjoint μ on f)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem lt_of_getLsb (x : BitVec w) (i : Nat) : getLsb x i = true → i < w
-- Mathlib/Data/NNReal/Basic.lean
theorem lt_iff_exists_rat_btwn (a b : ℝ≥0) :
    a < b ↔ ∃ q : ℚ, 0 ≤ q ∧ a < Real.toNNReal q ∧ Real.toNNReal q < b
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem permCongr_symm : e.permCongr.symm = e.symm.permCongr
-- Mathlib/NumberTheory/GaussSum.lean
/-- When `R'` has prime characteristic `p`, then the `p`th power of the Gauss sum
of `χ` and `ψ` is the Gauss sum of `χ^p` and `ψ^p`. -/
theorem gaussSum_frob (χ : MulChar R R') (ψ : AddChar R R') :
    gaussSum χ ψ ^ p = gaussSum (χ ^ p) (ψ ^ p)
-- Mathlib/Algebra/Lie/Submodule.lean
lemma isCompactElement_lieSpan_singleton (m : M) :
    CompleteLattice.IsCompactElement (lieSpan R L {m})
-- Mathlib/Data/List/ReduceOption.lean
@[simp]
theorem reduceOption_cons_of_some (x : α) (l : List (Option α)) :
    reduceOption (some x :: l) = x :: l.reduceOption
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[reassoc, simp]
theorem braiding_inv_tensorUnit_left (X : C) : (β_ (𝟙_ C) X).inv = (ρ_ X).hom ≫ (λ_ X).inv
-- Mathlib/Data/Set/Card.lean
theorem ncard_add_ncard_compl (s : Set α) (hs : s.Finite := by toFinite_tac)
    (hsc : sᶜ.Finite := by toFinite_tac) : s.ncard + sᶜ.ncard = Nat.card α
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp, norm_cast] lemma val_qsmul (q : ℚ) (x : selfAdjoint R) : ↑(q • x) = q • (x : R)
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
@[simp]
theorem eval_one_cyclotomic_prime_pow {R : Type*} [CommRing R] {p : ℕ} (k : ℕ)
    [hn : Fact p.Prime] : eval 1 (cyclotomic (p ^ (k + 1)) R) = p
-- Mathlib/Tactic/Abel.lean
theorem term_smulg {α} [AddCommGroup α] (c n x a n' a')
    (h₁ : c * n = n') (h₂ : smulg c a = a') :
    smulg c (@termg α _ n x a) = termg n' x a'
-- Mathlib/Topology/DiscreteQuotient.lean
theorem fiber_eq (x : X) : S.proj ⁻¹' {S.proj x} = setOf (S.Rel x)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableOn_add_const_iff (c : F) :
    DifferentiableOn 𝕜 (fun y => f y + c) s ↔ DifferentiableOn 𝕜 f s
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[elab_as_elim]
theorem inductionOn {C : Ordinal → Prop} (o : Ordinal)
    (H : ∀ (α r) [IsWellOrder α r], C (type r)) : C o
-- Mathlib/RingTheory/SimpleModule.lean
theorem isSimpleModule_iff_finrank_eq_one {R} [DivisionRing R] [Module R M] :
    IsSimpleModule R M ↔ FiniteDimensional.finrank R M = 1
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal_mul [Fintype n] [Fintype o] [NonUnitalNonAssocSemiring α]
    (M : o → Matrix m n α) (N : o → Matrix n p α) :
    (blockDiagonal fun k => M k * N k) = blockDiagonal M * blockDiagonal N
-- Mathlib/RingTheory/Bialgebra/Hom.lean
theorem copy_eq (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : f.copy f' h = f
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Product.lean
/-- The projection map is precisely `Path.Homotopic.proj` interpreted as a functor -/
@[simp]
theorem proj_map (i : I) (x₀ x₁ : πₓ (TopCat.of (∀ i, X i))) (p : x₀ ⟶ x₁) :
    (proj X i).map p = @Path.Homotopic.proj _ _ _ _ _ i p
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem coprod_inl (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : (coprod f g).comp (inl R M M₂) = f
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem comapDomain_add [∀ i, AddZeroClass (β i)] (h : κ → ι) (hh : Function.Injective h)
    (f g : Π₀ i, β i) : comapDomain h hh (f + g) = comapDomain h hh f + comapDomain h hh g
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem ofInt_re (n : ℤ) : (ofInt n : ℤ√d).re = n
-- Mathlib/Analysis/Fourier/FourierTransform.lean
lemma fourierIntegral_eq (f : V → E) (w : V) :
    𝓕 f w = ∫ v, 𝐞 (-⟪v, w⟫) • f v
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem sameCycle_conj : SameCycle (g * f * g⁻¹) x y ↔ SameCycle f (g⁻¹ x) (g⁻¹ y)
-- Mathlib/Data/PFunctor/Univariate/M.lean
/-- Internal definition for `M`. It is needed to avoid name clashes
between `M.mk` and `M.cases_on` and the declarations generated for
the structure -/
structure MIntl where
  /-- An `n`-th level approximation, for each depth `n` -/
  approx : ∀ n, CofixA F n
  /-- Each approximation agrees with the next -/
  consistent : AllAgree approx
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem uniformContinuous_compareEquiv : UniformContinuous (pkg.compareEquiv pkg')
-- Mathlib/Algebra/Regular/Pow.lean
/-- An element `a` is regular if and only if a positive power of `a` is regular. -/
theorem IsRegular.pow_iff {n : ℕ} (n0 : 0 < n) : IsRegular (a ^ n) ↔ IsRegular a
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Iio_eq : Iio a = (Iio (a : α)).subtype p