Opération sur les ensembles grâce aux nombres premiers.

Supposons que  j'attribue à chaque élément d'un ensemble un nombre premier. En informatique j'aurais pour chaque clef  qui identifie une ligne de table SQL un nombre premier unique attribué.

Maintenant pour identifier le contenu de l'ensemble ou de la table je créer un nombre qui est le produit de tout les nombre premiers  attribués à chaque éléments de cet ensemble. Ce produit est attribué à l'ensemble et contient la liste des ces élément: sa décomposition en nombre premiers. 

Si j'ai deux ensembles  identifiés par un produit de nombre premiers:

•  je peux trouver l'intersection de cet ensemble en calculant le PGCD de ces deux nombres.
• je peux trouver facilement un nombre identifiant l'union des ces deux  ensembles multipliant ces deux nombres.
• il faut que j'étudie les autres opérations.

Bien sur en cas de gros ensemble les nombres identifiant chaque ensemble seront très grand. Je n'ai pas fait d'étude de faisabilité pour l'instant. 

Pour pallier le fait que le nombre qui résulte du produit de tous les nombres premiers qui identifie un élément de cet ensemble est trop grand ,il serait peut être possible de ce ce limiter à un centaine de nombre premier et de créer des classes d'éléments utilisant chacun la même liste de nombre premiers. Exemple très simple pour démonstration: 

j'ai un ensemble O de 20 objets  dans lequel je vais faire des opération sur ces sous-ensembles. Mais je n'ai que 5 nombres premiers. Je créer donc 4 classes d'éléments. Et chaque éléments sera identifié par le couple (classe, nombre premier). Donc chaque sous-ensemble de O sera caractérisé par un quadruplet de nombre premier:

 (Nbre_classe_1,   Nbre_classe_2, Nbre_classe_3, Nbre_classe_4).

Si je veux calculer le nombre qui identifie l'intersection de  deux sous-ensembles de O je calculerai le PGCD classe par classe: le quadruplet caractérisant l'ensemble vide sera (1,1,1,1).

Vaut-il mieux travailler sur des nuplets que sur des très grands nombres? Quand est-il de la vitesse  ou de la place mémoire? Mon intuition est qu'il faut mieux utiliser les nuplets à partir d'une certaine taille des ensembles. Mais laquelle? De plus il est possible d'étendre/ restreindre la dimension  du nuplet suivant les besoins c.a.d si O grandit.

J'ai compris que la décomposition d'un nombre en facteurs premier est une opération très longue voir impossible pour des nombres très grand . C'est un fait garantissant la sureté des  méthodes  cryptographiques à clefs asymétriques.

Mais j'ai entendu dire que c'est une tache que les ordinateurs quantiques savent très bien faire. Mais là encore il faudrait étudier la question. Je ne connais pas assez ce domaine pour avancer.

Donc il m'est difficile d'évaluer l'utilité pratique d'une telle méthode. 

Elle pourrait quand même être utile d'un point de vue théorique.

En espérant que ce poste aura des répercussions utiles ........ si cette méthode n'existe pas déjà.

Cette méthode pourrait être très utile dans le cas ou l'on enchaine des opérations sur les ensemble sans avoir immédiatement besoin d'en  connaitre le résultat: il faut en effet faire une décomposition en nombre premier du  nombre résultat des opérations pour connaitre le contenu de l'ensemble résultat.

Remarquez que avec les capacités mémoire que l'on a aujourd'hui on pourrait peut-être utiliser si le nombre de nombres premier nécessaires n'est pas trop grand une liste comportant pour chaque nombre sa décomposition en nombre premiers.

Il est même possible que de nouvelles méthode puissent être utilisée pour analyser des expression logiques complexes en attribuant à chaque proposition P un nombre premier  p:

A=P1 ou (P2 et P3)  <==> a=p1 * (pgcd(p2,p3) 

<==> Si A est vide  (a=1) alors A est toujours fausse sinon A est vraie.

?????? juste un premier jet.