CINQ PREUVES DISCRÈTES CONTRE L'OBLIGATION DES NOMBRES IMAGINAIRES






Depuis des siècles, les mathématiques classiques utilisent les nombres imaginaires pour décrire la rotation, les oscillations, les ondes, l'analyse spectrale et la mécanique quantique. Ces nombres, fondés sur l'unité imaginaire i, sont si présents qu'ils semblent indispensables. Pourtant, ils viennent du continu, c'est-à-dire de l'idée que l'on peut diviser l'espace et le temps à l'infini. Or le réel ne se divise pas infiniment. Il est fait de sites, de seuils et de redistributions.

Nous avons construit et testé cinq formulations discrètes qui remplacent les nombres imaginaires par des opérations réelles, locales et entières. Chaque formulation est reproductible en quelques lignes de code. Aucun nombre complexe n'est utilisé.

Première preuve : la rotation.

La rotation classique utilise les fonctions sinus et cosinus, ou l'exponentielle complexe. En discret, une rotation de quatre-vingt-dix degrés est une simple permutation de sites. La matrice change de place, les valeurs restent les mêmes. Aucun calcul trigonométrique n'est nécessaire.

Deuxième preuve : l'oscillateur.

L'impédance complexe et les phaseurs servent à décrire les circuits réactifs. En discret, un circuit LC est simulé par deux équations d'état couplées, avec un schéma symplectique. La tension reste bornée, l'énergie se conserve, et la fréquence mesurée est très proche de la valeur théorique. Aucune exponentielle complexe.

Troisième preuve : la propagation d'onde.

L'onde classique est décrite par une exponentielle complexe. En discret, elle se propage par une relation de voisinage sur une grille. L'énergie mécanique totale reste constante. Le paquet d'onde se sépare en deux fronts symétriques. Aucun nombre imaginaire.

Quatrième preuve : l'analyse spectrale.

La transformée de Fourier utilise des exponentielles complexes. La transformée de Walsh-Hadamard utilise une base de +1 et -1. Elle décompose un signal, filtre le bruit et reconstruit le signal avec une erreur faible. Aucune fonction trigonométrique.

Cinquième preuve : la marche quantique.

La mécanique quantique standard repose sur des amplitudes complexes. Une marche quantique discrète à deux composantes réelles, avec la matrice de Hadamard réelle, conserve exactement la probabilité totale et produit la propagation balistique caractéristique. L'interférence vient du signe négatif, pas de l'unité imaginaire.

Ces cinq preuves ne sont pas une démonstration générale. Elles sont un premier faisceau. Elles montrent que les nombres imaginaires ne sont pas des réalités physiques. Ce sont des outils du continu. Dès que l'on raisonne en discret, on peut s'en passer.

La suite consistera à remplacer d'autres usages, comme les transformations de phase en traitement du signal avancé, ou les représentations complexes en électromagnétisme. Le chemin est long, mais la direction est claire.

Le code ci-dessous regroupe les cinq validations en un seul notebook reproductible. Il peut être copié dans Google Colab et exécuté tel quel.

```python
import numpy as np

print("=== 1. ROTATION DISCRÈTE 90° ===")
grille = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
rotation_90 = np.rot90(grille, -1)
print("Rotation 90° horaire :")
print(rotation_90)

print("\n=== 2. OSCILLATEUR LC DISCRET (LEAPFROG) ===")
L = 0.1
C = 0.0001
dt = 0.0001
steps = 5000
Vc = 5.0
I = 0.0
history_Vc = []
history_I = []
I_half = I + (Vc / L) * (dt / 2.0)
for step in range(steps):
    Vc = Vc - (I_half / C) * dt
    I_half = I_half + (Vc / L) * dt
    I_sync = I_half - (Vc / L) * (dt / 2.0)
    history_Vc.append(Vc)
    history_I.append(I_sync)
max_indices = [i for i in range(1, steps-1) if history_Vc[i] > history_Vc[i-1] and history_Vc[i] > history_Vc[i+1]]
period_steps = max_indices[1] - max_indices[0]
freq = 1.0 / (period_steps * dt)
print("Tension min :", round(min(history_Vc), 4))
print("Tension max :", round(max(history_Vc), 4))
print("Fréquence estimée :", round(freq, 2), "Hz")

print("\n=== 3. PROPAGATION D'ONDE 1D (FDTD) ===")
N = 200
dx = 1.0
dt2 = 0.1
c = 1.0
r = c * dt2 / dx
steps2 = 300
x = np.arange(N)
u_0 = np.exp(-0.01 * (x - N//2)**2)
u_1 = u_0.copy()
u_1[1:-1] = u_0[1:-1] + 0.5 * r**2 * (u_0[2:] - 2.0*u_0[1:-1] + u_0[:-2])
u_prev = u_0.copy()
u_curr = u_1.copy()
energy_kin = []
energy_pot = []
for step in range(steps2):
    u_next = np.zeros(N)
    u_next[1:-1] = (2.0 * u_curr[1:-1] - u_prev[1:-1] + r**2 * (u_curr[2:] - 2.0*u_curr[1:-1] + u_curr[:-2]))
    u_next[0] = 0.0
    u_next[N-1] = 0.0
    vitesse = (u_curr - u_prev) / dt2
    gradient = (np.roll(u_curr, -1) - u_curr) / dx
    E_k = 0.5 * np.sum(vitesse[1:-1]**2)
    E_p = 0.5 * c**2 * np.sum(gradient[1:-1]**2)
    energy_kin.append(E_k)
    energy_pot.append(E_p)
    u_prev = u_curr.copy()
    u_curr = u_next.copy()
energy_total = np.array(energy_kin) + np.array(energy_pot)
print("Énergie totale avant bord (pas 80) :", round(energy_total[80], 4))

print("\n=== 4. ANALYSE SPECTRALE WALSH-HADAMARD ===")
def fwht(x):
    a = np.array(x, dtype=float)
    N = len(a)
    h = 1
    while h < N:
        for i in range(0, N, h * 2):
            for j in range(i, i + h):
                u = a[j]
                v = a[j + h]
                a[j] = u + v
                a[j + h] = u - v
        h *= 2
    return a
N3 = 16
signal_original = np.array([1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1], dtype=float)
bruit = np.array([0.2, -0.1, 0.1, -0.2, 0.1, -0.1, 0.2, -0.1, 0.1, -0.2, 0.1, -0.1, 0.2, -0.1, 0.1, -0.2])
signal_bruite = signal_original + bruit
spectre = fwht(signal_bruite)
seuil = 2.0
spectre_filtre = np.where(np.abs(spectre) > seuil, spectre, 0.0)
signal_reconstruit = fwht(spectre_filtre) / N3
erreur_max = np.max(np.abs(signal_original - signal_reconstruit))
print("Erreur maximale :", round(erreur_max, 4))

print("\n=== 5. MARCHE QUANTIQUE 1D SANS COMPLEXE ===")
N4 = 201
steps4 = 60
center = N4 // 2
psi_R = np.zeros(N4, dtype=float)
psi_L = np.zeros(N4, dtype=float)
psi_R[center] = 1.0 / np.sqrt(2)
psi_L[center] = 1.0 / np.sqrt(2)
inv_sqrt2 = 1.0 / np.sqrt(2)
for step in range(steps4):
    new_R = inv_sqrt2 * (psi_R + psi_L)
    new_L = inv_sqrt2 * (psi_R - psi_L)
    psi_R = np.roll(new_R, 1)
    psi_L = np.roll(new_L, -1)
probability_density = psi_R**2 + psi_L**2
total_probability = np.sum(probability_density)
print("Conservation de la probabilité totale :", round(total_probability, 6))
print("Pic gauche :", center - np.argmax(probability_density[:center]))
print("Pic droit :", np.argmax(probability_density[center:]))
```

Ce notebook est la preuve reproductible. Il peut être exécuté par tout lecteur.


Commentaires

Posts les plus consultés de ce blog

LA MANIPULATION NE GUÉRIT PAS. ELLE TRAHIT LE VIVANT.

QUAND LA SCIENCE RETROUVE SA SOURCE

POURQUOI LA REFONDATION TRUE DES MATHÉMATIQUES EST UTILE