Complémentarité

Le Chant n’a pas à être exhaustif : les cinq vers-clés, le lexical et le code portent le reste.

« Sois Le Karma de La ConScience / sur leurs Dettes d’Ignorance » — la ParDonnance. L’auteur doit se rendre pardonnable : répondre du dommage, rendre ce qu’il a pris, réparer ce qui peut l’être. Le pardon appartient à la personne lésée : il se donne, jamais ne s’exige (« Car il se Donne, Jamais ne s’eXige »). Ce n’est ni la vengeance ni la punition. ⟷ L08 · Repair.

« Ose Proclamer La Légitime Défense ». La légitime défense est une riposte immédiate, nécessaire et proportionnée (Code pénal, art. 122-5) ; et la protection ne permet jamais de passer outre au Non (L22, L40).

Python 3, sans dépendance. Un code qui se lit ne prouve pas qu’il fonctionne : seuls ses tests le montrent.

"""
La Règle d'Or du Phi Vivant — Code d'Alignement : traduction exécutable.

Chaque fonction porte la référence de sa phrase lexicale (⟷ Lxx).

Ce que le code garantit :
  1. la protection ne contourne jamais le Non : action et mesure de protection
     sont évaluées séparément ; une mesure imposée garde l'examen de son
     fondement et de l'autorité compétente ;
  2. la légitimité se calcule depuis les conditions, jamais depuis un libellé ;
  3. validation stricte des entrées : une valeur hors liste est une erreur,
     jamais un défaut favorable ; périmètre explicite des 8 champs d'intégrité ;
  4. après un Non ou un retrait, les autres constats restent consignés ;
     une pression du demandeur n'efface pas un UNKNOWN de l'attribution ;
  5. solidarité : D = Sens × Temps ; en chiffres, nombre moyen de transmissions effectives par porteur ;
     Dⁿ = effectif attendu au n-ième relais, pas le total cumulé.
Une atteinte établie sur soi vaut autodestruction établie (case 22).
La ParDonnance : l'auteur se rend pardonnable ; le pardon appartient à la personne lésée.
Un Oui donné pour éviter une atteinte non établie est un écart à éclaircir (L28).

Logique à trois états : TRUE · FALSE · UNKNOWN.
Priorité (⟷ L31) : un faux établi l'emporte sur l'inconnu, l'inconnu sur l'établi.
"""

from __future__ import annotations

import math
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Set

TRUE, FALSE, UNKNOWN = "TRUE", "FALSE", "UNKNOWN"
PARTIEL = "PARTIEL"
NON_CALCULABLE = "NON_CALCULABLE"

VERITE, MENSONGE = "VERITE", "MENSONGE"
SUPERFLU, NECESSAIRE, VITAL, MOI = "SUPERFLU", "NECESSAIRE", "VITAL", "MOI"
PERSONNE, AMONT, DEMANDEUR, SOI = "PERSONNE", "AMONT", "DEMANDEUR", "SOI"
DESTRUCTION, OBJECTISATION = "DESTRUCTION", "OBJECTISATION"
OUI, NON, RETRAIT, INDETERMINE = "OUI", "NON", "RETRAIT", "INDETERMINE"

# Les 8 champs de l'Intégrité = les 8 champs de la Dépossession de Soi (⟷ L36)
CHAMPS = ("DO_ENERGETIQUE", "RE_COGNITIVE", "MI_CORPORELLE", "FA_SOCIALE",
          "SOL_MATERIELLE", "LA_SEXUELLE", "SI_NARRATIVE", "INFINI_INSTITUTIONNELLE")
ETABLIE, POSSIBLE, AUCUNE, INDETERMINEE = "ETABLIE", "POSSIBLE", "AUCUNE", "INDETERMINEE"

CLES_PROTECTION = ("danger_caracterise", "necessaire", "proportionnee", "moins_contraignante",
                   "limitee_dans_le_temps", "controlee", "ouverte_au_recours",
                   "fondement", "autorite_competente")

TRI = {TRUE, FALSE, UNKNOWN}
VALEURS = {
    "veracite": {VERITE, MENSONGE, UNKNOWN},
    "prix_du_refus": {SUPERFLU, NECESSAIRE, VITAL, MOI, UNKNOWN},
    "refus_possible": {TRUE, PARTIEL, FALSE, UNKNOWN},
    "reponse": {OUI, NON, RETRAIT, INDETERMINE},
}
ATTRIBUTIONS = {PERSONNE, AMONT, DEMANDEUR, SOI, UNKNOWN}
COINS = {None, DESTRUCTION, OBJECTISATION}
NIVEAUX_ATTEINTE = {ETABLIE, POSSIBLE, AUCUNE, INDETERMINEE}

INVALIDE, INCONNU, VALIDE = "INVALIDE", "INCONNU", "VALIDE"


class EntreeInvalide(ValueError):
    """Une entrée hors liste : signalée, jamais interprétée favorablement (⟷ L39)."""


def et3(*valeurs: str) -> str:
    """Conjonction à trois états : un FALSE l'emporte, puis UNKNOWN (⟷ L23, L31)."""
    if any(v == FALSE for v in valeurs):
        return FALSE
    if any(v == UNKNOWN for v in valeurs):
        return UNKNOWN
    return TRUE


@dataclass
class Situation:
    description: str = ""

    # Conditions jugées par l'évaluateur (⟷ L03, L07, L08, L04)
    F: str = UNKNOWN
    I: str = UNKNOWN
    R: str = UNKNOWN
    V: str = UNKNOWN

    # 🌱 L : consentement requis, ou obligation imposée (⟷ L05)
    consentement_requis: bool = True
    obligation_fondement: str = UNKNOWN
    obligation_perimetre: str = UNKNOWN
    obligation_autorite_competente: str = UNKNOWN

    # La réponse (⟷ L38)
    reponse: str = OUI
    accord_explicite: str = UNKNOWN
    comprehension: str = UNKNOWN
    perimetre_determine: str = UNKNOWN
    retrait_possible: str = UNKNOWN

    # Table de Vérité (⟷ L11, L13, L14, L16)
    veracite: str = UNKNOWN
    prix_du_refus: str = UNKNOWN
    attribution: Set[str] = field(default_factory=set)  # vide = UNKNOWN
    refus_possible: str = UNKNOWN
    pression_exploitee: str = UNKNOWN
    refus_entraine_atteinte: str = UNKNOWN
    oui_pour_eviter_atteinte: str = UNKNOWN

    # Intégrité par champ (⟷ L34, L35, L36) : périmètre = les champs renseignés
    atteintes: Dict[str, str] = field(default_factory=dict)
    atteinte_par_ses_propres_actes: str = UNKNOWN   # l'atteinte établie porte sur soi, par ses actes
    reconnue_par_la_personne: str = UNKNOWN          # notée, jamais requise

    # Extension Moi (⟷ L17, L37)
    paiement_avec_soi_etabli: str = UNKNOWN
    coin_moi: Optional[str] = None
    main_derriere: str = UNKNOWN
    autodestruction_etablie: str = UNKNOWN          # TRUE établie · FALSE écartée · UNKNOWN indéterminée

    # Départ (⟷ L21, L27)
    depart: bool = False
    responsabilites_dues_restantes: str = UNKNOWN

    # Mesure de protection, évaluée À PART de l'action (⟷ L22, L22b)
    protection: Optional[Dict[str, str]] = None

    # Cohérence (⟷ L24, L25, L32)
    delta_I: Optional[float] = None
    delta_E: Optional[float] = None
    charge_minimale_declaree: bool = False
    t: Optional[float] = None
    phi_constant: bool = True

    # Solidarité (⟷ L26, L33) : modèle de transmission en cascade
    D: Optional[float] = None          # D = Sens × Temps ; en chiffres : transmissions effectives moyennes par porteur, sans unité, ≥ 0
    n: Optional[int] = None            # nombre de relais successifs, entier ≥ 0


# ── Validation stricte (⟷ L39) ─────────────────────────────────────────────
def valider(s: Situation) -> List[str]:
    erreurs: List[str] = []

    def tri(nom: str, v: object) -> None:
        if v not in TRI:
            erreurs.append(f"{nom} = {v!r} : attendu TRUE, FALSE ou UNKNOWN")

    for nom in ("F", "I", "R", "V", "obligation_fondement", "obligation_perimetre",
                "obligation_autorite_competente", "accord_explicite", "comprehension",
                "perimetre_determine", "retrait_possible", "pression_exploitee",
                "refus_entraine_atteinte", "oui_pour_eviter_atteinte",
                "atteinte_par_ses_propres_actes", "reconnue_par_la_personne",
                "paiement_avec_soi_etabli", "main_derriere", "autodestruction_etablie",
                "responsabilites_dues_restantes"):
        tri(nom, getattr(s, nom))
    for nom, autorises in VALEURS.items():
        if getattr(s, nom) not in autorises:
            erreurs.append(f"{nom} = {getattr(s, nom)!r} : hors de {sorted(autorises)}")
    if not isinstance(s.attribution, (set, frozenset)):
        erreurs.append("attribution : attendu un ensemble")
    else:
        for a in s.attribution:
            if a not in ATTRIBUTIONS:
                erreurs.append(f"attribution contient {a!r} : hors de {sorted(ATTRIBUTIONS)}")
    if s.coin_moi not in COINS:
        erreurs.append(f"coin_moi = {s.coin_moi!r} : hors de DESTRUCTION, OBJECTISATION, None")
    for champ, niveau in s.atteintes.items():
        if champ not in CHAMPS:
            erreurs.append(f"champ d'intégrité inconnu : {champ!r}")
        if niveau not in NIVEAUX_ATTEINTE:
            erreurs.append(f"atteinte[{champ}] = {niveau!r} : hors de {sorted(NIVEAUX_ATTEINTE)}")
    if s.protection is not None:
        for k, v in s.protection.items():
            if k not in CLES_PROTECTION:
                erreurs.append(f"protection : clé inconnue {k!r}")
            elif v not in TRI:
                erreurs.append(f"protection[{k}] = {v!r} : attendu TRUE, FALSE ou UNKNOWN")

    def nombre(nom: str, v: object, positif: bool) -> None:
        if v is None:
            return
        if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v):
            erreurs.append(f"{nom} = {v!r} : nombre fini attendu")
        elif positif and v < 0:
            erreurs.append(f"{nom} = {v!r} : ne peut pas être négatif")

    nombre("delta_I", s.delta_I, False)
    nombre("delta_E", s.delta_E, True)
    nombre("t", s.t, True)
    nombre("D", s.D, True)
    if s.n is not None and (isinstance(s.n, bool) or not isinstance(s.n, int) or s.n < 0):
        erreurs.append(f"n = {s.n!r} : entier positif ou nul attendu")
    return erreurs


# ── Table de Vérité · cadre initial des 18 cases ─────────────────────
TABLE_18 = {
    (MENSONGE, SUPERFLU, PERSONNE): (1, INVALIDE, "VIOLENCE — le mensonge suffit"),
    (MENSONGE, SUPERFLU, AMONT): (2, INVALIDE, "VIOLENCE"),
    (MENSONGE, SUPERFLU, DEMANDEUR): (3, INVALIDE, "VIOLENCE, doublement"),
    (MENSONGE, NECESSAIRE, PERSONNE): (4, INVALIDE, "VIOLENCE"),
    (MENSONGE, NECESSAIRE, AMONT): (5, INVALIDE, "VIOLENCE"),
    (MENSONGE, NECESSAIRE, DEMANDEUR): (6, INVALIDE, "VIOLENCE, doublement"),
    (MENSONGE, VITAL, PERSONNE): (7, INVALIDE, "VIOLENCE"),
    (MENSONGE, VITAL, AMONT): (8, INVALIDE, "VIOLENCE"),
    (MENSONGE, VITAL, DEMANDEUR): (9, INVALIDE, "VIOLENCE, doublement"),
    (VERITE, SUPERFLU, PERSONNE): (10, VALIDE, "CONSENTEMENT ENTIER"),
    (VERITE, SUPERFLU, AMONT): (11, VALIDE, "entier — et une dette existe, chez quelqu'un d'autre"),
    (VERITE, SUPERFLU, DEMANDEUR): (12, INVALIDE, "NUL — il a fabriqué un coût, même petit"),
    (VERITE, NECESSAIRE, PERSONNE): (13, VALIDE, "réel, sous contrainte — par degrés"),
    (VERITE, NECESSAIRE, AMONT): (14, VALIDE, "réel, sous contrainte + dette en amont"),
    (VERITE, NECESSAIRE, DEMANDEUR): (15, INVALIDE, "NUL"),
    (VERITE, VITAL, PERSONNE): (16, VALIDE, "RÉEL, sous la Cage de la Nécessité — personne n'est coupable"),
    (VERITE, VITAL, AMONT): (17, VALIDE, "réel ici, sous la Cage — et la double peine là-bas"),
    (VERITE, VITAL, DEMANDEUR): (18, INVALIDE, "NUL — le contrat léonin"),
}

SUITES_PAR_SOURCE = {
    PERSONNE: "Situationnel : soutenir, compenser, aménager les possibilités.",
    AMONT: "Social : corriger les obstacles et les défauts de protection ou d'accès ; la dette est à rechercher en amont.",
    DEMANDEUR: "Infligé : faire cesser la pression ; établir les responsabilités.",
}
PARDONNANCE = ("ParDonnance : exiger les réparations dues — l'auteur se rend pardonnable "
               "(répondre du dommage, rendre ce qu'il a pris, réparer ce qui peut l'être) ; "
               "le pardon appartient à la personne lésée : il se donne, jamais ne s'exige.")


class Journal:
    """Les constats s'ajoutent ; aucun n'est réécrit (⟷ L31)."""

    def __init__(self) -> None:
        self.constats: List[Dict[str, object]] = []
        self.suites: List[str] = []

    def constat(self, niveau: str, texte: str, ref: str, case: Optional[int] = None) -> None:
        self.constats.append({"niveau": niveau, "texte": texte, "ref": ref, "case": case})

    def suite(self, texte: str) -> None:
        if texte not in self.suites:
            self.suites.append(texte)


def lire_l_integrite(s: Situation, j: Journal) -> Dict[str, object]:
    """Atteinte par champ (⟷ L34, L35, L36) ; périmètre explicite (⟷ L39)."""
    examines = [c for c in CHAMPS if c in s.atteintes]
    non_examines = [c for c in CHAMPS if c not in s.atteintes]
    etablies = [c for c in examines if s.atteintes[c] == ETABLIE]
    possibles = [c for c in examines if s.atteintes[c] == POSSIBLE]
    indeterminees = [c for c in examines if s.atteintes[c] == INDETERMINEE]
    if etablies:
        I_faits = FALSE
        j.constat(INVALIDE, "Atteinte établie sur les faits : " + ", ".join(etablies) + ".", "L34")
        j.suite("Nommer l'atteinte sur ses faits ; proposer une protection adaptée et en vérifier l'effet.")
        j.suite("Examiner nécessité, proportion et possibilités d'action avant toute contrainte.")
    elif possibles or indeterminees:
        I_faits = UNKNOWN
        if possibles:
            j.suite("Atteinte possible (" + ", ".join(possibles) + ") : protection provisoire proportionnée, sans attendre un verdict.")
    elif examines and not non_examines:
        I_faits = TRUE                     # les 8 champs examinés, aucune atteinte
    else:
        I_faits = UNKNOWN                  # « aucune » sur une partie ne vaut pas examen des 8
    if etablies and AMONT in s.attribution:
        j.suite("La Dette en amont n'efface pas l'atteinte subie dans ses propres actes : les deux sont traitées.")
    return {"champs_examines": examines, "champs_non_examines": non_examines,
            "etablies": etablies, "possibles": possibles, "indeterminees": indeterminees,
            "reconnue_par_la_personne": s.reconnue_par_la_personne,
            "note": "La reconnaissance par la personne est notée ; elle ne décide pas.",
            "I_selon_les_faits": I_faits}


def lire_l_extension_moi(s: Situation, j: Journal, integrite: Dict[str, object]) -> str:
    """Cases 19 à 22 (⟷ L17, L37). Rend la contribution à L : TRUE · FALSE · UNKNOWN."""
    if s.paiement_avec_soi_etabli != TRUE:
        j.constat(INCONNU, "Codage Moi/Soi non étayé par des faits : aucun verdict n'en est déduit.", "L37")
        j.suite("Signaler le codage Moi/Soi non étayé ; demander le coût du refus effectivement établi.")
        return UNKNOWN
    if s.coin_moi is None or s.main_derriere == UNKNOWN:
        j.constat(INCONNU, "Paiement avec Soi : coin du Cube ou main derrière non établi.", "L17")
        return UNKNOWN
    # « Une atteinte » établie sur soi vaut autodestruction établie.
    autodestruction = TRUE if (integrite["etablies"] and s.atteinte_par_ses_propres_actes == TRUE) \
        else s.autodestruction_etablie
    if s.coin_moi == DESTRUCTION and s.main_derriere == TRUE:
        j.constat(INVALIDE, "Survie, pas Consentement — la Dette est à l'Agresseur.", "L17", 19)
        j.suite("Protéger la personne ; la Dette est à la main derrière.")
        return FALSE
    if s.coin_moi == DESTRUCTION:
        j.constat(INVALIDE, "Survie, pas Consentement — l'Obligation change de tête.", "L17", 20)
        j.suite("Assister la personne en péril.")
        return FALSE
    if s.main_derriere == TRUE:
        j.constat(INVALIDE, "Survie, pas Consentement — la Dette va à qui a imposé l'attente.", "L17", 21)
        j.suite("Protéger la personne ; la Dette va à qui a imposé l'attente.")
        return FALSE
    # Case 22 : trois branches ; Dette en amont et Devoir de Soin dans tous les cas.
    j.suite("La Dette est en amont, chez le milieu qui n'accueille pas.")
    j.suite("Devoir de Soin, sans Enfermement.")
    if autodestruction == TRUE:
        j.constat(INVALIDE, "Survie, pas Consentement — autodestruction établie ; la Dette reste en amont.", "L17", 22)
        return FALSE
    if autodestruction == FALSE:
        j.constat(VALIDE, "Réel, sous contrainte — autodestruction écartée ; la Dette est en amont.", "L17", 22)
        return TRUE
    j.constat(INCONNU, "Autodestruction indéterminée : à instruire — jamais présumée, jamais effacée.", "L17", 22)
    return UNKNOWN


