mathématique symbolique logique relationel aux mots

Bonjour a tous, apres quelque semaines de travail, j'ai pu établir des liens entre les lettres et les chiffres, mot et nombre, calculable.
Imaginé quand dieu nous a creer nous etions sur un livre, chaque lettre est vivant en quelque sorte et reagit aux autres.

J'ai relier les chiffres a des mots, tres coherent qui marche, je vous invite a essayer mon programme qui est en python.
Sinon voici le code source : 

# ********************************************************************************************
#  CALCULATEUR SYMBOLIQUE - VERSION STABLE + SYMBOLIQUE MODULO INTÉGRÉ
# ********************************************************************************************

import json
import os
import unicodedata

# =============================
#  HISTORIQUE
# =============================
FICHIER = "historique.json"

def charger_historique():
    if not os.path.exists(FICHIER):
        return []
    try:
        with open(FICHIER, "r", encoding="utf-8") as f:
            return json.load(f)
    except:
        return []

def sauvegarder_historique(data):
    try:
        with open(FICHIER, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
    except:
        pass

# =============================
#  BASE SYMBOLIQUE
# =============================
base_symbolique = {
    0: "Cycle / Boucle",
    1: "A : Unité",
    2: "B : Couple",
    3: "C : Création",
    4: "D : Surface",
    5: "E : Harmonie",
    6: "F : Secret, vent",
    7: "G : Illusion",
    8: "H : Équilibre, amalgamme",
    9: "I : Transformation, mort",
    10: "J : Action, direct",
    11: "K : Canaliser",
    12: "L : Alpha",
    13: "M : Drogue",
    14: "N : Tension",
    15: "O : Sang",
    16: "P : Expansion",
    17: "Q : Matière",
    18: "R : Voyage",
    19: "S : Onde",
    20: "T : Temps",
    21: "U : Protection",
    22: "V : Énergie",
    23: "W : Désordre",
    24: "X : Force",
    25: "Y : Vérité",
    26: "Z : Fin"
}

# =============================
#  TITRE
# =============================
print(r"""
__________.__        _________            .__        __    ____   ________
\______   \__| ____ /   _____/ ___________|__|______/  |_  \   \ /   /_   |
 |    |  _/  |/  _ \\_____  \_/ ___\_  __ \  \____ \   __\  \   Y   / |   |
 |    |   \  (  <_> )        \  \___|  | \/  |  |_> >  |     \     /  |   |
 |______  /__|\____/_______  /\___  >__|  |__|   __/|__|      \___/   |___|
        \/                 \/     \/         |__|
""")

print(" Calculateur symbolique — version stable + symbolique intégrée")
print("====================================================")

# =============================
#  NETTOYAGE
# =============================
def nettoyer(txt):
    try:
        txt = unicodedata.normalize("NFD", str(txt))
        return txt.encode("ascii", "ignore").decode().upper().strip()
    except:
        return ""

# =============================
#  CONVERSION
# =============================
def convertir(valeur):
    try:
        valeur = nettoyer(valeur)
        total = 0

        for c in valeur:
            if c.isalpha():
                total += ord(c) - 64
            elif c.isdigit():
                total += int(c)

        return total
    except:
        return 0

# =============================
#  MODULO CHOIX
# =============================
def choisir_modulo():
    try:
        print("\n===== MODULO =====")
        print("1 : Avec modulo")
        print("2 : Sans modulo")
        print("3 : Tous les modulos")

        c = input("Choix : ").strip()

        if c == "1":
            m = int(input("Valeur modulo (1-26) : "))
            return max(1, min(26, m))

        if c == "3":
            return "TOUS"

        return None
    except:
        return None

# =============================
#  MODULO + SYMBOLIQUE
# =============================
def appliquer_modulo(resultat, modulo):

    if modulo is None:
        return resultat

    # =============================
    #  TOUS LES MODULOS
    # =============================
    if modulo == "TOUS":

        print("\n===== MODULO 1 → 26 (SYMBOLIQUE) =====")

        resultats = {}

        for i in range(1, 27):

            reste = resultat % i
            index = reste % 27

            symbole = base_symbolique[index]
            lettre = "Cycle" if index == 0 else chr(64 + index)

            print(f"{resultat} % {i} = {reste} → {lettre} → {symbole}")

            resultats[i] = {
                "reste": reste,
                "lettre": lettre,
                "symbolique": symbole
            }

        return resultats

    # =============================
    #  MODULO SIMPLE
    # =============================
    reste = resultat % modulo
    index = reste % 27

    symbole = base_symbolique[index]
    lettre = "Cycle" if index == 0 else chr(64 + index)

    print("\n===== MODULO =====")
    print(f"Calcul : {resultat} % {modulo}")
    print(f"Résultat : {reste}")
    print(f"Lettre : {lettre}")
    print(f"Symbolique : {symbole}")

    return {
        "reste": reste,
        "lettre": lettre,
        "symbolique": symbole
    }

# =============================
#  AFFICHAGE
# =============================
def afficher(valeurs, resultat, op, modulo):

    print("\n" + "=" * 60)
    print(" OPÉRATION :", op)
    print("=" * 60)

    print("\n VALEURS ANALYSÉES")
    for v in valeurs:
        print("-", v, "→", convertir(v))

    print("\n VALEUR BRUTE :", resultat)

    print("\n MODULO + SYMBOLIQUE")
    mod = appliquer_modulo(resultat, modulo)

    print("\n CARRÉ")
    print("brut² =", resultat * resultat)

    if isinstance(mod, dict) and "reste" in mod:
        print("modulo² =", mod["reste"] * mod["reste"])
    else:
        print("modulo² = multi-modulo")

    hist = charger_historique()
    hist.append({
        "operation": op,
        "valeurs": valeurs,
        "resultat": resultat,
        "modulo": modulo
    })
    sauvegarder_historique(hist)

# =============================
#  ADDITION
# =============================
def addition():
    modulo = choisir_modulo()

    n = int(input("Nombre de valeurs : "))
    vals = [input(f"Valeur {i+1} : ") for i in range(n)]

    res = sum(convertir(v) for v in vals)

    afficher(vals, res, "ADDITION", modulo)

# =============================
# ✖ MULTIPLICATION
# =============================
def multiplication():
    modulo = choisir_modulo()

    n = int(input("Nombre de valeurs : "))
    vals = []

    res = 1
    for i in range(n):
        v = input(f"Valeur {i+1} : ")
        vals.append(v)
        res *= convertir(v)

    afficher(vals, res, "MULTIPLICATION", modulo)

# =============================
#  COMPARAISON
# =============================
def difference():
    modulo = choisir_modulo()

    n = int(input("Nombre de valeurs : "))
    vals = [input(f"Valeur {i+1} : ") for i in range(n)]

    nums = [convertir(v) for v in vals]

    res = nums[0] - sum(nums[1:])

    afficher(vals, res, "COMPARAISON", modulo)

# =============================
#  CARRÉ
# =============================
def carre():
    modulo = choisir_modulo()

    v = input("Valeur : ")
    x = convertir(v)

    res = x * x

    afficher([v], res, "CARRÉ", modulo)

# =============================
#  MENU (MODIFIÉ)
# =============================
def menu():

    while True:

        try:
            print("\n===== MENU =====")
            print("1 : ADDITION ( additionne le nombre de valeurs spécifiées )")
            print("2 : MULTIPLICATION / FUSION ( multiplie le nombre de valeurs demandées )")
            print("3 : COMPARAISON ( compare les valeurs demandées )")
            print("4 : CARRÉ ( met au carré la valeur spécifiée )")
            print("5 : AFFICHER BASES MODULO")
            print("0 : QUITTER")

            choix = input("Choix : ").strip()

            if choix == "1":
                addition()
            elif choix == "2":
                multiplication()
            elif choix == "3":
                difference()
            elif choix == "4":
                carre()
            elif choix == "5":
                for k, v in base_symbolique.items():
                    print(k, "→", v)
            elif choix == "0":
                print(" fermeture")
                break
            else:
                print(" invalide")

        except:
            print(" erreur menu")

# =============================
#  LANCEMENT
# =============================
if __name__ == "__main__":
    menu()

Ce qui est le plus important est la symbolique lié aux chiffres :
   0: "Cycle / Boucle",
   1: "A : Unité",
   2: "B : Couple, dynamisme",
   3: "C : Création, sublime",
   4: "D : Surface",
   5: "E : Harmonie, Bonheur",
   6: "F : Secret, vent",
   7: "G : Illusion, or",
   8: "H : Équilibre, amalgame",
   9: "I : Transformation, mort",
   10: "J : Action, direct",
   11: "K : Canaliser",
   12: "L : Alpha",
   13: "M : Drogue",
   14: "N : Tension",
   15: "O : Sang",
   16: "P : Paradis",
   17: "Q : Jeux",
   18: "R : Voyage",
   19: "S : Onde",
   20: "T : Temps",
   21: "U : Protection",
   22: "V : Énergie",
   23: "W : Désordre",
   24: "X : Force",
   25: "Y : Vérité",
   26: "Z : Fin"

Vous pouver faire toute les operations possible dessus et meme parler un language numérique a la longue, * / - + ²

Exemple :

mickail ( 13 + 9 + 3 + 11 + 1  + 9 + 12 ) = 58, en numérologie ca donnerait 4D
Mais dans mon code j'ai rajouter ce qui s'apelle des "modulo", ce sont des nombres symbolique ( qui ont un cliché ) qui servent a "moduler" le résultat de fin. ce sont les chiffre et mots du début qui servent de modulo, de bases vue que l'alphabet a 26 lettres, le modulo seras 26, si vous voulez des phrases plus "vrai" joger le modulo a 25 ( vérité ) 

donc mickail = 58, modulo 25 ( verité ) = 58 % 25 = 8H, ( amalgame )
          "       = 58, modulo 26 ( fin ) = 58 % 26 = 6F ( secret, vent )

donner moi des exemples que l'on s'amuse !

Au secours, j'ai rien compris ....la dernière fois que j'ai eu des symboles c'est quand j'ai été piratée 

il y a 16 minutes, lunatike a dit :

Au secours, j'ai rien compris ....la dernière fois que j'ai eu des symboles c'est quand j'ai été piratée 

moi c'est pendant une recherche d'emploi, mon futur patron m'a parlé d'un salaire "symbolique"

si vous avez la bibliotheque pour lire les fichiers python, je vous invite a telecharger le script python : 
https://uploadnow.io/f/6wV8q6Z

Sinon c'est plutot simple il suffit de transcrire le mot ou chiffre que vous voulez, par exemple mikail = 13 + 9 + 11 +1 + 9 + 12 = 55.

ENsuite ont y applique un modulo, ici ca seras le 16 ( paradis ). donc 55 % 16 = 7G (illusion, or, soleil ) 

Il y a 1 heure, Tor boudine a dit :

moi c'est pendant une recherche d'emploi, mon futur patron m'a parlé d'un salaire "symbolique"

Il t'a proposé AQJC ?

Je suis d'accord, c'est honteux ! 

tres drole auger, aqjc est la virginité en quelque sorte ...
Cela donne dans mon programme 31, modulo 17 ( jeux de grand ), cela donne 14. (31 % 17 = 14) =  Tension, il y a de l"orage dans l'air

tener le lien du code source en python : 
https://uploadnow.io/f/6wV8q6Z

Dommage que les chiffres et les lettres n'existent plus sinon tu aurais pu t'y inscrire 

Pas sûr tu es la réf