ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Projection.lean
theorem range_eq_of_proj {f : E →ₗ[R] p} (hf : ∀ x : p, f x = x) : range f = ⊤
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem image_sub_const_uIcc : (fun x => x - a) '' [[b, c]] = [[b - a, c - a]]
-- .lake/packages/lean4/src/lean/Init/Data/Char/Lemmas.lean
theorem Char.ext_iff {x y : Char} : x = y ↔ x.val = y.val
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem prod_coe (γ₁ : Path a₁ a₂) (γ₂ : Path b₁ b₂) :
    ⇑(γ₁.prod γ₂) = fun t => (γ₁ t, γ₂ t)
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
lemma Γevaluation_naturality_apply (x : X) (a : Y.presheaf.obj (op ⊤)) :
    residueFieldMap f x (Y.Γevaluation (f.val.base x) a) =
      X.Γevaluation x (f.val.c.app (op ⊤) a)
-- Mathlib/Data/TypeVec.lean
theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ β ⟹ _)
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem aeval_monomial {n : ℕ} {r : R} : aeval x (monomial n r) = algebraMap _ _ r * x ^ n
-- Mathlib/Probability/Independence/Basic.lean
theorem iIndep.iIndepSets
    {s : ι → Set (Set Ω)} (hms : ∀ n, m n = generateFrom (s n)) (h_indep : iIndep m μ) :
    iIndepSets s μ
