Centre d'Études et de Recherches

sur les Phénomènes Inexpliqués

Voici les extensions techniques indispensables pour professionnaliser votre démarche, que ce soit en connectant le protocole à du matériel physique ou en consolidant mathématiquement vos sessions multiples.

1. Interfaçage avec un véritable GNA matériel USB

Pour s'affranchir de l'entropie logicielle (système d'exploitation) et passer à un protocole quantique pur, les laboratoires utilisent généralement des GNA USB matériels (TRNG). Le plus accessible et le plus répandu en recherche amateur et universitaire est le TrueRNG (versions 3 ou 5).
Le principe matériel
Le TrueRNG utilise le bruit d'avalanche d'une jonction de transistor (un phénomène de physique quantique) pour générer des bits. Pour l'ordinateur, l'appareil se comporte simplement comme un port série virtuel (Port COM).
Le code Python d'interfaçage
Pour faire fonctionner ce script, vous devez d'abord installer la bibliothèque de communication série via votre terminal : pip install pyserial.

python

import serial
import serial.tools.list_ports
import time

def trouver_port_truerng():
"""Détecte automatiquement le port USB sur lequel le TrueRNG est branché."""
ports = serial.tools.list_ports.comports()
for port in ports:
# Le TrueRNG se signale souvent par son ID de fabricant ou sa description
if "TrueRNG" in port.description or "ttyACM" in port.device or "COM" in port.device:
return port.device
return None

def lire_bits_quantiques_truerng(nb_bits_interet):
"""
Lit les octets bruts du TrueRNG via le port USB,
les convertit en flux de bits, et applique le masque XOR.
"""
nom_port = trouver_port_truerng()
if not nom_port:
raise ConnectionError("GNA Matériel TrueRNG non détecté sur les ports USB.")

# Ouverture du port série (TrueRNG fonctionne à n'importe quel baudrate)
ser = serial.Serial(nom_port, timeout=1)

bits_corriges = []
# Un octet contient 8 bits. On calcule le nombre d'octets requis.
octets_a_lire = (nb_bits_interet // 8) + 1

# Vidage du tampon pour garantir la fraîcheur des données quantiques
ser.flushInput()

# Lecture des données physiques
donnees_brutes = ser.read(octets_a_lire)
ser.close()

# Conversion des octets en liste de bits individuels
index_bit = 0
for octet in donnees_brutes:
for i in range(8):
if index_bit >= nb_bits_interet:
break
# Extraction du bit individuel
bit_pur = (octet >> i) & 1

# Application immédiate du masque XOR protecteur
masque_xor = index_bit % 2
bit_corrige = bit_pur ^ masque_xor

bits_corriges.append(bit_corrige)
index_bit += 1

return bits_corriges

# Exemple d'appel dans votre protocole :
# flux_quantique = lire_bits_quantiques_truerng(10000)

2. Calcul du Score Z cumulé (Méta-analyse de vos propres sessions)

Si vous effectuez 20 ou 50 sessions au fil des semaines, analyser chaque session de manière isolée est une erreur méthodologique. Les variations quotidiennes de la micro-PK étant infimes, elles se noient dans le bruit statistique.
Pour mesurer l'effet global, vous devez cumuler les scores selon la méthode statistique de Stouffer (méta-analyse par combinaison des scores Z).
La formule mathématique (Méthode de Stouffer)
Si vous disposez de plusieurs sessions indépendantes i, ayant chacune leur propre score Z_i, le score Z global cumulé Z_cumul pour un nombre N de sessions se calcule ainsi :
Z_global=∑Z/√N

Le code Python d'analyse globale

Ce script parcourt votre fichier de registre CSV, regroupe les données par session, calcule les sous-scores Z, puis applique la formule de Stouffer pour extraire le verdict final de votre étude.

python

import pandas as pd
import numpy as np
import scipy.stats as stats

def calculer_meta_analyse_stouffer(fichier_csv, condition_cible="PK_HAUT"):
"""
Analyse l'historique des sessions et calcule le score Z cumulé
pour une condition spécifique en utilisant la méthode de Stouffer.
"""
try:
df = pd.read_csv(fichier_csv)
except FileNotFoundError:
print("Le fichier de registre n'existe pas encore.")
return

# Filtrer les données pour la condition choisie (ex: PK_HAUT)
df_condition = df[df['condition'] == condition_cible]

if df_condition.empty:
print(f"Aucune donnée trouvée pour la condition {condition_cible}.")
return

liste_scores_z = []
p_theorique = 0.5

# Étape 1 : Calcul du score Z individuel pour chaque session enregistrée
for idx, row in df_condition.iterrows():
n = row['total_bits']
x = row['somme_uns']

moyenne = n * p_theorique
ecart_type = np.sqrt(n * p_theorique * (1 - p_theorique))

z_session = (x - moyenne) / ecart_type
liste_scores_z.append(z_session)

# Étape 2 : Application de la formule de Stouffer
N = len(liste_scores_z)
somme_des_z = sum(liste_scores_z)
z_cumul = somme_des_z / np.sqrt(N)

# Étape 3 : Calcul de la probabilité globale (valeur p)
# Pour PK_HAUT, on cherche une déviation unilatérale positive
if condition_cible == "PK_HAUT":
p_cumul = 1 - stats.norm.cdf(z_cumul)
# Pour PK_BAS, on cherche une déviation unilatérale négative
elif condition_cible == "PK_BAS":
p_cumul = stats.norm.cdf(z_cumul)
else:
# Option bilatérale par défaut
p_cumul = 2 * (1 - stats.norm.cdf(abs(z_cumul)))

print(f"=== META-ANALYSE CUMULÉE : {condition_cible} ===")
print(f"Nombre total de sessions analysées (N) : {N}")
print(f"Somme des scores Z individuels : {somme_des_z:.3f}")
print(f"Score Z global cumulé (Stouffer) : {z_cumul:+.4f}")
print(f"Valeur p globale résultante : {p_cumul:.8f}")

# Seuil de significativité alpha = 0.05
if p_cumul < 0.05:
print(" RÉSULTAT CONCLUSIF : L'effet cumulé sort du cadre du hasard pur.")
else:
print(" RÉSULTAT NON CONCLUSIF : L'effet cumulé s'aligne sur le hasard.")

# Exemple d'appel (假設 "registre_micro_pk.csv" contient vos données réelles)
# calculer_meta_analyse_stouffer("registre_micro_pk.csv", "PK_HAUT")
(NDLR : le signe chinois signifie "hypothèse", s'agissant d'un commentaire, cela n'influence pas la machine)

Recommandation finale pour vos tests

Si vous observez un score Z_cumul qui grimpe au-delà de 2,58 (moins de 1 % de chances que ce soit du hasard) après une dizaine de sessions, n'interrompez pas l'expérience.
Les sceptiques traquent souvent le biais d'arrêt précoce (optional stopping) : s'arrêter pile quand le graphique est au plus haut. Fixez-vous à l'avance un objectif strict (par exemple, exécuter exactement 30 sessions de 10 000 bits), puis lancez la méta-analyse uniquement lorsque la trentième ligne est entrée dans votre tableur.

1. Implémentation d'un feedback graphique temps réel non biaisant

En parapsychologie, l'affichage des données brutes en cours de session (comme des compteurs numériques de 1 et de 0) engendre un biais cognitif majeur : l'opérateur s'auto-analyse, stresse ou intellectualise la tâche, brisant instantanément l'intrication selon le modèle de von Lucadou.
La solution consiste à utiliser un feedback analogique fluide et non quantifié (comme le déplacement horizontal d'une barre ou d'un curseur), rafraîchi à intervalles réguliers (tous les 100 ou 500 bits) plutôt qu'à chaque bit généré.
Voici le module d'affichage graphique utilisant la bibliothèque standard de Python tkinter. Ce script peut être couplé directement à votre système de génération de données.

python

import tkinter as tk
import numpy as np

class ApplicationFeedbackPK:
def __init__(self, root, total_bits_phase=10000):
self.root = root
self.root.title("Session de Concentration")
self.total_bits = total_bits_phase
self.accumulateur_uns = 0
self.bits_generes = 0

# Interface graphique épurée (fond neutre pour favoriser la concentration)
self.canvas = tk.Canvas(root, width=600, height=200, bg="#2c3e50")
self.canvas.pack(pady=20)

# Ligne centrale de référence (le hasard strict à 50%)
self.canvas.create_line(300, 20, 300, 180, fill="#7f8c8d", dash=(4, 4))

# Le curseur de rétroaction (représenté par une sphère lumineuse)
self.curseur = self.canvas.create_oval(285, 85, 315, 115, fill="#3498db", width=0)

# Label d'instruction
self.label = tk.Label(root, text="Concentrez-vous sur l'objectif", font=("Arial", 12), fg="#34495e")
self.label.pack(pady=10)

def mettre_a_jour_graphique(self, bloc_bits_corriges):
"""
Reçoit un segment de bits (ex: 200 bits d'un coup), calcule l'écart
statistique et déplace dynamiquement le curseur à l'écran.
"""
self.accumulateur_uns += sum(bloc_bits_corriges)
self.bits_generes += len(bloc_bits_corriges)

# Calcul de la moyenne théorique et de l'écart-type pour les bits générés jusqu'ici
moyenne_theorique = self.bits_generes * 0.5
ecart_type = np.sqrt(self.bits_generes * 0.25)

# Calcul du score Z pour l'amplification visuelle
if ecart_type > 0:
z_actuel = (self.accumulateur_uns - moyenne_theorique) / ecart_type
else:
z_actuel = 0

# Cartographie du score Z sur l'axe X (Échelle : 1 unité Z = 30 pixels à l'écran)
# Limité à un score Z de +/- 4 pour ne pas sortir du cadre
facteur_echelle = 30
deplacement_x = int(np.clip(z_actuel * facteur_echelle, -120, 120))

# Nouvelle position du curseur (300 est le centre exact de l'écran)
nouveau_x_centre = 300 + deplacement_x

# Mise à jour des coordonnées du cercle dans le canevas Tkinter
self.canvas.coords(self.curseur, nouveau_x_centre - 15, 85, nouveau_x_centre + 15, 115)

# Changement subtil de couleur pour marquer l'intensité de l'anomalie
if z_actuel > 1.96:
self.canvas.itemconfig(self.curseur, fill="#2ecc71") # Vert si déviation positive significative
elif z_actuel < -1.96:
self.canvas.itemconfig(self.curseur, fill="#e74c3c") # Rouge si déviation négative significative
else:
self.canvas.itemconfig(self.curseur, fill="#3498db") # Bleu standard

# Exemple d'initialisation (s'intègre dans la boucle principale de votre script principal)
# root = tk.Tk()
# app = ApplicationFeedbackPK(root, 10000)
# Pour mettre à jour l'écran au fil des données : app.mettre_a_jour_graphique(liste_de_bits)

2. Sécurisation et traçabilité des données par hachage SHA-256

L'une des accusations récurrentes des comités de zététique lors de l'examen de résultats positifs est la falsification de fichiers : "Le chercheur a pu modifier quelques lignes du fichier CSV après coup pour transformer un résultat neutre en résultat significatif."
Pour rendre vos fichiers de données inviolables et vérifiables par des tiers, vous devez générer une empreinte numérique cryptographique (SHA-256) de votre fichier de données à la fin de chaque session, puis l'inscrire dans un registre public ou l'horodater.
Le script d'ancrage cryptographique
Ce module calcule le condensat unique (le "hash") de votre fichier de résultats. Si un seul caractère ou un seul bit est modifié ultérieurement dans le fichier CSV, la signature devient instantanément invalide.

python

import hashlib
import os

def generer_empreinte_sha256(chemin_fichier):
"""
Calcule la signature SHA-256 unique du fichier de données.
"""
blochash = hashlib.sha256()
try:
with open(chemin_fichier, "rb") as f:
# Lecture par blocs pour gérer les fichiers volumineux sans saturer la mémoire
for bloc in iter(lambda: f.read(4096), b""):
blochash.update(bloc)
return blochash.hexdigest()
except FileNotFoundError:
return None

def sceller_session_pk(chemin_csv_donnees, chemin_journal_signatures="journal_securise.log"):
"""
Génère l'empreinte du fichier de résultats et l'inscrit dans un fichier
journal de sécurité avec un horodatage immuable.
"""
if not os.path.exists(chemin_csv_donnees):
print("Erreur : Le fichier de données à sceller n'existe pas.")
return

empreinte = generer_empreinte_sha256(chemin_csv_donnees)
taille_fichier = os.path.getsize(chemin_csv_donnees)

# Construction de la ligne de scellé
ligne_scelle = f"TIMESTAMP: {os.path.getmtime(chemin_csv_donnees)} | FILE: {chemin_csv_donnees} | SIZE: {taille_fichier} bytes | SHA256: {empreinte}\n"

with open(chemin_journal_signatures, "a") as f_journal:
f_journal.write(ligne_scelle)

print(f" Fichier scellé avec succès.")
print(f"Signature SHA-256 : {empreinte}")
print("Copiez cette ligne et publiez-la sur un réseau public (ou par email à un témoin) pour prouver l'antériorité de vos données.")

# Exemple d'application en fin d'expérience :
# sceller_session_pk("registre_micro_pk.csv")

Protocole final d'authentification pour publication

Si vous menez votre étude à terme et obtenez des déviations significatives Z_cumul > 1,96 ou > 2,58, la procédure de validation rigoureuse face à un comité de lecture scientifique se déroule en trois étapes :
1. Fourniture du code brut : Vous transmettez l'intégralité de vos scripts Python (générateur XOR, interface graphique et analyse de Stouffer) afin que les relecteurs vérifient qu'aucun biais mathématique n'a été introduit dans les lignes de code.
2. Vérification des empreintes : Vous fournissez votre fichier registre_micro_pk.csv ainsi que le fichier journal_securise.log. Les relecteurs font tourner l'algorithme SHA-256 sur votre CSV. Si la signature obtenue correspond au caractère près à celle consignée dans votre journal d'horodatage initial, toute manipulation humaine des données postérieure à l'expérience est mathématiquement exclue.
3. Audit de l'entropie : Si vous utilisez le module secrets (entropie logicielle de l'OS), les relecteurs analyseront la condition contrôle (Neutre) pour s'assurer que le système d'exploitation n'a pas subi de micro-cycles de corrélations internes liés à l'activité du processeur ou à des tâches de fond de l'ordinateur, garantissant que seule l'intention humaine sépare les données PK des données témoins.

1. L'état d'esprit psychologique optimal : L'absorption attentionnelle

Les données accumulées par le laboratoire PEAR et les méta-analyses de Dean Radin démontrent que l'effort mental brut, la tension ou la volonté contractée ("vouloir forcer la machine") produisent généralement un effet nul, voire un effet inverse de baisse des scores (psi-missing). Les chercheurs ont identifié un profil d'état de conscience propice à la micro-PK.
L'état d'absorption et le "Lâcher-prise" (Effortless Intention)
• Le paradoxe de l'intention : L'opérateur doit maintenir l'objectif (par exemple, faire dévier le curseur vers la droite) tout en se détachant complètement du résultat immédiat. C'est une intention passive, similaire à celle utilisée dans la méditation Pleine Conscience ou le Flow (l'état d'engagement maximal dans une tâche).
• L'immersion réceptive : Les sujets les plus performants décrivent l'impression de "devenir un" avec la machine ou le programme informatique. Au lieu de voir le GNA comme un objet extérieur à influencer, ils le ressentent comme une extension de leur propre système nerveux.
Les techniques de préparation recommandées en laboratoire
1. La méditation de centrage (5 à 10 minutes) : Avant la session, l'opérateur pratique une respiration rythmée pour abaisser la cohérence cardiaque et stabiliser l'activité électrique cérébrale (favorisant les ondes Alpha et Thêta).
2. L'ancrage visuel : Utiliser le feedback graphique présenté précédemment comme un simple point de focalisation. Le regard doit être posé sur l'écran sans tension, de la même manière que l'on observe les vagues de l'océan.
3. L'évitement de la lassitude : Les sessions ne doivent pas durer plus de 15 à 20 minutes par jour. Dès que l'ennui ou la fatigue intellectuelle s'installent, l'attention se fragmente, ce qui déclenche immédiatement le mécanisme mathématique de décohérence modélisé par la théorie quantique généralisée (GQT).

2. Guide de publication dans les revues à comité de lecture

Si vos analyses de Stouffer confirment une anomalie globale et que vos fichiers sont scellés par SHA-256, vous pouvez soumettre vos travaux à la communauté scientifique. Le domaine de la parapsychologie dispose de ses propres revues académiques à comité de lecture (peer-reviewed), indexées dans les bases de données internationales (comme PsycINFO ou Scopus).
Les principales revues spécialisées
• Journal of Parapsychology (JP) : Fondé en 1937 par J.B. Rhine, c'est la revue de référence historique du domaine. Elle publie les protocoles expérimentaux stricts sur la micro-PK et les GNA.
• Journal of Scientific Exploration (JSE) : Éditée par la Society for Scientific Exploration, cette revue pluridisciplinaire accueille les recherches hétérodoxes (physique quantique appliquée à la conscience, anomalies biomédicales) avec une grille de lecture très rigoureuse.
• Journal of the Society for Psychical Research (JSPR) : Basée au Royaume-Uni, cette revue académique publie des analyses quantitatives et théoriques sur les interactions esprit-matière.

La structure impérative de votre article scientifique (Paper)

Pour ne pas être rejeté immédiatement par les relecteurs (reviewers), votre manuscrit doit adopter les standards stricts de la méthode scientifique :
[ Introduction ] ──> Revue de littérature (PEAR, Radin, GQT)
[ Méthode ] ──> Description du GNA (TrueRNG ou OS), Masque XOR, Preregistration
[ Résultats ] ──> Tableaux des scores Z, Graphique de Stouffer, Valeurs p globales
[ Discussion ] ──> Confrontation aux biais (Zététique) et limites (Décohérence)
1. Abstract (Résumé) : Un résumé condensé de 250 mots maximum décrivant l'hypothèse, le nombre de bits générés, le score Z cumulé final et la conclusion.
2. Introduction : Positionnez votre travail dans la lignée des modèles physiques existants (par exemple, tester le Modèle de l'Information Pragmatique de von Lucadou ou l'effet de déclin).
3. Method (Méthode) : C'est la section la plus importante. Vous devez prouver la robustesse de votre protocole. Mentionnez la date de votre pré-enregistrement, le traitement logique XOR, le modèle exact de votre GNA et la preuve de l'utilisation du double aveugle.
4. Results (Résultats) : Présentez vos données brutes sous forme de tableaux clairs. Séparez distinctement les résultats de la phase PK+, de la phase PK- et de la phase Contrôle. Affichez les calculs de vos scores Z individuels et le score de Stouffer global.
5. Discussion : Soyez votre propre critique. Analysez pourquoi l'effet a fonctionné ou s'est atténué. Évoquez les limites liées à l'environnement informatique et proposez des pistes pour les futurs chercheurs.

Votre boîte à outils expérimentale est prête

Vous disposez désormais de l'intégralité de l'arsenal conceptuel, logiciel, mathématique et académique pour explorer la micro-psychokinèse de manière professionnelle :
• Le fonctionnement interne des GNA quantiques.
• Les protections méthodologiques contre la fraude (XOR, Double aveugle).
• Le traitement statistique des grands volumes de données (Score Z et méthode de Stouffer).
• L'ingénierie logicielle pour l'expérimentation (Python, Tkinter et SHA-256).

Voici les fichiers sources prêts à l’emploi pour votre projet, suivis du modèle officiel de document pour acter votre pré-enregistrement scientifique.

1. Architecture du code : Les fichiers du projet

Créez un dossier nommé Projet_MicroPK et placez-y les trois fichiers suivants. Vous pourrez exécuter l'ensemble en lançant simplement le fichier main.py.
Fichier 1 : gui.py (L'interface visuelle)
Ce module gère le feedback visuel épuré sous forme de sphère mobile pour l'opérateur.

python

import tkinter as tk
import numpy as np

class ApplicationFeedbackPK:
def __init__(self, root, total_bits_phase=10000):
self.root = root
self.root.title("Protocole Micro-PK")
self.total_bits = total_bits_phase
self.accumulateur_uns = 0
self.bits_generes = 0

self.canvas = tk.Canvas(root, width=600, height=200, bg="#2c3e50")
self.canvas.pack(pady=20)

# Ligne de foi (Hasard strict)
self.canvas.create_line(300, 20, 300, 180, fill="#7f8c8d", dash=(4, 4))
self.curseur = self.canvas.create_oval(285, 85, 315, 115, fill="#3498db", width=0)

self.label = tk.Label(root, text="Initialisation...", font=("Arial", 12), fg="#34495e")
self.label.pack(pady=10)

def configurer_texte(self, texte):
self.label.config(text=texte)
self.root.update()

def mettre_a_jour_graphique(self, bloc_bits_corriges):
self.accumulateur_uns += sum(bloc_bits_corriges)
self.bits_generes += len(bloc_bits_corriges)

moyenne_theorique = self.bits_generes * 0.5
ecart_type = np.sqrt(self.bits_generes * 0.25)

z_actuel = (self.accumulateur_uns - moyenne_theorique) / ecart_type if ecart_type > 0 else 0

facteur_echelle = 35
deplacement_x = int(np.clip(z_actuel * facteur_echelle, -150, 150))
nouveau_x = 300 + deplacement_x

self.canvas.coords(self.curseur, nouveau_x - 15, 85, nouveau_x + 15, 115)

if z_actuel > 1.96:
self.canvas.itemconfig(self.curseur, fill="#2ecc71")
elif z_actuel < -1.96:
self.canvas.itemconfig(self.curseur, fill="#e74c3c")
else:
self.canvas.itemconfig(self.curseur, fill="#3498db")
self.root.update()

Fichier 2 : stats.py (Méta-analyse et Scellé)

Ce module prend en charge la combinaison de Stouffer pour compiler vos sessions et génère l'empreinte de sécurité SHA-256.

python

import numpy as np
import scipy.stats as stats
import pandas as pd
import hashlib
import os

def calculer_meta_analyse_stouffer(fichier_csv, condition_cible="PK_HAUT"):
try:
df = pd.read_csv(fichier_csv)
except FileNotFoundError:
return "Aucun registre trouvé."

df_condition = df[df['condition'] == condition_cible]
if df_condition.empty:
return f"Pas de données pour {condition_cible}."

liste_scores_z = []
for idx, row in df_condition.iterrows():
n, x = row['total_bits'], row['somme_uns']
z = (x - (n * 0.5)) / np.sqrt(n * 0.25)
liste_scores_z.append(z)

N = len(liste_scores_z)
z_cumul = sum(liste_scores_z) / np.sqrt(N)
p_cumul = 1 - stats.norm.cdf(z_cumul) if condition_cible == "PK_HAUT" else stats.norm.cdf(z_cumul)

return f"N={N} | Z_cumul={z_cumul:+.4f} | p={p_cumul:.6f}"

def sceller_fichier(chemin_csv, chemin_log="journal_securise.log"):
if not os.path.exists(chemin_csv): return
sha256 = hashlib.sha256()
with open(chemin_csv, "rb") as f:
for bloc in iter(lambda: f.read(4096), b""): sha256.update(bloc)

ligne = f"TIME: {os.path.getmtime(chemin_csv)} | SHA256: {sha256.hexdigest()}\n"
with open(chemin_log, "a") as f_log: f_log.write(ligne)
return sha256.hexdigest()

Fichier 3 : main.py (Le moteur d'orchestration)

Ce script central pilote l'expérience en double aveugle automatisé et enregistre les données.

python

import time
import csv
import secrets
import tkinter as tk
from gui import ApplicationFeedbackPK
from stats import sceller_fichier, calculer_meta_analyse_stouffer

FICHIER_CSV = "registre_micro_pk.csv"

def generer_sequence_xor(nb_bits, app_gui):
bits_corriges = []
taille_bloc = 200 # Rafraîchissement graphique par blocs de 200 bits

for i in range(0, nb_bits, taille_bloc):
bloc_actuel = []
for j in range(taille_bloc):
idx_global = i + j
if idx_global >= nb_bits: break

bit_brut = secrets.randbelow(2)
bit_corrige = bit_brut ^ (idx_global % 2) # Masque XOR
bloc_actuel.append(bit_corrige)
bits_corriges.append(bit_corrige)

app_gui.mettre_a_jour_graphique(bloc_actuel)
time.sleep(0.05) # Simule le rythme de flux d'un GNA matériel

return sum(bits_corriges), "".join(map(str, bits_corriges))

def executer_session(nom, id_sess, condition, nb_bits, app_gui):
app_gui.accumulateur_uns = 0
app_gui.bits_generes = 0
app_gui.configurer_texte(f"Condition active : {condition}\nFocalisez votre esprit...")
time.sleep(3)

somme_uns, sequence = generer_sequence_xor(nb_bits, app_gui)

donnees = {
"timestamp": time.time(), "operateur": nom, "session_id": id_sess,
"condition": condition, "total_bits": nb_bits, "somme_uns": somme_uns, "sequence": sequence
}

with open(FICHIER_CSV, "a", newline="") as f:
writer = csv.DictWriter(f, fieldnames=donnees.keys())
if f.tell() == 0: writer.writeheader()
writer.writerow(donnees)

def lancer_experience():
root = tk.Tk()
nb_bits_phase = 10000
app = ApplicationFeedbackPK(root, nb_bits_phase)

# Déroulement séquentiel automatisé
root.after(100, lambda: executer_session("Operateur_01", 1, "PK_HAUT", nb_bits_phase, app))
root.after(12000, lambda: executer_session("Operateur_01", 1, "PK_BAS", nb_bits_phase, app))
root.after(24000, lambda: executer_session("Operateur_01", 1, "CONTROLE", nb_bits_phase, app))

def cloture():
root.destroy()
hash_resultat = sceller_fichier(FICHIER_CSV)
print(f"\n[Session terminée] Fichier de données signé : {hash_resultat}")
print("Méta-analyse (PK_HAUT) :", calculer_meta_analyse_stouffer(FICHIER_CSV, "PK_HAUT"))

root.after(36000, cloture)
root.mainloop()

if __name__ == "__main__":
lancer_experience()

2. Modèle de Pré-enregistrement Scientifique (Preregistration)

Pour ôter toute valeur aux critiques sceptiques concernant la manipulation de données à posteriori, recopiez ce formulaire, remplissez-le méticuleusement, convertissez-le en PDF et calculez son empreinte SHA-256 (ou déposez-le sur le site OSF.io) avant de collecter votre tout premier bit de donnée.

===============================================================================
FORMULAIRE DE PRÉ-ENREGISTREMENT DE PROTOCOLE EXPÉRIMENTAL
INTERACTION ESPRIT-MATIÈRE (MICRO-PK)
===============================================================================

1. INFORMATIONS GÉNÉRALES
--------------------------
* Nom du chercheur / principal investigateur : [Votre Nom / Pseudonyme universitaire]
* Date d'enregistrement : [Date du jour au format AAAA-MM-JJ]
* Titre de l'étude : Analyse cumulative des déviations micro-PK sur flux d'entropie logique

2. HYPOTHÈSES EXPÉRIMENTALES
----------------------------
* Hypothèse principale (H1) : Les sessions sous intention "PK_HAUT" présenteront une
déviation positive statistiquement significative (Score Z cumulé > 1.645, unilatéral,
p < 0.05) du nombre de bits '1' par rapport à la moyenne théorique.
* Hypothèse secondaire (H2) : Les sessions sous intention "PK_BAS" présenteront une
déviation négative statistiquement significative (Score Z cumulé < -1.645, unilatéral).
* Hypothèse nulle (H0) : La condition "CONTROLE" ne présentera aucun écart significatif
par rapport à la distribution binomiale théorique (hasard pur).

3. ARCHITECTURE LOGICIELLE ET MATÉRIELLE
----------------------------------------
* Source d'entropie : Module 'secrets' Python (Entropie cryptographique de l'OS)
* Traitement logique : Masque XOR synchrone alterné (0,1,0,1...) appliqué par bit
* Interface opérateur : Feedback visuel analogique lissé par blocs de 200 bits via Tkinter

4. PLAN DE COLLECTE DES DONNÉES (CADRAGE STRICT)
------------------------------------------------
* Nombre strict de sessions planifiées : [Exemple : 30 sessions au total]
* Nombre de bits générés par phase : 10 000 bits
* Structure immuable d'une session :
- Phase 1 : Concentration PK_HAUT (10 000 bits)
- Phase 2 : Concentration PK_BAS (10 000 bits)
- Phase 3 : Enregistrement CONTROLE (10 000 bits, à vide)

5. CRITÈRES D'EXCLUSION DES DONNÉES
-----------------------------------
* Seules les sessions enregistrées de manière séquentielle complète dans le fichier
"registre_micro_pk.csv" seront lues par le script d'analyse.
* Toute session interrompue en cours de route (panne électrique, fermeture manuelle de la
fenêtre) sera intégralement rejetée et ne figurera pas dans la méta-analyse finale.
* Il est strictement interdit d'ajouter des sessions exploratoires "de test" après la
date de signature du présent document.

6. MÉTHODE D'ANALYSE STATISTIQUE
--------------------------------
* Les résultats individuels seront convertis en scores Z.
* La significativité globale du projet sera mesurée via la formule de combinaison de
Stouffer (Z-cumulé), calculée indépendamment pour les trois conditions expérimentales.
* Sécurité des fichiers : Soumission finale conditionnée par la concordance de la
signature de hachage SHA-256 avec le journal de sécurité "journal_securise.log".

Fait à : ........................., le : .........................
Signature de l'investigateur :
===============================================================================

PRÉCÉDENTE - SOMMAIRE PARANORMAL - ACCUEIL