Merci pour le message, l'article est intéressant.
Une remarque sur 0 : tous les nombres positifs à un chiffre sont des successeurs de 0 qui est leur unique prédécesseur.

La question que tu poses me semble difficile.

En effet, 0 est l'unique prédécesseur de tous les chiffres de 0 à 9.

Il y a moyen de montrer (c'est fait dans l'article) qu'il y a un nombre limité de nombre positifs qui n'ont pas de prédécesseur.  Si on peut étendre cela aux nombres négatif et tenant compte que la différence entre deux nombres dans une séquence est entre 0 et 100, on pourrait montrer que le nombre de graphes est limité.

D'après mes expériences, tous les nombres négatifs ont exactement un prédécesseur. Donc le nombre de graphes disjoints devrait être inférieur à 100.

Il me semble, mais j'ai un peu de fièvre ce qui rend mes résultats douteux, que tous les nombres strictement négatifs ont un unique prédécesseur et un unique successeur.
Ça supprime des nombres sans prédécesseur de la liste, mais il reste tous les nombres de la forme c*10^k où c est un chiffre entre 2 et 9 (théorème 5.4). Il faudrait démontrer que, parmi leurs nombreux successeurs, certains rejoignent un autre chemin.

Je suis d'accord avec toi, les nombres négatifs ont un unique prédécesseur et un unique successeur. Il faudrait le prouver

0 est spécial car il boucle sur lui-même et est le seul à avoir plus de 2 successeurs.

Pour les nombres de la forme c*10^k, j'ai mal utilisé mes termes. Dans l'article un successeur est le plus petit des enfants (child), ici j'appelle tous les enfants successeurs. Il faut donc regarder le théorème 5.5. Où il n'y a que 50 nombres sans parent (sans prédécesseur). On peut réduire cette liste car j'ai étendu la définition aux nombres négatifs et 0.

En effet j'ai mal lu.
Et la liste des nombres sans parent est considérablement réduite, mais pas vidée.

Une démonstration pour : un nombre négatif a un unique parent.
Soit avec et un chiffre non nul
On cherche un nombre tel que et un chiffre.
L'égalité se réécrit facilement
On en déduit
D'où
Comme il y a une possibilité unique pour et donc pour .
CQFD

Cette preuve s'adapte aux enfants, mais il me reste quelques détails à régler quand on change le nombre de chiffres et quand l'enfant est positif.

Finalement ça ne marche pas bien :
— il y a des négatifs qui n'ont pas d'enfants  -11 ; -33 ; -55  ; -77 et -99
— il y a des négatifs qui ont deux enfants -2 ; -3 ; -4 ; -5 ; -6 ; -7 ; -8 et -9.

En effet j'ai dû faire une erreur dans mon code. En le réécrivant, je n'ai plus le même résultat

Il y a exactement 20 nombres sans prédécesseur et ils sont tous positifs:

 Cliquez pour afficher

21 []
31 []
32 []
41 []
42 []
43 []
51 []
52 []
53 []
54 []
62 []
63 []
64 []
65 []
74 []
75 []
76 []
86 []
87 []
98 []

 Cliquez pour afficher

12 [1, -79]
23 [11, -69]
24 [2, -58]
34 [21, -59]
35 [12, -48]
36 [3, -37]
45 [31, -49]
46 [22, -38]
47 [13, -27]
48 [4, -16]
56 [41, -39]
57 [32, -28]
58 [23, -17]
59 [14, -6]
60 [14, -6]
67 [51, -29]
68 [42, -18]
69 [33, -7]
70 [33, -7]
78 [61, -19]
79 [52, -8]
80 [52, -8]
89 [71, -9]
90 [71, -9]

 Cliquez pour afficher

