Programme de numérologie / tarot avancé / fonction des lettres et chiffre

[mikalapach]

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.

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

[Flyingbike]

Venir poster ça sur un forum de sciences (vous savez, dans "Futura-sciences" le "sciences" se rapporte aux "sciences", c'est à dire à l'opposé de ces foutaises), c'est quand même culotté.