— ouvrage —

La programmation Neuro-Symbolique en langage VVL

Principes
Langage
Algèbre
Planification
& Applications
VAILS · VVL 5.1.11
VVL
VAILS
— ouvrage technique —

Programmation neuro-symbolique en VVL

Du langage naturel au planning vérifié.
8
parties
34
chapitres
+1
annexe
600+
builtins
~95%
fidélité N-S

Ce livre présente VVL, un langage formel et exécutable conçu pour relier la compréhension du langage naturel à la puissance des planificateurs et solveurs. Il expose une approche neuro-symbolique complète, du texte libre jusqu'au planning vérifié — en passant par la logique de Frege, l'ontologie d'Edward Zalta, le pont Prolog, le RAG natif, et la compilation vers CP-SAT.

Commencer la lecture Annexe builtins
Parties : I · Fondements II · Langage III · LLM IV · Symbolique V · Neuronal VI · Pipelines VII · Avancés VIII · Profondeur Annexe
I.

Histoire et fondements

3 chapitres · 23 pages · de Frege au neuro-symbolique
1Chapitre

Histoire des paradigmes de l'IA

Une chronologie raisonnée — symbolique, connexionnisme, statistique, deep learning

Retrace les grandes époques de l'intelligence artificielle : l'âge symbolique (années 1960-80, MYCIN, Prolog), l'ère connexionniste (1980-2000), le règne statistique (2000-2015), puis l'avènement du Deep Learning et des LLM (2015 à aujourd'hui). Met en lumière les forces et faiblesses de chaque paradigme et l'émergence du besoin neuro-symbolique comme synthèse nécessaire.

MYCINPrologConnexionnismeLLM
2Chapitre

Fondements théoriques du neuro-symbolique

Frege, Zalta et le pattern d'oscillation

Présente la logique de Frege comme socle de la formalisation, la théorie des objets abstraits d'Edward Zalta comme cadre ontologique, et le pattern d'oscillation entre couches neuronale et symbolique. Pose les exigences techniques : intégration des deux mondes en première classe, partage d'objets, traçabilité.

FregeZaltaOscillationPremière classe
3Chapitre

VAILS et VVL : un langage conçu pour le neuro-symbolique

L'écosystème, la syntaxe Lisp-like, l'homoiconicité

Introduit l'écosystème : objectif d'un langage où neuronal et symbolique cohabitent en première classe, choix d'une syntaxe Lisp-like (homoiconicité comme clé de voûte), comparaison directe avec Python+LangChain — pourquoi ~99% de syntaxe valide LLM contre 80-90% pour Python.

LispHomoiconicitévs LangChain
II.

Le langage VVL

3 chapitres · 27 pages · syntaxe, fonctionnel, OO unifié
4Chapitre

Syntaxe et types fondamentaux

La grammaire en quelques pages

Forme préfixe [op args], opérateurs infix, quasiquote/unquote, interpolation ${...}, types primitifs, accesseurs pointés, conventions d'affectation $var = expr. Tout VVL tient dans une grammaire compacte mais expressive.

PréfixeQuasiquoteInterpolationAccesseurs pointés
5Chapitre

Programmation fonctionnelle

Lambdas, ordre supérieur, parallélisme, lazy

Lambdas, map / filter / reduce, for, pmap pour le parallélisme, évaluation paresseuse, opérateurs de tolérance ~> qui transforment toute exception en une valeur fallback inspectable.

Lambdaspmap~>Lazy
6Chapitre

Programmation orientée objet

Classes, mixins avec MRO, protocoles

Système OO unifié autour de VVL_Instance : classes, héritage, mixins (avec ordre de résolution méthode), protocoles (interfaces), méthodes dynamiques. Pose le socle pour les chapitres ontologiques et concepts réifiés des parties suivantes.

VVL_InstanceMixinsMROProtocoles
III.

LLM co-processeur

4 chapitres · 33 pages · 20 opérateurs sémantiques, génération, réification
7Chapitre

Les opérateurs sémantiques (vingt opérateurs)

L'algèbre neuronale en première classe

Présentation complète des vingt opérateurs neuro-symboliques : /, %, ?, ~~, *, +, == et leurs cousins. Cache sémantique transparent, principe de mémoïsation order-insensitive : la machine apprend à reconnaître que deux requêtes équivalentes le sont.

20 opérateursCache sémantiqueMémoïsation
8Chapitre

Génération de code par LLM : opérateur @

Premier niveau d'autonomie programmable

Génération ponctuelle d'une lambda depuis un exemple plus une description, exécution locale répétée sans nouvel appel LLM. Le coût de l'IA paie une fois ; l'exécution suit ensuite la rigueur d'un binaire compilé.

@LambdaLocal
9Chapitre

Réification de concepts [@ "..."]

Du nom au concept manipulable

Transformation d'un nom de concept en objet VVL_ConceptEntity manipulable. Propriétés découvertes paresseusement (lazy loading), cache à trois niveaux (mémoire / objet / disque), modes lazy versus bootstrap pour préchauffer ou découvrir au fil de l'eau.

VVL_ConceptEntityLazyCache 3 niveaux
10Chapitre

L'opérateur §§ : compilation NL + [generic]

Du français au VVL exécutable

Résolution NL→VVL→exécution, mémorisation en keyword catalogue persistant, validation par tests. Une commande exprimée en langage naturel devient une fonction réutilisable, indexée, testée.

§§NL→VVLCatalogue
IV.

Pont symbolique

3 chapitres · 25 pages · Prolog, ontologies, opérateurs Zalta
11Chapitre

La base de connaissances Prolog

Prolog citoyen de première classe

Triangle VVL : LLM ↔ OO ↔ Prolog. Faits, règles, requêtes, six modes de query, pont obj-assert qui projette toute instance VVL en faits Prolog. Le moteur logique parle directement aux objets et aux LLM.

Triangle VVLobj-assert6 modes
12Chapitre

Le système ontologique

Schémas, règles, mondes possibles

ontology:define avec annotations (required, default, min, max, type, enum), fromText et fromImage pour extraire automatiquement, ontology:rule avec priorités, infer versus infer-fixpoint (cascade jusqu'au point fixe), mondes éphémères ontology:in-world avec fork et restauration auto.

ontology:defineinfer-fixpointMondesPriorités
13Chapitre

L'algèbre des opérateurs Zalta

Huit opérateurs en quatre paires

Quatre paires symbolique/hybride (==/~~, */**, +/++, / / //), implémentés comme mixin ZaltaOperators, dispatch via MRO. ~~ à quatre niveaux de matching, mode IS-A holistique avec un seul appel LLM par paire de concepts.

8 opérateursZaltaOperatorsIS-A holistique
V.

Pont neuronal

4 chapitres · 35 pages · RAG, extraction, Gherkin, induction
14Chapitre

RAG et recherche sémantique

Pipeline complet en trois phases

Indexation, retrieval, génération. Vingt-quatre builtins RAG, quatre modes de requête : ragSearchContext gratuit, ragAskSimple, ragAsk hybride, ragExtractJson. Façade genius pour interroger la documentation VVL elle-même.

24 builtins4 modesgenius
15Chapitre

Extraction structurée par LLM

40 lignes au lieu de 500

Trois opérateurs sémantiques d'extraction : / liste, % objet, ? question/réponse. Pattern [JSON [STRING source / [§ "..."]]], vision IA via pdfToImages, distinction extraction libre vs ontology:fromText typé. Pipeline e-commerce sept étapes en quarante lignes contre cinq cents en Python.

/ % ?pdfToImages40 lignes
16Chapitre

Gherkin et ontologie dynamique

Du schéma écrit au schéma déduit

Inversion paradigmatique : on ne décrit plus le schéma, on le laisse se déduire. Format Gherkin (Background + Scenarios), ontology:loadGherkin (transpilation), ontology:context (déduction depuis échantillons). Pipeline cinq phases neuro-symboliques, auto-apprentissage continu.

GherkinSchéma déduit5 phases
17Chapitre

Apprentissage inductif de règles

Conjecture vs preuve

Déduction (Prolog, prouve) versus induction (LLM, conjecture). Trois axes de qualité d'un dataset : variation, complexité, longueur. Induction libre versus ciblée par target_feature, validation croisée 70/30, gestion des conflits avec règles manuelles via priorités, pattern d'induction continue.

Inductiontarget_feature70/30
VI.

Pipelines en pratique

4 chapitres · 36 pages · médical, BTP, fraude
18Chapitre

L'oscillation neuro-symbolique formalisée

Quatre propriétés authentiques, quatre patterns canoniques

Alternance régulière, partage d'objets, traçabilité, complémentarité. Cycle élémentaire en quatre phases (Définir-Extraire-Inférer-Synthétiser), quatre patterns canoniques. Métriques cost/latency/fidelity : LLM monolithique 70-85%, RAG 85-90%, neuro-symbolique complet ≥95%.

DEIS4 patterns≥95%
19Chapitre

Diagnostic médical différentiel

Cent lignes pour cinq syndromes

Système complet de cent lignes basé sur le tutoriel Zalta-médical. Mapping syndrome=abstrait / patient=concret / diagnostic=satisfies. Schéma Patient (16 attributs catégoriques) + 5 archétypes (Grippe, COVID-19, Pneumonie, Allergie, Embolie), matrice de scoring 5×5, règles de priorité (AlerteSpO2, RisqueAge, RisqueCritique), simulation thérapeutique par mondes possibles.

Zalta-médical5 archétypesMondes possibles
20Chapitre

Système de devisage BTP de bout en bout

54 PDF historiques, 100% de précision

Architecture quatre fichiers (config / learn / generate / batch_classify), trois archétypes Zalta en mode lazy (TERRASSE, REPARATION, COOLROOF). Apprentissage initial sur 54 PDF historiques, génération à la demande avec deux appels LLM, devis chiffré « 25 m² → 18 000 € HT / 19 800 € TTC ». Distribution observée 38/10/6 (précision 100%), quatre niveaux de compréhension Zalta.

54 PDF3 archétypes100% précision
21Chapitre

Détection de fraude transactionnelle

Temps réel, <100ms, DSP2

Contraintes temps réel (latence <100ms, milliers de transactions/seconde, conformité DSP2). Ontologie Transaction avec attributs extraits versus déduits. Cascade trois règles avec protection HIGH→MEDIUM, performance via cache sémantique + concurrence pmap (facteur 1000 séquentiel→parallèle+cache), résilience par circuit-breaker ~> avec fallback regex et isolation try/catch.

<100msDSP2×1000Circuit-breaker
VII.

Autonomie & systèmes avancés

6 chapitres (22–27) · agents, expert flou, atomes, contraintes, génétique, ILP
22Chapitre

Agents autonomes : [agent] et [architect]

Trois niveaux d'autonomie programmable

@ = une lambda. [agent] = boucle ReAct. [architect] = orchestration multi-agents. Boucle Reason-Act-Observe-Feedback détaillée, quatre patterns de composition agent + VVL. Étude de cas analyse de contrat (architect orchestre extraction + évaluations parallèles + synthèse). Homoiconicité comme clé de voûte (~99% syntaxe valide vs 80-90% Python).

[agent][architect]ReAct~99%
23Chapitre

Système expert et logique floue

T-normes, hedges, bootstrap NL one-shot

Quatre opérateurs flous infix (~&, ~|, ~!, ≈>), trois familles de T-normes (Zadeh défaut idempotent, probabiliste pour évidences indépendantes, Łukasiewicz pour logique stricte). Hedges linguistiques (very x², extremely x⁴, somewhat √x, slightly x^(1/3)), agrégateurs (wmean, most, few). Commandes [fuzzy:ontology] / [fuzzy:rule] / [expert] qui compilent NL → ontologie + règles + keyword opérationnel. Persistance via expert:save/load/list, étude de cas triage tickets multi-décisions.

~& ~| ~!T-normesHedges[expert]
24Chapitre

Optimisation par contraintes

Compiler VVL vers CP-SAT — et le planning opérationnel

Architecture en couches : VVL conceptuel → compilateur → CP-SAT/OR-Tools. Quatre principes : backend exposé, résolution sémantique au compile-time, artefacts inspectables, NL→VVL en couches. Douze formes du corps (decision, assert, soft, maximize, intent, lexicographic, all-different, cumulative, circuit, instance, for, scale), trois types de décisions (Integer, Enum, Fuzzy), diagnostic why-infeasible. Prolongé par le DSL planning:* (tâches, ressources, horizon, géographie geo:*) qui désucre vers optimize:* et réifie les affectations.

CP-SATOR-Tools12 formesplanning:*why-infeasible
25Chapitre

Le protocole d'atomes

Gating, policies et audit — couche d'introspection unifiée

Tout objet VVL devient un « atome » classable, hashable, traçable et gateable par policy : atom:trace, policy:check. Une couche d'introspection qui donne un contenu calculable au discours neuro-symbolique et permet de gater les candidats générés. Statut expérimental (branche experimental-grounded-protocol) — à vérifier dans le registre stable selon la version serveur.

atom:tracepolicy:checkgatingexpérimental
26Chapitre

Programmation génétique

Population, fitness, évolution et amélioration continue

Évolution de structures discrètes : genetic:population, genetic:evolve, genetic:best, genetic:lineage. Counter-store et corrections humaines (genetic:add-counter, genetic:fit-with-counter), front de genetic:pareto, atomes tracés et gating par policy. Le système devient auto-améliorant.

genetic:evolvecounter-storePareto
27Chapitre

ILP : programmation logique inductive

Induction de règles sound & complete (Learning From Failures)

Apprentissage de programmes logiques multi-clauses depuis des exemples positifs/négatifs : Learning From Failures (LFF), biais de recherche, θ-subsomption, greedy set-cover, ilp:learn. Bootstrap LLM (ilp:propose-bias, ilp:seed-hypotheses), contre-exemples et pont génétique (ilp:learn-with-counter, ilp:refine-with-ga). Troisième mode d'apprentissage de règles, sound & complete, complémentaire de l'induction LLM (ch. 17) et du génétique (ch. 26).

ilp:learnLFFθ-subsomptionsound & complete
VIII.

Le langage en profondeur

7 chapitres (28–34) · l'infrastructure qui fait de VVL une plateforme
28Chapitre

Méta-programmation, homoiconicité & helpers REBOL

Le code comme donnée

Le noyau réflexif : quote, load, evaluate, execute, dump, type-of, inspectWord. Le triangle méta-programmatique (stockage différé puis substitution-évaluation) et les helpers REBOL : collect/keep, attempt (erreur-comme-donnée), object. Sans cette couche, le code généré par un agent resterait inerte.

quoteevaluatecollect/keepattempt
29Chapitre

Dialectes : grammaires VVL embarquées

Parser des DSL métier

dialect:parse : définir et invoquer des grammaires pour parser des DSL métier. Le dialecte étend les données nommées du langage (inspectable), complémentaire de match/load. C'est ce qui rend transparente la compilation NL → système expert.

dialect:parseDSLvalidation au parse
30Chapitre

Modules : la frontière de package

Organiser et exporter du code VVL natif

module:def, [export …], scope isolé et accès qualifié Module:commande. Le triptyque d'extension : le dialecte étend les données, le module les commandes en VVL natif, le plugin les commandes en code externe signé.

module:defexportscope isolé
31Chapitre

Valeurs scalaires typées

Validation à la construction

EMAIL, URL, DATE, UUID, MONEY, DURATION, DATETIME : validation à la construction, mold/form, round-trip et normalisation. La division du travail : valeur typée vs concept ontologique vs dialecte.

EMAIL · URL · DATEmold/formround-trip
32Chapitre

Tests intégrés & auditabilité formelle

Le framework de test non-throwing

test:assert, test:equals, test:suite, test:summary : suites non-throwing pour auditer les règles induites (ch. 17, 26, 27). Quand l'assertion classique reste appropriée : invariants de production via error. Distinguer test:* / try / attempt / error.

test:suitenon-throwingaudit des règles
33Chapitre

Plugins signés Ed25519

La chaîne de confiance du code externe

Flux de confiance auteur / administrateur / workspace, magasin de clés, double garde anti-TOCTOU. Modèle cryptographique Ed25519 : signature hors-ligne, digest canonique, dégradation gracieuse. Le bundle .vvlplugin (manifeste, entrée, signature) et le SDK.

Ed25519anti-TOCTOU.vvlplugin
34Chapitre

Synthèse de la plateforme

Trois paradigmes d'écriture des règles, sept couches

Vue d'ensemble finale : les trois paradigmes d'écriture des règles (déduction Prolog, induction LLM/ILP, contraintes) et les sept couches de la plateforme. VVL passe du statut de langue complète à celui de plateforme composable, organisable, auditable et extensible.

3 paradigmes7 couchesplateforme
A.

Annexe : référence des builtins

600+ builtins par familles · VScript · plugins signés
A.1Partie 1

Conventions, opérateurs et noyau

La fondation du langage

Conventions du langage (affectation $var = expr, booléens 1/0, quasiquote/unquote, interpolation, accesseurs pointés), opérateurs (arithmétiques, comparaisons, logiques, flous), contrôle de flux RAW, ordre supérieur (map, pmap, filter, reduce, for), listes, chaînes, conversion/math, JSON/XML (littéraux <{}> <[]> <<>>), filesystem jail-protégé, OO (class/mixin/protocol), fibers, concurrence (promise, channel, semaphore, mutex), administration, logs, persistance objet (SQLite + Prolog).

Filesystem jailConcurrenceobj-* + PrologRAW builtins
A.2Partie 2

Logique floue, IA, RAG, Prolog, écosystème

Les couches hautes du serveur

Commandes IA et opérateurs sémantiques, RAG, Prolog, système ontologique (ontology:*, 37), réification de concepts, résolution NL→VVL et catalogue de génériques (generic:*, 11), approximation calculable (approximation:*, 10), logique floue & expert (fuzzy:*, 14), optimisation (optimize:*) & planning (planning:*, 27), géo (geo:*/route:*), génétique (genetic:*, 10), ILP (ilp:*, 10), atomes & policies, dialectes & modules, tests (test:*), CSV/BATCH, bases SQL, et les connecteurs (Office 29, PDF 11, image 10, http/web, Selenium, email, Google, MCP, hypervisor, plugins 23, clients ProSuite/Tekitisy/VDOM).

37 ontology27 planningilp · genetic29 office23 plugins
A.3Annexe D

VScript, le langage embarqué

VBScript modernisé, sandboxé, signable

Langage embarqué dérivé de VBScript et modernisé (additions Tier 1 en VAILS 5.18, Tier 3 en 5.19, toutes additives). Syntaxe, opérateurs et précédence, contrôle de flux, procédures, OO ; modernisations : littéraux […]/{…}, chaînes interpolées $"…", ?? (coalescing) et ?. (optional chaining), IIf, Return, court-circuit conditionnel. Appelable depuis VVL via [vscript "…"], libraries [use …], objet hôte ws (ws.vvl, ws.csv, ws.mem…), interop OO par proxys vivants.

[vscript "…"]?? · ?.ws hôteTier 1/3
A.4Annexe C

Système de plugins signés

Architecture des fichiers & chaîne de confiance

Le SDK et la chaîne de confiance : vvl_plugin_sdk.py, vvl-plugin-sign.py, vvl_config.py, intégration moteur ; bundle .vvlplugin (manifeste, entrée, signature Ed25519). Secrets et profils de connecteurs (plugin-secret-*, plugin-login, plugin-audit), trust de clés (plugin-trust-add, tiers standard/high).

.vvlpluginEd25519plugin-trustsecrets
Explorer les 600+ builtins →
❦ ❦ ❦