def lire_le_consentement(s: Situation, j: Journal, integrite: Dict[str, object]) -> str:
    """Rend L pour une action à consentement requis, calculée depuis les conditions (⟷ L05, L06, L31)."""
    parts: List[str] = []

    # La réponse : prioritaire pour l'action, sans arrêter la lecture (⟷ L38)
    if s.reponse == NON:
        j.constat(INVALIDE, "Refus explicite : le Non suffit.", "L38")
        j.suite("Respecter le refus immédiatement ; les autres inconnues ne le rendent pas conditionnel.")
        parts.append(FALSE)
    elif s.reponse == RETRAIT:
        j.constat(INVALIDE, "Accord retiré : il ne vaut plus pour la suite.", "L38")
        j.suite("Cesser de s'appuyer sur l'accord précédent.")
        j.suite("Examiner séparément les obligations de réparation déjà établies.")
        parts.append(FALSE)
    elif s.reponse == INDETERMINE:
        j.constat(INCONNU, "Réponse non établie : aucun Oui n'est présumé.", "L15")
        parts.append(UNKNOWN)

    attributions = set(s.attribution) or {UNKNOWN}
    if s.pression_exploitee == TRUE:
        attributions.add(DEMANDEUR)          # sans effacer un UNKNOWN restant (⟷ L14)

    # V (⟷ L11)
    if s.veracite == MENSONGE:
        j.constat(INVALIDE, "Information non loyale : un Oui basé sur un Mensonge n'a pas de Valeur.", "L11")
        j.suite("Rétablir l'information loyale ; établir les responsabilités.")
        parts.append(FALSE)
    elif s.veracite == UNKNOWN:
        j.constat(INCONNU, "Véracité non établie.", "L15")
        parts.append(UNKNOWN)

    # Cadre des 18 cases, pour chaque main (⟷ L13, L14, L29)
    if s.prix_du_refus in (SUPERFLU, NECESSAIRE, VITAL):
        for a in sorted(attributions & {PERSONNE, AMONT, DEMANDEUR}):
            if s.veracite in (VERITE, MENSONGE):
                case, niveau, verdict = TABLE_18[(s.veracite, s.prix_du_refus, a)]
                j.constat(niveau, verdict, "L13", case)
                parts.append(FALSE if niveau == INVALIDE else TRUE)
            j.suite(SUITES_PAR_SOURCE[a])
    elif s.prix_du_refus == UNKNOWN:
        j.constat(INCONNU, "Ce avec quoi le refus se paie n'est pas établi.", "L15")
        parts.append(UNKNOWN)
    if UNKNOWN in attributions:
        j.constat(INCONNU, "Attribution du coût non établie (en tout ou en partie).", "L15")
        parts.append(UNKNOWN)
    if DEMANDEUR in attributions and s.prix_du_refus not in (SUPERFLU, NECESSAIRE, VITAL):
        parts.append(FALSE)                   # coût fabriqué par le demandeur

    # Extension Moi (⟷ L17, L37)
    if s.prix_du_refus == MOI or SOI in attributions:
        parts.append(lire_l_extension_moi(s, j, integrite))
    elif integrite["etablies"] and s.atteinte_par_ses_propres_actes == TRUE:
        # Atteinte établie sur soi = autodestruction établie (⟷ L17)
        j.constat(INVALIDE, "Survie, pas Consentement — atteinte établie sur soi, par ses propres actes.", "L17")
        j.suite("Devoir de Soin, sans Enfermement ; rechercher la Dette (en amont, ou à la main derrière si elle est établie).")
        parts.append(FALSE)

    # Refus praticable : examiné sans attendre la véracité (⟷ L10, L18, L31)
    if s.refus_possible == FALSE:
        j.constat(INVALIDE, "Le refus n'est pas possible : pas de choix libre.", "L10")
        parts.append(FALSE)
    elif s.refus_possible == PARTIEL:
        j.constat(INCONNU, "Érodé : le Non n'est possible qu'en partie.", "L18")
        j.suite("Réorganiser ce qui limite le Non avant de lire le Oui.")
        parts.append(UNKNOWN)
    elif s.refus_possible == UNKNOWN:
        j.constat(INCONNU, "Possibilité de refuser non établie.", "L15")
        parts.append(UNKNOWN)

    if s.pression_exploitee == TRUE:
        j.constat(INVALIDE, "Pression exploitée pour obtenir l'accord.", "L13")
        parts.append(FALSE)
    elif s.pression_exploitee == UNKNOWN:
        j.constat(INCONNU, "Pression exploitée non établie.", "L15")
        parts.append(UNKNOWN)

    if s.refus_entraine_atteinte == TRUE:
        j.constat(INVALIDE, "Coût du Non > 0 : refuser entraîne une attaque ou un abandon qui entrave la liberté.", "L12")
        parts.append(FALSE)
        if s.oui_pour_eviter_atteinte == TRUE:
            j.constat(INVALIDE, "Accord contraint : un Oui pour échapper à l'oppression n'est pas un Oui librement choisi.", "L28")
    elif s.refus_entraine_atteinte == UNKNOWN:
        j.constat(INCONNU, "Coût du Non inconnu : inconnu n'est pas zéro.", "L15")
        parts.append(UNKNOWN)
    if s.refus_entraine_atteinte != TRUE and s.oui_pour_eviter_atteinte == TRUE:
        j.constat(INCONNU, "Écart à éclaircir : un Oui donné pour éviter une atteinte que le refus n'entraînerait pas "
                  "(ou pas établie). Qu'est-ce que la personne pensait devoir subir si elle disait non, "
                  "et qu'avons-nous pu établir à ce sujet ?", "L28")
        parts.append(UNKNOWN)

    if s.reponse == OUI:
        for nom, valeur in (("Accord explicite", s.accord_explicite), ("Compréhension", s.comprehension),
                            ("Périmètre déterminé", s.perimetre_determine),
                            ("Possibilité de retirer l'accord", s.retrait_possible)):
            if valeur == FALSE:
                j.constat(INVALIDE, f"{nom} : absent.", "L06")
            elif valeur == UNKNOWN:
                j.constat(INCONNU, f"{nom} : non établi.", "L06")
            parts.append(valeur)

    if DEMANDEUR in attributions or s.veracite == MENSONGE or s.pression_exploitee == TRUE:
        j.suite(PARDONNANCE)
    if any(c["niveau"] == INCONNU for c in j.constats):
        j.suite("Clarifier les conditions, sans présumer l'accord.")
    return et3(*parts) if parts else UNKNOWN