...
-90088 []
-80077 []
-70066 []
-60055 []
-50044 []
-40033 []
-30022 []
-20011 []
-9088 []
-8077 []
-7066 []
-6055 []
-5044 []
-4033 []
-3022 []
-2011 []
-988 []
-877 []
-766 []
-655 []
-544 []
-433 []
-322 []
-211 []
-178 []
-157 []
-136 []
-115 []
-99 []
-94 []
-89 []
-78 []
-77 []
-73 []
-67 []
-56 []
-55 []
-52 []
-45 []
-34 []
-33 []
-31 []
-23 []
-12 []
-11 []
18 []
27 []
36 []
45 []
54 []
63 []
72 []
81 []
918 []
927 []
936 []
945 []
954 []
963 []
972 []
981 []
9918 []
9927 []
9936 []
9945 []
9954 []
9963 []
9972 []
9981 []
99918 []
99927 []
99936 []
99945 []
99954 []
99963 []
99972 []
99981 []
...

 Cliquez pour afficher

-10088 [-10007, -9999]
-10077 [-10006, -9998]
-10066 [-10005, -9997]
-10055 [-10004, -9996]
-10044 [-10003, -9995]
-10033 [-10002, -9994]
-10022 [-10001, -9993]
-10011 [-10000, -9992]
-1088 [-1007, -999]
-1077 [-1006, -998]
-1066 [-1005, -997]
-1055 [-1004, -996]
-1044 [-1003, -995]
-1033 [-1002, -994]
-1022 [-1001, -993]
-1011 [-1000, -992]
-188 [-107, -99]
-177 [-106, -98]
-166 [-105, -97]
-155 [-104, -96]
-144 [-103, -95]
-133 [-102, -94]
-122 [-101, -93]
-111 [-100, -92]
-98 [-17, -9]
-76 [-15, -8]
-54 [-13, -7]
-32 [-11, -6]
-9 [89, 90]
-8 [79, 80]
-7 [69, 70]
-6 [59, 60]
-5 [49, 50]
-4 [39, 40]
-3 [29, 30]
-2 [19, 20]
14 [59, 60]
33 [69, 70]
52 [79, 80]
71 [89, 90]
118 [199, 200]
227 [299, 300]
336 [399, 400]
445 [499, 500]
554 [599, 600]
663 [699, 700]
772 [799, 800]
881 [899, 900]
1918 [1999, 2000]
2927 [2999, 3000]
3936 [3999, 4000]
4945 [4999, 5000]
5954 [5999, 6000]
6963 [6999, 7000]
7972 [7999, 8000]
8981 [8999, 9000]
19918 [19999, 20000]
29927 [29999, 30000]
39936 [39999, 40000]
49945 [49999, 50000]
59954 [59999, 60000]
69963 [69999, 70000]
79972 [79999, 80000]
89981 [89999, 90000]

 Cliquez pour afficher

def get_next(n):
    a = abs(n) % 10
    for b in range(10):
        m = n + a * 10 + b
        d = abs(m)
        while d > 9:
            d //= 10
        if d == b:
            yield m


def get_prev(n):
    b = abs(n)
    while b > 9:
        b //= 10
    for a in range(10):
        m = n - (a * 10 + b)
        d = abs(m) % 10
        if d == a:
            yield m


if __name__ == '__main__':
    for n in range(-100000, 100000):
        l = list(get_next(n))
        if len(l) == 0:
            print(n, l)

Bonsoir,
on en est au même point.
À propos de programme je ne comprends pas ce que fait yield et je n'aime pas les fonctions sans return.
Je donne mon code qui est volontairement non optimisé

def premch(n): # retourne le premier chiffre
    return int(str(abs(n))[0])

def derch(n):# retourne le dernier chiffre
    return abs(n)%10

def suc(n): # l est la liste des enfants de n
    l=[]
    a=derch(n)
    m=n+10*a
    for b in range(1,10):
        k=m+b
        if premch(k)==b :
            l.append(k)
    return l

def pred(m): # l est la liste des parents de m
    l=[]
    b=premch(m)
    n=m-b
    for a in range(0,10):
        k=n-10*a
        if derch(k)==a:
            l.append(k)
    return l

On a un code très similaire. Les yields ne sont clairement pas nécessaire ici.
Au lieu de transformer n en str, je divise par 10 jusqu'à avoir un seul chiffre.
Et les yields, l'idée c'est de retourner les résultats dès qu'ils sont disponibles au lieu d'attendre la fin de la fonction et de les retourner dans une liste. Mais comme je les accumule dans une liste de toute façon, ça ne change rien.