Skip to content

La suite $(B_n)_{n in Bbb{N}}$ est-elle non bornée, où $B_n := sum_{k=1}^nmathrm{sgn}(sin(k))$ ?

Ce tutoriel a été analysé par nos spécialistes afin que vous puissiez être sûr de l'exactitude de notre avis.

Solution :

Cette suite est non bornée et ce résultat s'étend à toute période irrationnelle, bien que je n'écrive explicitement que le cas demandé.

Définir $f(x)=operatorname{sgn}(sin(x))$.. Définissons également $$g_n(x)=f(x)+f(x+1)+f(x+2)+ldots+f(x+n-1).$$ La question est de savoir si la séquence $g_0(0), g_1(0), g_2(0), ldots$ est non bornée.

Lemme : La séquence $g_0(0), g_1(0), g_2(0), ldots$ est bornée si et seulement si la suite de fonctions $g_0, g_1, g_2, ldots$ est uniformément bornée.

Preuve : Observez que puisque $g_n(x)$ est une somme de fonctions qui sont continues à l'exception de certaines discontinuités de saut et qu'il n'y a pas deux discontinuités de saut dans les sommandes qui s'alignent, elle est aussi continue à l'exception des discontinuités de saut de la somme - formellement, on peut dire que pour tout $x$ il existe un certain $varepsilon tel que si $|x'-x| <{varepsilon$} alors $|g_n(x')-g_n(x)| leq 1$. Notez également que $g_n(x)+g_m(x+n)=g_{n+m}(x)$ et que les entiers sont denses mod $2pi$. La combinaison de ces faits nous indique que si $|g_n(x)|$ est toujours au moins $C$ alors $|g_n(k)|$ est au moins $C-1$ pour un nombre entier $k$ et donc $g_k(0) + g_n(k) = g_{n+k}(0)$ ce qui implique que soit $|g_k(0)|$ soit $|g_{n+k}(0)|$ est au moins $frac{C-1}2$. Par conséquent, en montrant que $g_n$ n'est pas uniformément bornée impliquerait que la suite initiale n'est pas bornée non plus.

Nous nous attachons donc à montrer que la séquence $g_n$ n'est pas uniformément bornée. Pour ce faire, nous calculons quelques coefficients de Fourier. Pour les entiers impairs $a$ on a
$$int_{0}^{2pi}f(x)e^{iax},dx=frac{4i}a$$
et de là, nous pouvons dériver
$$int_{0}^{2pi}g_n(x)e^{iax},dx=frac{4i}acdot (1 + e^{-ia}+e^{-2ia}+e^{-3ia}+ldots+e^{-(n-1)ia}).$$

Pour un $a$ n'est pas un multiple rationnel de $pi$, la somme supérieure des sommes $|sum_{k=0}^{n-1}e^{-kia}|$ sur $n$ est $frac{2}{|1-e^{-ia}|}$ en utilisant la formule habituelle des sommes géométriques. Observez que $|1-e^{-ia}|$ est asymptotique à la distance de $a$ au multiple le plus proche de $2pi$ (au moins lorsque cette quantité est petite).

Nous arrivons alors à une question sur l'approximation qui est frustrante et proche de ce dont nous avons besoin : pour tout $varepsilon>0$, existe-t-il une valeur impaire $a$ telle que $a$ est compris dans $frac{varepsilon}a$ d'un multiple de $2pi$? Bien que le théorème d'approximation de Dirichlet (ou le théorème de Hurwitz) puisse être utilisé en conjonction avec la connaissance que les convergents consécutifs d'une fraction continue ont des dénominateurs copremiers pour montrer qu'une infinité de tels impairs... $a$ existent pour un nombre fixe de $varepsilon$ nous ne pouvons pas dire quoi que ce soit sur tous les choix possibles de ${varepsilon$} - bien qu'un peu de théorie ergodique montre que notre affirmation souhaitée est vraie pour presque tous les irrationnels. Pour atteindre notre objectif en général (et sans chercher à parler d'approximation de la valeur de mieux que les nombres irrationnels génériques), nous devons donc regarder plusieurs coefficients de Fourier à la fois.

Pour commencer, notons que les convergents $frac{p}q$ de la fraction continue vers $frac{1}{2pi}$ ont que $|p-{frac{1}{2pi}q| < frac{1}q$ en combinant le théorème d'approximation de Dirichlet avec le fait de savoir que les convergents minimisent la quantité du côté gauche sur tous les plus petits. $q$ . Il doit y avoir une infinité de convergents avec un dénominateur impair, puisque les dénominateurs des convergents consécutifs sont copremiers. En supprimant les constantes, on peut alors dire que pour certains $c$
, il doit exister une infinité de convergents impairs $a$ tels que $frac{1}{|1-e^{-ia}|} > ac$.

La formule habituelle des séries géométriques nous dit que
$$1+e^{-ia}+e^{-2ia}+ldots + e^{-(n-1)ia} = frac{1 - e^{-nia}}{1-e^{-ia}}.$$ Nous allons utiliser ceci pour montrer que certains $g_n$ ont de nombreux coefficients de Fourier de taille au moins égale à 1. $c$ ce qui nécessite de choisir des entiers impairs est que 1-e^{-ia}$ soit petit, puis de sélectionner $n$ de telle sorte que $e^{-nia}$ est proche $-1$ pour tous les sélectionnés $a$.

Lemma : Pour tout ensemble fini $a_1,ldots,a_k$ d'entiers impairs et tout $varepsilon$ il existe un certain $n$ telle que 1+e^{-nia_k}| < varepsilon$. pour tout $k$.

Preuve : Par un argument sur les approximations similaire à celui utilisé précédemment, on peut trouver un entier $n$ qui est arbitrairement proche d'un multiple impair de $pi$ . Notons que si un nombre réel $r$ est compris dans $varepsilon$ d'un multiple impair de ${pi$} alors, pour tout nombre entier impair $a$ , la valeur $ar$ est comprise dans $avarepsilon$ d'un multiple impair de ${pi$} . Puisque le $a_k$ sont fixes et finis, on peut, en choisissant $n$ suffisamment proche d'un multiple impair de $pi$ s'assurer que toutes les valeurs $na_k$ sont arbitrairement proches des multiples impairs de $pi$ . Le lemme s'ensuit immédiatement.

Pour finir, on peut, pour tout $k$ , sélectionner $k$ valeurs $a_1,ldots,a_k$ telles que $frac{1}{|1-e^{-ia_k}|} > a_kc$ . En utilisant le lemme, nous pouvons alors choisir $n$ de telle sorte que $|1-e^{-ina_k}| > 1$ pour tout $k$ . Les quotients $frac{1-e^{-ina_k}}{1-e^{-ia_k}}$ ont alors tous une valeur absolue au moins égale à $a_kc$ et donc $a_k^{th}$ Coefficients de Fourier de $g_n$ sont tous au moins $frac{4c}{pi}$. en valeur absolue. Puisqu'il existe $g_n$ avec un nombre arbitraire de coefficients de Fourier supérieurs à une certaine borne inférieure fixée, la suite $g_n$ n'est pas bornée en $L^2$ et n'est donc pas uniformément bornée. En appliquant le premier lemme, on trouve que la suite $g_0(0), g_1(0), g_2(0), ldots$ n'est pas bornée. Cette preuve s'étend à toutes les périodes irrationnelles avec une modification mineure.

Pas de réponse.

Cette question est follement délicate. Laissez-moi vous expliquer ce qui se passe.

La séquence $s : =(operatorname{sgn}(sin(n)))_{n=1}^infty$ est généralement périodique avec une période $+,+,+,-,-,-$ sauf que parfois on a quatre plus ou quatre moins. Soit H(N) := #{n le N : {frac{n}{2pi}} in (0,frac{1}{2}-frac{3}{2pi})}$ et $S(N) := #{n le N : {frac{n}{2pi}} in (frac{1}{2},1-frac{3}{2pi})}$ . Les moments où $s$ a quatre plus dans une rangée est exactement quand n est dans H(N)$. ($s$ a un plus à n, n+1, n+2, n+3... ), et les moments où $s$ a quatre moins d'affilée, c'est exactement quand n est dans S(N)$. ($s$ a un moins à $n, n+1, n+2, n+3$.).

Par conséquent, $sum_{n le N} N-operatorname{sgn}(sin(n)) = H(N)-S(N)+O(1)$ , où la $O(1)$ Le terme vient juste $N$ étant au milieu d'une "période" de $+,+,+,-,-,-$. En termes de bornage, nous pouvons ignorer la période de $O(1)$ et déterminer si $H(N)-S(N)$ est non borné.

Formez une séquence $t$ de $+$ et $-$ en commençant par $n=1$ , en augmentant $n$, mettre un $+$ si $n$ se trouve dans H(N)$ et en mettant un $-$ si $n$ se trouve dans S(N)$. Alors $t$ alterne entre $+$ et $-$ sauf que parfois il y a deux $+$ dans une rangée, et parfois il y a deux $-$. $-$ dans une rangée. Et en général, on alterne lequel des $+$ ou $-$ apparaît deux fois dans une rangée. La raison pour laquelle $+$ et $-$ alternent généralement est que si $n in H(N)$ alors cela signifie généralement que n+22 $ in S(N)$ et si $n in S(N)$ alors cela signifie généralement que n+22 in H(N)$.

Rigoureusement, il existe une bijection entre l'ensemble de $n$ avec ${frac{n}{2pi}} in left(0,frac{pi-3}{2pi}-({frac{22}{2pi}}-frac{1}{2})right)$ et l'ensemble $n$ avec ${frac{n}{2pi}} in left(frac{1}{2}+({frac{22}{2pi}}-frac{1}{2}),frac{1}{2}+frac{pi-3}{2pi}right)$. Par conséquent, si nous laissons $H'(N) = #{n le N : {frac{n}{2pi}} in left(frac{pi-3}{2pi}-({frac{22}{2pi}}-frac{1}{2}),frac{pi-3}{2pi}right)}$ et S'(N) = N : {frac{n}{2pi}\} in left(frac{1}{2},frac{1}{2}+({frac{22}{2pi}}-frac{1}{2})right)}$ alors $H(N)-S(N) = H'(N)-S'(N)+O(1)$ , où le $O(1)$ est pour le même type de raison que précédemment (la bijection mentionnée pourrait être éloignée d'une bijection par $1$ en raison de la restriction à $n le N$).

Par conséquent, il nous suffit de déterminer si $H'(N)-S'(N)$ est non borné. L'association $+,-$ associé est maintenant périodique avec une période $-,+,+,-,+,+,-,+,+,-,-,+,-,-,+,-,-,+,-,-,+,+$ à l'exception de quelques défauts. Il faut donc étudier les défauts.

Le point de tout ceci est que si $sum_{n le N}text{sgn}(sin(n))$ est bornée ou non bornée est en fait déterminé par tous ces éléments $O(1)$ s'additionnent, puisqu'on va continuer à rencontrer des séquences quasi périodiques. [I hope my point is clear; there is something subtle going on. Even though the $O(1)$ terms don't matter individually (e.g. whether $sum_{n le N} text{sgn}(sin(n))$ is bounded is equivalent to whether $H(N)-S(N)$ is bounded even though they differ by a $O(1)$ term), they matter when added together].

J'ai l'impression que tout cela est lié à l'expansion de la fraction continue de... $pi$ . J'y réfléchirai plus tard.

Pas de réponse. Lorsqu'on m'a demandé dans les commentaires de deviner si les sommes partielles sont bornées ou non bornées, j'ai répondu : " Unbounded for all irrational ". $alpha > 1,$ mais que est seulement une supposition (même pas une supposition éclairée - je suis assez nouveau dans ce domaine)."

Mes propres notes sur le problème sont reproduites à la fin de ce commentaire/réponse. (Des événements troublants dans Maths.SE m'ont empêché de faire avancer mon travail, dans les deux jours qui ont suivi l'éclatement de la dispute. Autre hypothèse : je ne pense pas qu'il y ait jamais eu beaucoup de chances que mon travail aboutisse à une solution. Cependant, je pense que ma notation, et les quelques inégalités que j'ai prouvées, peuvent être utiles à d'autres ainsi qu'à moi-même, bien que mes preuves soient presque certainement stupidement compliquées. J'ai l'intention de mettre à jour cette réponse, avec des preuves améliorées si possible, si on m'autorise à me concentrer à nouveau).

Ce commentaire/réponse, pour ce qu'il vaut, consiste en quelques données, et maintenant aussi le code Python qui les a produites, suivies d'une explication de l'algorithme assemblée à la hâte, basée sur mes notes privées (qui, comme je le dis, peuvent avoir une certaine valeur indépendante de l'algorithme) :
$$
begin{array}{|r|r|}
hline
B_n(pi) & n
hline
{-1} & 25
{-2} & 358
{-3} & 104{,}351
{4} & 312{,}692
{5} & 625{,}381
{6} & 938{,}070
{-4} & 2{,}084{,}478
{-5} & 6{,}357{,}421
{-6} & 86{,}501{,}278
{-7} & 166{,}645{,}135
{7} & 412{,}496{,}057
{8} & 824{,}054{,}044
{9} & 1{,}235{,}612{,}031
{10} & 1{,}647{,}170{,}018
{11} & 2{,}058{,}728{,}005
{12} & 2{,}470{,}285{,}992
{-8} & 7{,}986{,}246{,}888
{-9} & 8{,}066{,}390{,}745
{-10} & 18{,}515{,}628{,}134
{-11} & 36{,}864{,}611{,}133
hline
end{array}
Quad
begin{array}{|r|r|}
hline
B_n(sqrt{10}) & n N
hline
{4} & 22
{5} & 41
{6} & 60
{7} & 79
{8} & 98
{9} & 117
{10} & 838
{11} & 1{,}559
{12} & 2{,}280
{13} & 3{,}001
{14} & 3{,}722
{15} & 4{,}443
{16} & 31{,}822
{17} & 59{,}201
{18} & 86{,}580
{19} & 113{,}959
{20} & 141{,}338
{21} & 168{,}717
{22} & 1{,}208{,}398
{23} & 2{,}248{,}079
hline
end{array}

begin{array}{c}
begin{array}{|r|r|}
hline
B_n(sqrt{10}) & n N
hline
{24} & 3{,}287{,}760
{25} & 4{,}327{,}441
{26} & 5{,}367{,}122
{27} & 6{,}406{,}803
{28} & 45{,}887{,}302
{29} & 85{,}367{,}801
{30} & 124{,}848{,}300
{31} & 164{,}328{,}799
{32} & 203{,}809{,}298
{33} & 243{,}289{,}797
{34} & 1{,}255{,}929{,}484
{35} & 2{,}268{,}569{,}171
{36} & 9{,}357{,}046{,}980
{37} & 10{,}856{,}266{,}261
{38} & 12{,}355{,}485{,}542
hline
end{array}

mathstrut
mathstrut
mathstrut
mathstrut
mathstrut
end{array}
$$

Je suis désolé pour le mauvais formatage. Je vais essayer de l'améliorer dans les prochaines mises à jour. Comme je l'ai écrit dans un autre commentaire : " La dernière mise à jour a été retardée, car le formatage de mes nouveaux tableaux utilise beaucoup de... framebox et je viens juste de découvrir (à la dure) qu'elles ne sont pas supportées par MathJax.
par MathJax."

Les calculs utilisés $100$ chiffres décimaux de précision. Je n'ai pas vérifié rigoureusement les erreurs possibles dans les données de $2{,}000{,}000{,}000$ itérations pour $B_n(pi),$ ou $680{,}000{,}000$ itérations pour B_n(sqrt{10}),$ chaque itération nécessitant l'arrondi d'un nombre réel à un nombre entier. J'ai l'intention d'ajouter de telles vérifications plus tard.

Pas de commentaire $ldots ddotfrown$

J'avais prévu de travailler beaucoup plus sur cette réponse aujourd'hui, en suivant plusieurs pistes indépendantes à la fois, mais $[ldots]$!

Je vais simplement poster le code Python 3 non poli que j'ai utilisé pour générer le tableau, avec des instructions pour l'exécuter. (Ne vous inquiétez pas, c'est facile.) Ce dont il a probablement le plus besoin est l'inclusion de tests pour les arrondis inexacts à une valeur entière. (Il devrait lever une exception si cela se produit.) Ce qui n'est pas satisfaisant non plus, c'est qu'il ne traite que le calcul de $B_n(alpha)$ pour les irrationnels $alpha$ tels que m < alpha < m + tfrac12$ pour un certain nombre d'entiers positifs $m.$ Les formules pour le cas m.$ + tfrac12 < alpha <1>$ sont presque identiques. J'avais prévu de les coder également en Python avant de mettre à jour ma réponse. (Oh, bon.)

Il serait seulement légèrement plus compliqué d'écrire un code qui gère tous les irrationnels. $alpha > 1$ de manière uniforme, mais je ne pense pas qu'il y ait un intérêt à le faire, comme je vais essayer de l'expliquer. $[ldots]$

Tout en expliquant le code, je vais présenter les formules que j'ai utilisées, avec des preuves. Je dois serrer les dents pour le faire, car mes preuves ont été obtenues d'une manière follement détournée, et portent probablement encore des traces de leur origine, même s'il y a presque forcément une simplification "évidente". C'était une autre des nombreuses aspects du problème sur lesquels j'avais prévu de travailler aujourd'hui. (Oh, bien.)

Dans un futur jour plus heureux, peut-être pourrons-nous mettre nos têtes ensemble, et en plus de simplifier mes preuves stupides (si je n'ai pas réussi à le faire moi-même), nous pourrions décider d'une notation commune à utiliser pour communiquer sur le problème. Mais d'abord, je dois présenter ma propre notation. C'est une tâche suffisamment importante pour une fois, sans la compliquer avec des tentatives prématurées de collaboration. (C'est l'une des nombreuses bonnes raisons pour lesquelles ce n'est pas un post sur le Wiki communautaire). $[ldots]$

Quoi qu'il en soit, je dois faire une pause pour le dîner maintenant. Voici le code non poli de mon module Python, que j'ai exécuté sous la version 3.8.1 (64 bits), non pas que cela doive avoir beaucoup d'importance. $[ldots]$

Le code peut probablement être accéléré considérablement en installant gmpy2, mais cela dépend de l'installation préalable de Microsoft Visual C++ 14.0. (Vous l'avez deviné, c'était une autre des nombreuses, nombreuses choses que j'avais prévu de faire aujourd'hui...). $[ldots]$ ) Oui, j'aurais dû mentionner que j'utilise une machine Windows. Pour fonctionner sous Linux ou un autre système d'exploitation de type Unix (peut-être n'importe quoi d'autre que Windows), vous devrez ajouter une sorte de chose "shebang" au début (mais vous saurez ce qu'il faut faire, et moi pas).

Mise à jour 1

# WorkCompPython3Libmathsspinoff.py
#
# Thu 25 Jun 2020  (created)
# Mon 29 Jun 2020  (updated)
# Thu  2 Ju1 2020  (trivial update)

"""Almost alternating: https://math.stackexchange.com/q/3731454.

Now see also this: https://math.stackexchange.com/q/3737600."""

__all__ = ['state']

from math import floor, ceil
from mpmath import mp

class state(object):
    # Mon 29 Jun 2020  (created)
    # Thu  2 Ju1 2020  (trivial update)
    """
    Place in list of possibly extreme sums of (-1)^k: k in Beatty sequence.
    """

    def __init__(self, j=0, B_n=0, maxB=0, minB=0, alpha=mp.pi):
        # Mon 29 Jun 2020  (created)
        # Mon 29 Jun 2020  (updated)
        """
        Initialise state from parameters (copied and pasted from previous run).
        """
        self.m = floor(alpha)
        if alpha == self.m or alpha < 1:
            raise ValueError
        self.beta = 1/(alpha - self.m) - 1
        if self.beta == floor(self.beta) or self.beta < 1:
            raise ValueError
        self.alpha = alpha
        self.B_n = B_n
        self.maxB = maxB
        self.minB = minB
        self.j = j
        self.sj = ceil(self.j*self.beta)
        self.n = self.sj*self.m + self.j*(self.m + 1)
        self.k = floor(self.n/alpha)
        self.sgn = 1 - 2*(self.k % 2)  # = (-1)**k
        self.record = []  # list of new record-breaking tuples (B_n, n, k, j)

    def readout(self):
        # Mon 29 Jun 2020  (created)
        # Mon 29 Jun 2020  (updated)
        """
        Read out the present state of the computation.
        """
        return (self.j, self.B_n, self.maxB, self.minB, self.alpha)

    def advance(self, loops=40000000):
        # Mon 29 Jun 2020  (created)
        # Thu  2 Ju1 2020  (trivial update)
        """
        Increment the value of j the given number of times.
        """
        old_j = self.j
        for self.j in range(old_j + 1, old_j + loops + 1):
            old_sj = self.sj  # = ceil((j-1)*beta)
            self.sj = ceil(self.j*self.beta)
            p = self.sj - old_sj
            self.n += p*self.m
            self.k += p
            if p % 2:  # p is odd
                self.B_n += self.sgn*self.m
                self.sgn = -self.sgn
            self.n += self.m + 1
            self.k += 1
            self.B_n += self.sgn*(self.m + 1)
            self.sgn = -self.sgn
            if self.B_n > self.maxB:
                self.record.append((self.B_n, self.n, self.k, self.j))
                self.maxB = self.B_n
            if self.B_n < self.minB:
                self.record.append((self.B_n, self.n, self.k, self.j))
                self.minB = self.B_n

def main():
    mp.dps = 100
    dat = state()
    dat.advance(1000000)
    print(dat.readout())
    print(dat.record)

if __name__ == '__main__':
    main()

# end spinoff.py

Le début du journal de la session interactive (en utilisant IDLE) qui a
a produit la table pour B_n(sqrt{10})$. devrait donner une idée suffisante
de la façon d'exécuter le programme (merci de poster toute difficulté ou rapport de bogue
en tant que commentaires sur cette réponse) :

Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 23:11:46) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> from maths import spinoff
>>> from mpmath import mp
>>> mp.dps = 100
>>> a = mp.sqrt(10)
>>> a
mpf('3.162277660168379331998893544432718533719555139325216826857504852792594438639238221344248108379300295183')
>>> a**2
mpf('10.0')
>>> dat = spinoff.state(0, 0, 0, 0, a)
>>> dat.readout()
(0, 0, 0, 0, mpf('3.162277660168379331998893544432718533719555139325216826857504852792594438639238221344248108379300295183'))
>>> dat.record
[]
>>> dat.advance(10000000)
>>> dat.readout()
(10000000, 19, 31, 0, mpf('3.162277660168379331998893544432718533719555139325216826857504852792594438639238221344248108379300295183'))
>>> dat.record
[(4, 22, 7, 1), (5, 41, 13, 2), (6, 60, 19, 3), (7, 79, 25, 4), (8, 98, 31, 5), (9, 117, 37, 6), (10, 838, 265, 43), (11, 1559, 493, 80), (12, 2280, 721, 117), (13, 3001, 949, 154), (14, 3722, 1177, 191), (15, 4443, 1405, 228), (16, 31822, 10063, 1633), (17, 59201, 18721, 3038), (18, 86580, 27379, 4443), (19, 113959, 36037, 5848), (20, 141338, 44695, 7253), (21, 168717, 53353, 8658), (22, 1208398, 382129, 62011), (23, 2248079, 710905, 115364), (24, 3287760, 1039681, 168717), (25, 4327441, 1368457, 222070), (26, 5367122, 1697233, 275423), (27, 6406803, 2026009, 328776), (28, 45887302, 14510839, 2354785), (29, 85367801, 26995669, 4380794), (30, 124848300, 39480499, 6406803), (31, 164328799, 51965329, 8432812)]
>>> from math import floor
>>> def sgn(n):
    return 1 - 2*(n % 2)  # = (-1)**n

>>> def B(n):
    return sum([sgn(floor(i/a)) for i in range(1, n+1)])

>>> [B(n) for n in range(100)]
[0, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 0, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 5, 4, 3, 2, 3, 4, 5, 4, 3, 2, 3, 4, 5, 4, 3, 2, 3, 4, 5, 6, 5, 4, 3, 4, 5, 6, 5, 4, 3, 4, 5, 6, 5, 4, 3, 4, 5, 6, 7, 6, 5, 4, 5, 6, 7, 6, 5, 4, 5, 6, 7, 6, 5, 4, 5, 6, 7, 8, 7]
>>> [B(n) for n in [22, 41, 60, 79, 98, 117, 838, 1559, 2280, 3001, 3722, 4443, 31822]]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
>>> # So far, so good.
>>> B(113959)
19
>>> B(1208398)
22
>>> B(6406803)
27
>>> B(45887302)
28
>>> # Still OK.  I think that's enough checking.

D'après un autre commentaire :

N.B. Il existe un bogue dans mon code Python qui
peut causer des résultats bizarres si vous initialisez un objet avec des paramètres non
par défaut afin de reprendre un calcul à partir d'un état précédemment atteint.
précédemment atteint. C'est probablement facile à corriger, mais je n'y ai pas encore réfléchi.
J'ai étendu la table pour $B_n(pi),$ et construit une table pour
$B_n(sqrt{10}).$ Ce serait bien de coder le $q_j$ version des formules,
pour que je puisse faire $B_n(e),$ et peut-être $B_n(sqrt8),$ mais je ferais mieux de corriger
le $p_j$ d'abord. Une bonne surprise a été que le calcul avec $100$
chiffres de précision semble presque aussi rapide qu'avec $50.$

Mise à jour 2

Il s'agit d'un dump légèrement édité de quelques $LaTeX{}$
ed notes que j'ai écrites, pour mon usage privé, depuis le jeudi 25 juin. (Il y a aussi des notes manuscrites, à partir du mardi 23, dont certaines n'ont pas encore été... $LaTeX{}$ éditées. Elles comblent une ou deux lacunes laissées ici, mais pas beaucoup).

Il est nécessaire de donner ce contexte, car ces notes n'ont pas été écrites pour être "publiées", et mes arguments suivent un parcours sinueux, menant à des conclusions simples qui doivent presque sûrement être "évidentes", ne serait-ce qu'avec du recul. Aussi, il n'y a rien d'étonnant à ce quee; c'est très laborieux ! Mais sans elle, le code de mon module Python se lira comme, eh bien, co....de; et pour des raisons que je ne vais pas détailler maintenant - elles sont dans l'historique des modifications, et dans des dizaines de commentaires, pour la plupart maintenant supprimés, et dans un fil de discussion Meta (que je ne suis pas pour le moment, afin de pouvoir me concentrer sur ce travail) - j'ai été virtuellement obligé de larguer tout mon code Python non poli ici, et je suis maintenant confronté à devoir l'expliquer du mieux que je peux. J'espère que la notation que j'utilise, au moins, sera également d'une certaine utilité pour les autres.

$Nouvelle commande{floor}[1]{leftlfloor#1rightrfloor}
N- nouvelle commande{rfloor}[1]{leftlceil#1rceil}$
Étant donné un nombre irrationnel $alpha > 1,$ on s'intéresse à la
séquence de Beatty d'entiers non négatifs
$(floor{n/alpha})_{ngeqslant1}.$ Pour chaque
entier non négatif $k,$
laissez $r_k$ soit le nombre de fois $k$ dans la séquence de Beatty pour $1/alpha.$ Ensuite, $r_k$ est toujours
$m$ ou $m + 1,$ et en particulier $r_0 = m,$
m = floor{alpha},$
c'est-à-dire $m$ est l'unique entier positif tel que
$$
m < alpha < m + 1. $$
Pour chaque nombre entier positif $j,$ laissez $p_j$ soit la longueur de la
$j^text{th}$ groupe de valeurs consécutives de $k$ pour lesquelles
r_k = m,$
et laissons $q_j$ est la longueur de la $j^text{th}$ groupe de valeurs consécutives de $k$ pour lesquelles $r_k = m + 1.$

Pour tout entier positif $j,$begin{gather}
notag
[(p_1 + cdots + p_j)m + (q_1 + cdots + q_{j-1})(m + 1) + 1]
/alpha > p_1 + q_1 + cdots + q_{j-1} + p_j,
notag\N- Texte{et}N- L'histoire d'un homme.
[(p_1 + cdots + p_j)m + (q_1 + cdots + q_{j-1} + 1)(m + 1)]
/alpha < p_1 + q_1 + cdots + q_{j-1} + p_j + 1, Donc... m + frac{q_1 + cdots + q_{j-1} + 1} {p_1 + q_1 + cdots + q_{j-1} + p_j + 1} < alpha < m + frac{q_1 + cdots + q_{j-1} + 1} {p_1 + q_1 + cdots + q_{j-1} + p_j}, N notagtext{i.e.} 1 + frac{p_1 + cdots + p_j - 1}{q_1 + cdots + q_{j-1} + 1} < frac1{{alpha - m}<1>+ frac{p_1 + cdots + p_j}{q_1 + cdots + q_{j-1} + 1},
notagtext{i.e.}
p_j < (q_1 + cdots + q_{j-1} + 1)left(frac1{alpha - m} - 1right) - p_1 - cdots - p_{j-1} + 1 < p_j + 1, N label{3731454:eq:P}tag{P} text{i.e. }N{i} p_j = ceil{(q_1 + cdots + q_{j-1} + 1)left(frac1 {alpha - m} - 1right)} - p_1 - cdots - p_{j-1}. end{gather}

De même,
begin{gather}
notag
[(p_1 + cdots + p_j)m + (q_1 + cdots + q_j)(m + 1)]/alpha < p_1 + q_1 + cdots + p_j + q_j, \ notagtext{and } [(p_1 + cdots + p_j)m + (q_1 + cdots + q_j + 1)(m + 1)]/alpha \ notag > p_1 + q_1 + cdots + p_j + q_j + 1, N
NNotagN{donc} texte{donc}
m + frac{q_1 + cdots + q_j}
{p_1 + q_1 + cdots + p_j + q_j} < alpha < m + frac{q_1 + cdots + q_j + 1} {p_1 + q_1 + cdots + p_j + q_j + 1}, N notagtext{i.e. } 1 + frac{p_1 + cdots + p_j}{q_1 + cdots + q_j + 1} < frac1{{alpha - m}<1>+ frac{p_1 + cdots + p_j}{q_1 + cdots + q_j}, N
notagtext{i.e. }{i}
q_j < (p_1 + cdots + p_j)gauche( frac1{alpha - m} - 1right)^{-1} ! ! - q_1 - cdots - q_{j-1} < q_j + 1, N label{3731454:eq:Q}tag{Q} text{i.e. }N{i} q_j = floor{(p_1 + cdots + p_j)left( frac1{alpha - m} - 1right)^{-1}} - q_1 - cdots - q_{j-1}. end{cdots}

Si $m alors $2m+2$ multiples successifs de $1/alpha$ occupent
un intervalle fermé de longueur $(2m+1)/alpha>2,$ donc $q_j=1$ pour tous $j.$

De même, si m + tfrac12 < alpha < m + 1,$ alors $2m + 2$ multiples successifs
de $1/alpha$ occupent un intervalle fermé de longueur $(2m + 1)/alpha <2>,$
donc
$p_j=1$
pour tous $j.$

(C'est pourquoi il semble peu utile d'écrire du code Python pour traiter les deux cas de manière uniforme, surtout au vu de ce qui va suivre).

Définir
$$
beta = frac1{alpha - m} - 1,
$$

de sorte que
begin{align*}
beta > 1 & text{ si } m < alpha < m + frac12 , beta <1>& text{ if } m + frac12 < alpha < m + 1. end{align*}
Alors
begin{align*}
text{si} m < alpha < m + frac12 text{alors} p_j & = ceil{jbeta} - p_1 - cdots - p_{j-1}, N text{if } m + frac12 < alpha < m + 1 text{ then } q_j & = floor{frac{j}{beta}} - q_1 - cdots - q_{j-1}, end{align*}
et il est maintenant évident, par induction sur $j$ (Je suis sûr que ça devrait être évident
sans ces palabres, mais je n'ai pas eu l'occasion d'y réfléchir davantage
aujourd'hui), que
begin{align*}
text{if } m < alpha < m + frac12 text{ alors } p_j & = ceil{jbeta} - ceil{(j - 1)beta}, text{if } m + frac12 < alpha < m + 1 text{ then } q_j & = floor{frac{j}{beta}} - floor{frac{j - 1}{beta}}, end{align*}

(Par une étonnante synchronicité, cette
question est apparue le samedi 27 juin, juste avant que je commence à écrire des choses de cette
de cette manière, mais j'étais si bête que le centime n'est pas tombé avant un jour environ).

L'équation pour $p_j$ a été vérifiée de manière assez approfondie, mais je n'ai pas fait grand chose
avec l'équation pour $q_j,$
donc je la considère avec (encore plus) de suspicion (sauf si, c'est-à-dire que
que ces deux équations soient encore plus évidentes que je ne l'imagine).

Notez les implications que
begin{align*}
text{si } m < alpha < m + frac12 text{ alors } p_j & = ceil{beta} text{i} ou } floor{beta} text{ pour tout } j, N text{si } m + frac12 < alpha < m + 1 text{ alors } q_j & = floor{frac1{beta}} text{ or } ceil{frac1{beta}} text{ pour tout } j. end{align*}

Supposons à partir de maintenant que m < alpha < m + frac12.$
(Ceci est, bien sûr, simplement
parce que je voulais me mettre à écrire du code Python pour calculer $B_n(pi).$
Il n'est pas question de suggérer que l'autre cas ne présente pas le même intérêt).

Dans une notation provisoire, laissons
$$
s(j) = p_1 + cdots + p_j = ceil{jbeta} quad (j geqslant 1).
$$

Dans une notation peut-être peu judicieuse (mais je devrais avoir... quelque notation pour cela), laissons
$$
l(n) = floor{frac{n}alpha} quad (n geqslant 1)
$$
(J'ai changé ça immédiatement !), et bien sûr
$$
B_n = B_n(alpha) = sum_{i=1}^n(-1)^{l(i)} quad (n geqslant 1).
$$
Cela semble presque "évident" maintenant (et je l'imagine devrait être assez facile à prouver)
que les valeurs cruciales de $n,$
les seules pour lesquelles $B_n$
peuvent prendre de nouvelles
valeurs maximales ou minimales, sont
$$
t(j) = s(j)m + j(m + 1) quad (j geqslant 1).
$$
On devrait avoir
$$
l(t(j) - m) = l(t(j) - m + 1) = cdots = l(t(j) - 1) = l(t(j))
quad (j geqslant 1).
$$
(Je pense que je avoir fait prouver tout cela, mais seulement dans mes notes manuscrites. L'horrible
controverse dans Maths.SE a éclaté, je pense, le lendemain matin de la nuit où je
étais arrivé à ce point, et commencé à faire des calculs systématiques, donc je n'ai pas eu
le temps de travailler correctement sur tout cela. Mais je vais mettre à jour cette réponse).



Utilisez notre moteur de recherche

Ricerca
Generic filters

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.