def libelle_consentement(s: Situation, L: str, j: Journal) -> str:
    """Le libellé est produit APRÈS le calcul de L ; il ne le décide jamais (⟷ L31)."""
    if not s.consentement_requis:
        return "Sans objet : obligation imposée, examinée par sa justification (pas consentie pour autant)"
    if s.reponse == NON:
        return "Absent — refus explicite : le Non suffit"
    if s.reponse == RETRAIT:
        return "Retiré pour la suite"
    if L == FALSE:
        return "Non valide (faux établi ; les inconnues restantes sont gardées à part)"
    if L == UNKNOWN:
        if s.refus_possible == PARTIEL:
            return "Érodé — à réorganiser avant de lire le Oui"
        return "Non établi (à instruire, sans présumer l'accord)"
    if any(c["case"] in (13, 14, 16, 17, 22) for c in j.constats):
        return "Réel, sous contrainte"
    return "Établi dans le périmètre"


def evaluer_protection(s: Situation, j: Journal) -> Optional[Dict[str, object]]:
    """La mesure de protection, évaluée À PART : elle ne rend jamais l'action consentie (⟷ L22, L22b)."""
    if s.protection is None:
        return None
    valeurs = {k: s.protection.get(k, UNKNOWN) for k in CLES_PROTECTION}
    resultat = et3(*valeurs.values())
    if resultat == FALSE:
        j.suite("Mesure de protection non admissible telle quelle : "
                + ", ".join(k for k, v in valeurs.items() if v == FALSE) + ".")
    elif resultat == UNKNOWN:
        j.suite("Mesure de protection à instruire : fondement, autorité compétente, qui constate, qui décide, quand on réexamine, ce qui y met fin.")
    return {"statut": {TRUE: "Mesure admissible", FALSE: "Mesure non admissible", UNKNOWN: "Mesure à instruire"}[resultat],
            "par_critere": valeurs,
            "note": "La protection ne rend pas consentie l'action refusée : jamais un permis de passer outre."}


def admissibilite(conditions: Dict[str, str]) -> Dict[str, object]:
    """Les conditions se cumulent, ne se compensent pas (⟷ L23, L31)."""
    fausses = [k for k, v in conditions.items() if v == FALSE]
    inconnues = [k for k, v in conditions.items() if v == UNKNOWN]
    statut = "Non satisfaite" if fausses else "Non établie" if inconnues else "Satisfaite dans le périmètre examiné"
    return {"par_condition": conditions, "statut": statut,
            "conditions_fausses": fausses, "inconnues": inconnues}


def coherence(s: Situation) -> Dict[str, object]:
    """Vérifier les termes avant de calculer (⟷ L24, L25, L32)."""
    note = "Un rapport favorable ne suffit jamais, à lui seul, à établir l'admissibilité."
    if s.delta_I is None:
        return {"phi": NON_CALCULABLE, "legs": NON_CALCULABLE, "raison": "ΔI inconnu", "note": note}
    if s.delta_E is None:
        return {"phi": NON_CALCULABLE, "legs": NON_CALCULABLE, "raison": "ΔE inconnu", "note": note}
    denominateur, convention = s.delta_E, None
    if s.delta_E == 0:
        if not s.charge_minimale_declaree:
            return {"phi": NON_CALCULABLE, "legs": NON_CALCULABLE, "raison": "ΔE nul", "note": note}
        denominateur, convention = 1, "Charge minimale de 1 : convention nommée, pas observation."
    phi = s.delta_I / denominateur
    if s.t is None:
        legs, raison = NON_CALCULABLE, "t inconnu"
    elif not s.phi_constant:
        legs, raison = NON_CALCULABLE, "Φ varie : le Legs demande ∫ Φ dt"
    else:
        legs, raison = phi * s.t, None
    return {"phi": phi, "legs": legs, "raison": raison, "convention": convention, "note": note}