-- Mathlib/Order/Defs.lean
theorem le_of_eq {a b : α} : a = b → a ≤ b
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem DifferentiableWithinAt.div_const (hc : DifferentiableWithinAt 𝕜 c s x) (d : 𝕜') :
    DifferentiableWithinAt 𝕜 (fun x => c x / d) s x
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- If `find p = some i`, then `p i` holds -/
theorem find_spec :
    ∀ {n : ℕ} (p : Fin n → Prop) [DecidablePred p] {i : Fin n} (_ : i ∈ Fin.find p), p i
-- Mathlib/ModelTheory/Skolem.lean
/-- The **Downward Löwenheim–Skolem theorem** :
  If `s` is a set in an `L`-structure `M` and `κ` an infinite cardinal such that
  `max (#s, L.card) ≤ κ` and `κ ≤ # M`, then `M` has an elementary substructure containing `s` of
  cardinality `κ`.  -/
theorem exists_elementarySubstructure_card_eq (s : Set M) (κ : Cardinal.{w'}) (h1 : ℵ₀ ≤ κ)
    (h2 : Cardinal.lift.{w'} #s ≤ Cardinal.lift.{w} κ)
    (h3 : Cardinal.lift.{w'} L.card ≤ Cardinal.lift.{max u v} κ)
    (h4 : Cardinal.lift.{w} κ ≤ Cardinal.lift.{w'} #M) :
    ∃ S : L.ElementarySubstructure M, s ⊆ S ∧ Cardinal.lift.{w'} #S = Cardinal.lift.{w} κ
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/Defs.lean
lemma eisensteinSeries_SIF_apply (k : ℤ) (z : ℍ) :
    eisensteinSeries_SIF a k z = eisensteinSeries a k z
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem SameCycle.exists_pow_eq_of_mem_support {f} [DecidableEq α] [Fintype α] (h : SameCycle f x y)
    (hx : x ∈ f.support) : ∃ i < (f.cycleOf x).support.card, (f ^ i) x = y
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem BinaryBicone.sndKernelFork_ι : (BinaryBicone.sndKernelFork c).ι = c.inl
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem continuous_normed : Continuous (f.normed μ)
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_sdiff_comm : (a \ b) \ c = (a \ c) \ b
-- Mathlib/Topology/Filter.lean
protected theorem HasBasis.nhds {l : Filter α} {p : ι → Prop} {s : ι → Set α} (h : HasBasis l p s) :
    HasBasis (𝓝 l) p fun i => Iic (𝓟 (s i))
-- Mathlib/Topology/Algebra/Algebra.lean
theorem Subalgebra.isClosed_topologicalClosure (s : Subalgebra R A) :
    IsClosed (s.topologicalClosure : Set A)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem mkOfCompact_add [CompactSpace α] (f g : C(α, β)) :
    mkOfCompact (f + g) = mkOfCompact f + mkOfCompact g
-- Mathlib/NumberTheory/Bernoulli.lean
theorem bernoulli'PowerSeries_mul_exp_sub_one :
    bernoulli'PowerSeries A * (exp A - 1) = X * exp A
-- Mathlib/Topology/NhdsSet.lean
theorem disjoint_nhdsSet_principal : Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t)
-- Mathlib/Computability/Primrec.lean
theorem option_map₁ {f : α → σ} (hf : Primrec f) : Primrec (Option.map f)
-- Mathlib/Algebra/Group/Int.lean
lemma two_not_dvd_two_mul_add_one (n : ℤ) : ¬2 ∣ 2 * n + 1
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem coeComplex_add (z w : ℂ) : ↑(z + w) = (z + w : ℍ)
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAnti.image_Ioi_subset (h : StrictAnti f) : f '' Ioi a ⊆ Iio (f a)
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem Heap.realSize_tail (le) (s : Heap α) : (s.tail le).realSize = s.realSize - 1
-- Mathlib/Order/BoundedOrder.lean
theorem eq_bot_of_bot_eq_top (hα : (⊥ : α) = ⊤) (x : α) : x = (⊥ : α)
-- Mathlib/Data/Num/Lemmas.lean
theorem ppred_to_nat : ∀ n : Num, (↑) <$> ppred n = Nat.ppred n
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_eq_iInf' (s : Set α) : sInf s = ⨅ a : s, (a : α)
-- Mathlib/RingTheory/JacobsonIdeal.lean
theorem mem_jacobson_iff {x : R} : x ∈ jacobson I ↔ ∀ y, ∃ z, z * y * x + z - 1 ∈ I
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk (p : R[X]) :
    (quotAdjoinRootEquivQuotPolynomialQuot I f).symm
        (Ideal.Quotient.mk (span ({f.map (Ideal.Quotient.mk I)} : Set (R ⧸ I)[X]))
        (p.map (Ideal.Quotient.mk I))) =
      Ideal.Quotient.mk (I.map (of f)) (mk f p)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@[simp]
theorem contractLeft_one : d⌋(1 : CliffordAlgebra Q) = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivAt.cos (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x
-- Mathlib/FieldTheory/Normal.lean
theorem AlgHom.normal_bijective [h : Normal F E] (ϕ : E →ₐ[F] K) : Function.Bijective ϕ
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- `SimpleFunc.integral` and `SimpleFunc.lintegral` agree when the integrand has type
    `α →ₛ ℝ≥0∞`. But since `ℝ≥0∞` is not a `NormedSpace`, we need some form of coercion.
    See `integral_eq_lintegral` for a simpler version. -/
theorem integral_eq_lintegral' {f : α →ₛ E} {g : E → ℝ≥0∞} (hf : Integrable f μ) (hg0 : g 0 = 0)
    (ht : ∀ b, g b ≠ ∞) :
    (f.map (ENNReal.toReal ∘ g)).integral μ = ENNReal.toReal (∫⁻ a, g (f a) ∂μ)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle as a ratio of sides, version subtracting
vectors. -/
theorem tan_oangle_sub_left_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    Real.Angle.tan (o.oangle (x - y) x) = ‖y‖ / ‖x‖
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem factorial_smul_hasseDeriv : ⇑(k ! • @hasseDeriv R _ k) = (@derivative R _)^[k]
-- Mathlib/Data/QPF/Multivariate/Basic.lean
theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
    u ∈ supp x i ↔ ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ
-- Mathlib/Data/Real/EReal.lean
theorem coe_real_ereal_eq_coe_toNNReal_sub_coe_toNNReal (x : ℝ) :
    (x : EReal) = Real.toNNReal x - Real.toNNReal (-x)
-- Mathlib/Probability/ConditionalProbability.lean
lemma cond_absolutelyContinuous : μ[|s] ≪ μ
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem comp_memℒp' (L : E →L[𝕜] F) {f : α → E} (hf : Memℒp f p μ) : Memℒp (L ∘ f) p μ
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem aeval_eq_smeval {R : Type*} [CommSemiring R] {S : Type*} [Semiring S] [Algebra R S]
    (x : S) (p : R[X]) : aeval x p = p.smeval x
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem IsCompactElement.exists_finset_of_le_iSup {k : α} (hk : IsCompactElement k) {ι : Type*}
    (f : ι → α) (h : k ≤ ⨆ i, f i) : ∃ s : Finset ι, k ≤ ⨆ i ∈ s, f i
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem mkMetric_nnreal_smul (m : ℝ≥0∞ → ℝ≥0∞) {c : ℝ≥0} (hc : c ≠ 0) :
    (mkMetric (c • m) : OuterMeasure X) = c • mkMetric m
-- Mathlib/RingTheory/Finiteness.lean
theorem id : Finite (RingHom.id A)
-- Mathlib/Algebra/Lie/Derivation/AdjointAction.lean
lemma maxTrivSubmodule_eq_bot_of_center_eq_bot (h : LieAlgebra.center R L = ⊥) :
    LieModule.maxTrivSubmodule R L (LieDerivation R L L) = ⊥
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem C_surjective {R : Type*} [CommSemiring R] (σ : Type*) [IsEmpty σ] :
    Function.Surjective (C : R → MvPolynomial σ R)
-- Mathlib/RingTheory/Binomial.lean
theorem multichoose_succ_neg_natCast [NatPowAssoc R] (n : ℕ) :
    multichoose (-n : R) (n + 1) = 0
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
/-- The exponential map in a commutative Banach algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ` has strict
Fréchet derivative `exp 𝕂 x • 1 : 𝔸 →L[𝕂] 𝔸` at any point `x`. -/
theorem hasStrictFDerivAt_exp {x : 𝔸} : HasStrictFDerivAt (exp 𝕂) (exp 𝕂 x • (1 : 𝔸 →L[𝕂] 𝔸)) x
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem compl_symmDiff : (a ∆ b)ᶜ = a ⇔ b
-- Mathlib/AlgebraicGeometry/Properties.lean
theorem isIntegral_iff_irreducibleSpace_and_isReduced :
    IsIntegral X ↔ IrreducibleSpace X ∧ IsReduced X
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- If `K₁` is complete and contained in `K₂`, `K₁` and `K₁ᗮ ⊓ K₂` span `K₂`. -/
theorem Submodule.sup_orthogonal_inf_of_completeSpace {K₁ K₂ : Submodule 𝕜 E} (h : K₁ ≤ K₂)
    [HasOrthogonalProjection K₁] : K₁ ⊔ K₁ᗮ ⊓ K₂ = K₂
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma rnDeriv_eq_zero_of_mutuallySingular [SigmaFinite μ] {ν' : Measure α}
    [SigmaFinite ν'] (h : μ ⟂ₘ ν) (hνν' : ν ≪ ν') :
    μ.rnDeriv ν' =ᵐ[ν] 0
-- Mathlib/Algebra/Ring/Equiv.lean
/-- The two paths coercion can take to a `MonoidHom` are equivalent -/
theorem toMonoidHom_commutes (f : R ≃+* S) :
    (f : R →+* S).toMonoidHom = (f : R ≃* S).toMonoidHom
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_add (x y : ENNReal) : ((x + y : ℝ≥0∞) : EReal) = x + y
-- Mathlib/Topology/Algebra/Polynomial.lean
theorem tendsto_abv_atTop {R k α : Type*} [Ring R] [LinearOrderedField k] (abv : R → k)
    [IsAbsoluteValue abv] (p : R[X]) (h : 0 < degree p) {l : Filter α} {z : α → R}
    (hz : Tendsto (abv ∘ z) l atTop) : Tendsto (fun x => abv (p.eval (z x))) l atTop
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_le_pow_iff_mem_span_pow (x : ℤ_[p]) (n : ℕ) :
    ‖x‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ x ∈ (Ideal.span {(p : ℤ_[p]) ^ n} : Ideal ℤ_[p])
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
protected lemma Nil.eq {p : G.Walk v w} : p.Nil → v = w
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
theorem HasSum.unop {f : β → αᵐᵒᵖ} {a : αᵐᵒᵖ} (hf : HasSum f a) :
    HasSum (fun a ↦ unop (f a)) (unop a)
-- Mathlib/LinearAlgebra/Basis.lean
theorem units_smul_span_eq_top {v : ι → M} (hv : Submodule.span R (Set.range v) = ⊤) {w : ι → Rˣ} :
    Submodule.span R (Set.range (w • v)) = ⊤
-- Mathlib/Probability/Density.lean
theorem pdf_of_not_haveLebesgueDecomposition {_ : MeasurableSpace Ω} {ℙ : Measure Ω}
    {μ : Measure E} {X : Ω → E} (h : ¬(map X ℙ).HaveLebesgueDecomposition μ) : pdf X ℙ μ = 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_self_eq_zero {x : F} : ⟪x, x⟫ = 0 ↔ x = 0
-- Mathlib/Analysis/MeanInequalities.lean
/-- **Minkowski inequality**: the `L_p` seminorm of the infinite sum of two vectors is less than or
equal to the infinite sum of the `L_p`-seminorms of the summands, if these infinite sums both
exist. A version for `ℝ`-valued functions. For an alternative version, convenient if the infinite
sums are not already expressed as `p`-th powers, see `Lp_add_le_tsum_of_nonneg`. -/
theorem Lp_add_le_hasSum_of_nonneg (hp : 1 ≤ p) (hf : ∀ i, 0 ≤ f i) (hg : ∀ i, 0 ≤ g i) {A B : ℝ}
    (hA : 0 ≤ A) (hB : 0 ≤ B) (hfA : HasSum (fun i => f i ^ p) (A ^ p))
    (hgB : HasSum (fun i => g i ^ p) (B ^ p)) :
    ∃ C, 0 ≤ C ∧ C ≤ A + B ∧ HasSum (fun i => (f i + g i) ^ p) (C ^ p)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The first of two points lies in their affine span. -/
theorem left_mem_affineSpan_pair (p₁ p₂ : P) : p₁ ∈ line[k, p₁, p₂]
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem comp_id (f : CoheytingHom α β) : f.comp (CoheytingHom.id α) = f
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_dirac [MeasurableSingletonClass α] (a : α) (f : α → ℝ≥0∞) :
    ∫⁻ a, f a ∂dirac a = f a
-- Mathlib/Algebra/Module/Equiv/Basic.lean
theorem funLeft_comp (f₁ : n → p) (f₂ : m → n) :
    funLeft R M (f₁ ∘ f₂) = (funLeft R M f₂).comp (funLeft R M f₁)
-- Mathlib/Topology/MetricSpace/Gluing.lean
theorem Sum.mem_uniformity_iff_glueDist (hε : 0 < ε) (s : Set ((X ⊕ Y) × (X ⊕ Y))) :
    s ∈ 𝓤 (X ⊕ Y) ↔ ∃ δ > 0, ∀ a b, glueDist Φ Ψ ε a b < δ → (a, b) ∈ s
-- Mathlib/Order/UpperLower/Hom.lean
@[simp]
theorem coe_iciSupHom : (iciSupHom : α → UpperSet α) = Ici
-- Mathlib/Computability/Partrec.lean
theorem nat_iff {f : ℕ →. ℕ} : Partrec f ↔ Nat.Partrec f
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive (attr := simp)]
theorem map_id (S : Subsemigroup M) : S.map (MulHom.id M) = S
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u)
-- Mathlib/Data/Nat/Digits.lean
theorem digits_ne_nil_iff_ne_zero {b n : ℕ} : digits b n ≠ [] ↔ n ≠ 0
-- Mathlib/Data/Finset/Functor.lean
@[simp]
theorem seq_def (s : Finset α) (t : Finset (α → β)) : t <*> s = t.sup fun f => s.image f
-- Mathlib/Order/SuccPred/Basic.lean
theorem Pred.rec_linear {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) (a b : α) : p a ↔ p b
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueSet_bot (hn : 1 < n) : (⊥ : SimpleGraph α).cliqueSet n = ∅
-- Mathlib/Data/Finset/Image.lean
theorem image_val_of_injOn (H : Set.InjOn f s) : (image f s).1 = s.1.map f
-- Mathlib/Data/Nat/Defs.lean
lemma pred_eq_of_eq_succ (H : m = n.succ) : m.pred = n
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_of_finite (s : Set A)
    (H : ∀ t ⊆ s, t.Finite → AlgebraicIndependent R ((↑) : t → A)) :
    AlgebraicIndependent R ((↑) : s → A)
-- Mathlib/Data/Finsupp/Basic.lean
theorem smul_single_one [Semiring R] (a : α) (b : R) : b • single a (1 : R) = single a b
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma nilRankAux_le [Nontrivial R] (b : Basis ι R L) (b' : Basis ι' R L) :
    nilRankAux φ b ≤ nilRankAux φ b'
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
theorem toMatrix_smul_left {G} [Group G] [DistribMulAction G M] [SMulCommClass G R M] (g : G) :
    (g • e).toMatrix v = e.toMatrix (g⁻¹ • v)
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem mk_coeFn (f : α →ₘ[μ] β) : mk f f.aestronglyMeasurable = f
-- Mathlib/Topology/Semicontinuous.lean
/-- The sum of two lower semicontinuous functions is lower semicontinuous. Formulated with an
explicit continuity assumption on addition, for application to `EReal`. The unprimed version of
the lemma uses `[ContinuousAdd]`. -/
theorem LowerSemicontinuousAt.add' {f g : α → γ} (hf : LowerSemicontinuousAt f x)
    (hg : LowerSemicontinuousAt g x)
    (hcont : ContinuousAt (fun p : γ × γ => p.1 + p.2) (f x, g x)) :
    LowerSemicontinuousAt (fun z => f z + g z) x
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem prod_snd : LipschitzWith 1 (@Prod.snd α β)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean
lemma cfcHom_nnreal_eq_restrict {a : A} (ha : 0 ≤ a) :
    cfcHom ha = (SpectrumRestricts.nnreal_of_nonneg ha).starAlgHom
      (cfcHom (IsSelfAdjoint.of_nonneg ha))
-- Mathlib/NumberTheory/Divisors.lean
@[simp]
theorem divisors_one : divisors 1 = {1}
-- Mathlib/Analysis/Fourier/AddCircle.lean
/-- If the sequence of Fourier coefficients of `f` is summable, then the Fourier series of `f`
converges everywhere pointwise to `f`. -/
theorem has_pointwise_sum_fourier_series_of_summable (h : Summable (fourierCoeff f))
    (x : AddCircle T) : HasSum (fun i => fourierCoeff f i • fourier i x) (f x)
-- Mathlib/Topology/Bornology/Constructions.lean
theorem IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsBounded t
-- Mathlib/Data/Seq/WSeq.lean
theorem LiftRelO.imp_right (R : α → β → Prop) {C D : WSeq α → WSeq β → Prop}
    (H : ∀ s t, C s t → D s t) {o p} : LiftRelO R C o p → LiftRelO R D o p
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[fun_prop]
theorem aemeasurable_id'' (μ : Measure α) {m : MeasurableSpace α} (hm : m ≤ m0) :
    @AEMeasurable α α m m0 id μ
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem Coprime.gcd_mul_left_cancel_right (n : Nat)
    (H : Coprime k m) : gcd m (k * n) = gcd m n
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
theorem slash_action_eqn [SlashInvariantFormClass F Γ k] (f : F) (γ : Γ) :
    ↑f ∣[k] γ = ⇑f
-- Mathlib/Dynamics/Ergodic/Function.lean
/-- Let `f : α → α` be an ergodic map.
Let `g : α → X` be an a.e. strongly measurable function
from `α` to a nonempty metrizable topological space.
If `g` is a.e.-invariant under `f`, then `g` is a.e. constant. -/
theorem ae_eq_const_of_ae_eq_comp_ae {g : α → X} (h : Ergodic f μ) (hgm : AEStronglyMeasurable g μ)
    (hg_eq : g ∘ f =ᵐ[μ] g) : ∃ c, g =ᵐ[μ] const α c
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
@[simp]
theorem _root_.OrthonormalBasis.coe_toHilbertBasis [Fintype ι] (b : OrthonormalBasis ι 𝕜 E) :
    (b.toHilbertBasis : ι → E) = b
-- Mathlib/Data/Nat/Digits.lean
/-- Interpreting as a base `p` number and dividing by `p` is the same as interpreting the tail.
-/
lemma ofDigits_div_eq_ofDigits_tail {p : ℕ} (hpos : 0 < p) (digits : List ℕ)
    (w₁ : ∀ l ∈ digits, l < p) : ofDigits p digits / p = ofDigits p digits.tail
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem ofNat_add {n} (x y : Nat) : BitVec.ofNat n (x + y) = BitVec.ofNat n x + BitVec.ofNat n y
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem balancedCoreAux_maximal (h : t ⊆ s) (ht : Balanced 𝕜 t) : t ⊆ balancedCoreAux 𝕜 s
-- Mathlib/Topology/Basic.lean
theorem IsClosed.union : IsClosed s₁ → IsClosed s₂ → IsClosed (s₁ ∪ s₂)
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
@[simp]
theorem div_self {a : R} (a0 : a ≠ 0) : a / a = 1
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem roots_X_pow_card_sub_X : roots (X ^ q - X : K[X]) = Finset.univ.val
-- Mathlib/RingTheory/OreLocalization/OreSet.lean
lemma nonempty_oreSet_iff {R : Type*} [Ring R] {S : Submonoid R} :
    Nonempty (OreSet S) ↔ (∀ (r₁ r₂ : R) (s : S), r₁ * s = r₂ * s → ∃ s' : S, s' * r₁ = s' * r₂) ∧
      (∀ (r : R) (s : S), ∃ (r' : R) (s' : S), s' * r = r' * s)
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem gcd_mul_right_add_left (m n k : ℕ) : gcd (k * n + m) n = gcd m n
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- If Cᵒᵖ is filtered or empty, then C is cofiltered or empty. -/
lemma isCofilteredOrEmpty_of_isFilteredOrEmpty_op [IsFilteredOrEmpty Cᵒᵖ] : IsCofilteredOrEmpty C
-- Mathlib/CategoryTheory/SmallObject/Iteration.lean
@[simp]
lemma restrictionLT_map {k₁ k₂ : { k // k < i }} (φ : k₁ ⟶ k₂) :
    (restrictionLT F hi).map φ = F.map (homOfLE (by simpa using leOfHom φ))
-- Mathlib/Data/List/GetD.lean
theorem getD_eq_get {n : ℕ} (hn : n < l.length) : l.getD n d = l.get ⟨n, hn⟩
-- Mathlib/LinearAlgebra/Ray.lean
theorem exists_nonneg_left_iff_sameRay (hx : x ≠ 0) :
    (∃ r : R, 0 ≤ r ∧ r • x = y) ↔ SameRay R x y
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem map_comap_le : map f (comap f N₂) ≤ N₂
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
protected theorem image_eq (s : Set H) : I '' s = I.symm ⁻¹' s ∩ range I
-- Mathlib/Init/Logic.lean
theorem not_of_eq_false {p : Prop} (h : p = False) : ¬p
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem zipWithAll_map_left (l₁ : List α) (l₂ : List β) (f : α → α') (g : Option α' → Option β → γ) :
    zipWithAll g (l₁.map f) l₂ = zipWithAll (fun a b => g (f <$> a) b) l₁ l₂
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.trans_tendsto (hfg : f'' =O[l] g'') (hg : Tendsto g'' l (𝓝 0)) :
    Tendsto f'' l (𝓝 0)
-- Mathlib/Analysis/Calculus/FDeriv/Linear.lean
@[fun_prop]
theorem IsBoundedLinearMap.hasFDerivAt (h : IsBoundedLinearMap 𝕜 f) :
    HasFDerivAt f h.toContinuousLinearMap x
-- Mathlib/Analysis/Analytic/Basic.lean
theorem hasFPowerSeriesAt_const {c : F} {e : E} :
    HasFPowerSeriesAt (fun _ => c) (constFormalMultilinearSeries 𝕜 E c) e
-- Mathlib/Data/Nat/Defs.lean
protected lemma dvd_add_left (h : a ∣ c) : a ∣ b + c ↔ a ∣ b
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem isEmpty_replicate : (replicate n a).isEmpty = decide (n = 0)
-- Mathlib/Data/Finset/Union.lean
@[simp]
lemma biUnion_insert [DecidableEq α] {a : α} : (insert a s).biUnion t = t a ∪ s.biUnion t
-- Mathlib/GroupTheory/Perm/List.lean
theorem zipWith_swap_prod_support' (l l' : List α) :
    { x | (zipWith swap l l').prod x ≠ x } ≤ l.toFinset ⊔ l'.toFinset
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropOn_univ : LiftPropOn P g univ ↔ LiftProp P g
-- Mathlib/Data/Nat/Digits.lean
theorem digits_succ (b n m r l) (e : r + b * m = n) (hr : r < b)
    (h : Nat.digits b m = l ∧ 1 < b ∧ 0 < m) : (Nat.digits b n = r :: l) ∧ 1 < b ∧ 0 < n
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem mem_toSubalgebra {S : StarSubalgebra R A} {x} : x ∈ S.toSubalgebra ↔ x ∈ S
-- Mathlib/RingTheory/Adjoin/Basic.lean
@[simp]
theorem adjoin_top :
    adjoin (⊤ : Subalgebra R S) t = (adjoin S t).restrictScalars (⊤ : Subalgebra R S)
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem get_map₂ (v₁ : Vector α n) (v₂ : Vector β n) (f : α → β → γ) (i : Fin n) :
    get (map₂ f v₁ v₂) i = f (get v₁ i) (get v₂ i)
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_le_choose {a b : ℕ} (c : ℕ) (h : a ≤ b) : choose a c ≤ choose b c
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma dblX_smul (P : Fin 3 → R) (u : R) : W'.dblX (u • P) = (u ^ 4) ^ 2 * W'.dblX P
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem pred_succ : ∀ n : ZNum, n.pred.succ = n
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
    f <*> x - y = (f <*> x) - (f <*> y)
-- Mathlib/Algebra/Lie/Derivation/AdjointAction.lean
lemma ad_apply_lieDerivation (x : L) (D : LieDerivation R L L) : ad R L (D x) = - ⁅x, D⁆
-- Mathlib/Logic/Unique.lean
theorem eq_const_of_subsingleton {β : Sort*} [Subsingleton α] (f : α → β) (a : α) :
    f = Function.const α (f a)
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem lieIdeal_oper_eq_span :
    ⁅I, N⁆ = lieSpan R L { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m }
-- Mathlib/CategoryTheory/Limits/ExactFunctor.lean
@[simp]
theorem LeftExactFunctor.ofExact_map {F G : C ⥤ₑ D} (α : F ⟶ G) :
    (LeftExactFunctor.ofExact C D).map α = α
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem apply (φ : K →+* ℂ) (x : K) : (mk φ) x = Complex.abs (φ x)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma baseChange_preΨ₄ : (W.baseChange B).preΨ₄ = (W.baseChange A).preΨ₄.map f
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Lp.lean
theorem Integrable.aefinStronglyMeasurable (hf : Integrable f μ) : AEFinStronglyMeasurable f μ
-- Mathlib/Topology/Algebra/Order/Floor.lean
/-- Do not use this, use `ContinuousOn.comp_fract` instead. -/
theorem ContinuousOn.comp_fract' {f : β → α → γ} (h : ContinuousOn (uncurry f) <| univ ×ˢ I)
    (hf : ∀ s, f s 0 = f s 1) : Continuous fun st : β × α => f st.1 (fract st.2)
-- Mathlib/Topology/Category/Profinite/Limits.lean
lemma finiteCoproduct.ι_jointly_surjective (R : finiteCoproduct X) :
    ∃ (a : α) (r : X a), R = finiteCoproduct.ι X a r
-- Mathlib/Topology/Order/Basic.lean
theorem dense_of_exists_between [OrderTopology α] [Nontrivial α] {s : Set α}
    (h : ∀ ⦃a b⦄, a < b → ∃ c ∈ s, a < c ∧ c < b) : Dense s
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
/-- The complex exponential is everywhere differentiable, with the derivative `exp x`. -/
theorem hasDerivAt_exp (x : ℂ) : HasDerivAt exp (exp x) x
-- Mathlib/Data/Complex/ExponentialBounds.lean
theorem log_two_gt_d9 : 0.6931471803 < log 2
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp] lemma disjoint_fromEdgeSet : Disjoint G (fromEdgeSet s) ↔ Disjoint G.edgeSet s
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem mem_support (x : HahnSeries Γ R) (a : Γ) : a ∈ x.support ↔ x.coeff a ≠ 0
-- Mathlib/Data/ENNReal/Operations.lean
theorem sub_ne_top (ha : a ≠ ∞) : a - b ≠ ∞
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle