01_core_engine

Core Engine — Le Socle du Moteur

🎯 Objectif

Le Core Engine contient toute la logique de raisonnement agnostique du domaine. C'est le socle sur lequel reposent tous les domaines d'application.

📁 Structure

01_core_engine/
├── graph/          # Structure de graphe (nœuds, arêtes)
├── reasoning/      # Moteurs de raisonnement (path, causal, constraint)
├── decision/       # Logique de décision (bornes, pivots)
└── agent/          # Agent autonome générique

🔧 Modules

Graph (graph/)

Structure de base du graphe :

• Graph : conteneur principal
• Node : nœud (fait, hypothèse, objectif)
• Edge : arête (relation logique)
• Types : types et enums (NodeType, EdgeType, ReasoningStatus)

Reasoning (reasoning/)

Moteurs de raisonnement :

• PathReasoning : raisonnement par chemin
• CausalReasoning : raisonnement causal (propagation)
• ConstraintSolver : raisonnement par contraintes
• MultiPathReasoning : raisonnement multi-chemins

Decision (decision/)

Logique de décision (à venir) :

• Bornes de décision (B, B')
• Évaluation de convergence
• Calcul de confiance

Agent (agent/)

Agent autonome générique, inspiré de Duan et al. (2025) :

• AutonomousAgent : agent sans tri global
• Frontier : gestion de la frontière décisionnelle (ensemble S)
• Pivots : sélection de pivots structurants (ensemble P)
• BoundedReasoning : raisonnement par bornes (B, B')

Référence : Duan, R., Mao, J., Mao, X., Shu, X., & Yin, L. (2025). Breaking the Sorting Barrier for Directed Single-Source Shortest Paths. arXiv:2504.17033v2.

🎓 Utilisation

Créer un Graphe

from 01_core_engine.graph import Graph, Node, Edge, NodeType, EdgeType, ReasoningStatus

graph = Graph()
node_a = Node(id="A", content="Fact", node_type=NodeType.FACT)
node_b = Node(id="B", content="Goal", node_type=NodeType.GOAL)
graph.add_node(node_a)
graph.add_node(node_b)
edge = Edge(source_id="A", target_id="B", edge_type=EdgeType.SUPPORTS)
graph.add_edge(edge)

Raisonner

from 01_core_engine.reasoning.path_reasoning import PathReasoning

path_reasoning = PathReasoning(graph)
paths = path_reasoning.find_reasoning_path("A", "B")

Utiliser un Agent

from 01_core_engine.agent import AutonomousAgent

agent = AutonomousAgent(graph)
result = agent.decide(goal="B")

🔑 Principes

Agnostique Domaine

Le Core Engine ne connaît aucun domaine spécifique. Il fournit uniquement :

• La structure de graphe
• Les moteurs de raisonnement
• L'agent autonome générique

Déterministe

Tous les résultats sont déterministes :

• Même graphe + même requête = même résultat
• Pas de magie noire
• Chaque décision est justifiable

Explicable

Chaque résultat inclut :

• Le chemin de raisonnement
• Les pivots utilisés
• La justification structurée

📚 Prochaines Étapes

1. Explorer graph/ pour comprendre la structure
2. Explorer reasoning/ pour comprendre les moteurs
3. Explorer agent/ pour comprendre l'agent autonome
4. Passer à 02_training_framework/ pour apprendre à entraîner