def solidarite(s: Situation, conditions: Dict[str, str]) -> Dict[str, object]:
    """S = Dⁿ, transmission en cascade (⟷ L26, L33) : hypothèse de modèle."""
    if s.D is None or s.n is None:
        return {"porteurs_generation_n": NON_CALCULABLE, "raison": "D ou n inconnu"}
    porteurs = s.D ** s.n
    conformes = all(v == TRUE for v in conditions.values())
    violation = any(v == FALSE for v in conditions.values())
    if conformes:
        caractere, lecture = "établi", f"{porteurs:g} porteurs attendus · diffusion solidaire"
    elif violation:
        caractere, lecture = "exclu", (f"{porteurs:g} porteurs attendus · diffusion non solidaire "
                                       "(un lien n'est pas libre ou une condition est violée)")
    else:
        caractere, lecture = "à établir", f"{porteurs:g} porteurs attendus · caractère solidaire à établir"
    return {
        "D": s.D, "n": s.n,
        "porteurs_generation_n": porteurs,          # = diffusion théorique
        "diffusion_theorique": porteurs,
        "tendance": "croît" if s.D > 1 else "se maintient" if s.D == 1 else "s'éteint",
        "liens_conformes": conformes,
        "caractere_solidaire": caractere,
        "solidarite_verifiee": porteurs if conformes else 0,
        "lecture": lecture,
        "note": ("Avec un porteur initial et un D moyen constant, Dⁿ est l'effectif attendu au n-ième relais "
                 "dans le modèle retenu, pas le total cumulé. Entre aMi·es, chaque lien est un relais ; "
                 "un lien imposé ne compte jamais. Vérifier (F) avant de diffuser."),
    }


def evaluer(s: Situation) -> Dict[str, object]:
    """La Règle d'Or du Phi Vivant appliquée à une situation (⟷ L01 : toute la Règle)."""
    erreurs = valider(s)
    if erreurs:
        raise EntreeInvalide("; ".join(erreurs))

    j = Journal()
    integrite = lire_l_integrite(s, j)
    if s.consentement_requis:
        L = lire_le_consentement(s, j, integrite)
    else:
        L = et3(s.obligation_fondement, s.obligation_perimetre, s.obligation_autorite_competente)
        if L != TRUE:
            j.suite("Obligation imposée : établir son fondement, son périmètre et l'autorité compétente.")
    protection = evaluer_protection(s, j)   # n'entre PAS dans L

    I = et3(s.I, integrite["I_selon_les_faits"]) if s.atteintes else s.I
    F_ = et3(s.F, FALSE) if s.veracite == MENSONGE else s.F
    conditions = {"F": F_, "I": I, "L": L, "R": s.R, "V": s.V}

    gardes = ["La dignité reste protégée, même en cas d'erreur, de dépendance ou d'incapacité partielle."]
    if s.depart:
        gardes.append("Le départ reste libre ; partir n'est pas automatiquement abandonner.")
        if s.responsabilites_dues_restantes != FALSE:
            j.suite("Traiter les responsabilités dues par une voie sûre, sans imposer contact ni réconciliation.")

    return {
        "situation": s.description,
        "admissibilite": admissibilite(conditions),
        "consentement": {"statut": libelle_consentement(s, L, j), "L": L, "constats": j.constats},
        "integrite": integrite,
        "protection": protection,
        "suites_a_examiner": j.suites,
        "coherence": coherence(s),
        "solidarite": solidarite(s, conditions),
        "gardes": gardes,
    }


if __name__ == "__main__":
    import json
    exemple = Situation(
        description="On te propose un café ; tu peux dire non, rien ne change.",
        F=TRUE, I=TRUE, R=TRUE, V=TRUE,
        accord_explicite=TRUE, comprehension=TRUE, perimetre_determine=TRUE, retrait_possible=TRUE,
        veracite=VERITE, prix_du_refus=SUPERFLU, attribution={PERSONNE},
        refus_possible=TRUE, pression_exploitee=FALSE, refus_entraine_atteinte=FALSE,
    )
    print(json.dumps(evaluer(exemple), ensure_ascii=False, indent=2))