From 75283c407c4d332001cc2ca3bfeaef17470d337c Mon Sep 17 00:00:00 2001 From: jsboige Date: Mon, 21 Sep 2026 20:48:45 +0200 Subject: [PATCH] feat(notebook-tools,#17093): garde d'atteignabilite de la chaine de navigation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `check_notebook_navlinks.py` verifie que chaque cible de lien EXISTE (404). Il ne verifie pas que la chaine ATTEINT chaque notebook. Les deux proprietes divergent exactement sur un notebook insere dont les voisins pointent encore l'un vers l'autre : `12b` n'a alors aucun lien entrant, tous les liens resolvent, le garde 404 est vert -- et le notebook est inatteignable. C'est la classe qui a laisse passer QC-Py-12b et QC-Py-23c (#17093), corriges comme INSTANCES par #17277 mais jamais comme CLASSE. Le garde neuf la detecte sur le corpus reel : il designe ces deux notebooks la, sur main, tant que #17277 n'est pas merge. Mesure : 1353 notebooks au graphe, 70 series jugees, 450 findings (396 entrees orphelines, 54 notebooks inatteignables), 138 dossiers non juges, 18 series a chaine bouclee. Le vocabulaire d'arete a ete CALIBRE par mesure, pas devine : sur un echantillon de 30 orphelins, 12 portaient une reference entrante d'apres grep -- instruites une par une, toutes de la prose, une liste « voir aussi » ou un lien de jumeaux, donc 0 faux positif. Trois conventions manquantes ont ete trouvees ainsi et ajoutees (fleches, marqueur hors du lien, marqueur en cellule), chacune parce qu'elle fabriquait un faux orphelin. Livrable volontairement hors `.github/workflows/` : le cablage CI est signale, pas pose. Co-Authored-By: Claude Sonnet 5 --- .../check_notebook_nav_chain.py | 501 ++++ .../tests/test_check_notebook_nav_chain.py | 373 +++ scripts/tests/baseline_nb_nav_chain.json | 2328 +++++++++++++++++ 3 files changed, 3202 insertions(+) create mode 100644 scripts/notebook_tools/check_notebook_nav_chain.py create mode 100644 scripts/notebook_tools/tests/test_check_notebook_nav_chain.py create mode 100644 scripts/tests/baseline_nb_nav_chain.json diff --git a/scripts/notebook_tools/check_notebook_nav_chain.py b/scripts/notebook_tools/check_notebook_nav_chain.py new file mode 100644 index 0000000000..0bdf235fec --- /dev/null +++ b/scripts/notebook_tools/check_notebook_nav_chain.py @@ -0,0 +1,501 @@ +#!/usr/bin/env python3 +"""Check that every notebook of a series is REACHABLE through its navigation chain. + +Pourquoi cet outil existe +------------------------- +`check_notebook_navlinks.py` verifie que chaque cible de lien **existe** (404). +Il ne verifie pas que la chaine de navigation **atteint** chaque notebook. Les +deux proprietes divergent exactement sur un notebook **insere** dont les voisins +pointent encore l'un vers l'autre : + + avant : 12 -> 13 13 -> 12 (chaine intacte, 12b invisible) + apres : 12 -> 12b 12b -> 13 13 -> 12 + +Dans l'etat « avant », `12b` n'a **aucun lien entrant**. Tous les liens de la +serie resolvent, donc le garde 404 est **vert**, et pourtant aucun lecteur ne +peut atteindre `12b` en suivant la navigation. C'est ce qui a laisse passer +`QC-Py-12b` et `QC-Py-23c` sur toute la serie QC-Py (corrige par #17277 en tant +qu'**instance**, jamais en tant que **classe**). + +Comment ca marche +----------------- +Le depot est lu comme un graphe oriente : noeuds = notebooks git-tracked sous +`MyIA.AI.Notebooks/`, aretes = liens de navigation d'un notebook vers un autre +`.ipynb`. Une **serie** = le dossier parent d'un notebook. + +Pour chaque serie S on calcule : + +- `entries(S)` : les notebooks de S sans **aucun lien entrant** (depuis n'importe + ou dans le depot). Une serie pedagogique a **un** point d'entree : la premiere + notebook. Deux entrees = un notebook que rien ne relie a la chaine. +- `unreachable(S)` : les notebooks de S **non-entries** qu'aucune entree + n'atteint (ilot, cycle detache). Calcul par parcours en largeur. +- `wrapped` : les series ou **tout** notebook a un lien entrant (la chaine + **boucle** : le « suivant » du dernier pointe le premier). C'est une + convention legitime, pas un cas non jugeable — la serie est jugee depuis son + depart le plus couvrant. Les declarer non jugeables laissait **18 series** + hors du garde (mesure du 2026-09-21). + +`entries` et `unreachable` sont **disjoints** : une entree orpheline est +rapportee une seule fois, comme entree. + +Ce qui est juge, et ce qui ne l'est pas +--------------------------------------- +Une serie n'est jugee que si elle **exhibe** une convention de navigation (au +moins une arete interne). Un dossier de recherche, de scripts ou de brouillons +n'en a aucune : le juger produirait un finding par notebook, tous faux. Ces +dossiers sont ecartes, **comptes et publies** (`not_judged`), jamais ecartes en +silence. + +L'arete est reconnue a **trois portees**, chacune ajoutee apres mesure d'un faux +orphelin (detail dans `_looks_nav` et `NAV_LINE_MARKERS`) : le texte du lien, la +ligne entiere, la cellule. Ce qui n'est **pas** une arete, volontairement : une +mention en prose (nom de fichier entre `backticks`), une liste « voir aussi » +titree, un lien de parite de jumeaux C#/Python. Ce sont des references, pas la +chaine de navigation — et c'est la chaine qui est jugee. + +**Calibration (mesure du 2026-09-21)**, sur un echantillon aleatoire de 30 +orphelins declares : 12 portaient une reference entrante d'apres `grep`. Les 12 +ont ete instrutes un par un — **toutes** sont de la prose, une liste « voir +aussi » ou un lien de jumeaux, donc **aucun faux positif** dans l'echantillon. +Le taux brut de `grep` (12/30) est une borne **superieure**, pas le taux de FP. +Residu connu et assume : une rangee d'en-tete de type « Ladder L1 · L2 · L3 » +sans mot de navigation n'est pas reconnue comme une arete. + +Ce que cet outil ne dit PAS +--------------------------- +- Il ne juge pas la **qualite** d'un ordre : une chaine qui passe par tous les + notebooks dans un ordre pedagogicalement absurde est « atteignable ». +- Il ne remplace pas le garde 404 : les deux sont necessaires ensemble. + +Modes (convention check_notebook_navlinks.py / check_docs_links.py) +------------------------------------------------------------------ + python check_notebook_nav_chain.py # scan complet, exit 1 si findings + python check_notebook_nav_chain.py --baseline # ecrit scripts/tests/baseline_nb_nav_chain.json + python check_notebook_nav_chain.py --check # check vs baseline (exit 1 si NEW) + python check_notebook_nav_chain.py --family Sharp # limiter le RAPPORT a une famille + python check_notebook_nav_chain.py NB.ipynb # limiter le rapport a la serie de ce notebook + python check_notebook_nav_chain.py --json # sortie machine + python check_notebook_nav_chain.py --quiet # sortie minimale (CI) + +Exit codes +---------- + 0 = aucun finding (ou mode --check : aucun NEW finding) + 1 = findings presents (ou NEW findings vs baseline) + 2 = erreur d'execution (aucun notebook, argument introuvable) + +Voir aussi +---------- +- scripts/notebook_tools/check_notebook_navlinks.py (garde 404, source unique + de l'extraction de liens et de la decouverte : ce tool l'importe au lieu de + redupliquer sa logique) +- #17093 (chaine QC-Py cassee), #17277 (l'instance corrigee) +""" +import argparse +import json +import sys +from collections import defaultdict, deque +from pathlib import Path + +# Source unique de l'extraction de liens, de la resolution de cible et de la +# decouverte de notebooks : on importe le garde 404 au lieu de redupliquer sa +# logique (meme convention que son propre `from notebook_walk import SKIP_DIRS`). +# Si ces primitives divergent un jour, les deux gardes divergeraient ensemble -- +# ce qui est le comportement recherche. +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from check_notebook_navlinks import ( # noqa: E402 + LINK_PATTERN, + NOTEBOOKS_ROOT, + REPO_ROOT, + _iter_notebooks, + _resolve_target, +) + +BASELINE_PATH = REPO_ROOT / "scripts" / "tests" / "baseline_nb_nav_chain.json" + +# Vocabulaire de navigation. Base sur celui de check_notebook_navlinks.py (ou il +# sert a CLASSER un lien casse), **complete par mesure** : il sert ici a decider +# si un lien est une ARETE du graphe, et un mot manquant fabrique un faux +# orphelin. Mesure du 2026-09-21, sur un echantillon de 30 orphelins declares : +# 13 portaient une reference entrante, dont la rangee de nav canonique ecrite +# avec des FLECHES plutot que des chevrons -- +# +# [← MGS-7b LandscapeMultidim](MGS-07b-LandscapeMultidim.ipynb) · [MGS-8 LandscapeExplorer →](MGS-08-LandscapeExplorer.ipynb) +# +# ni « precedent »/« suivant » ni marqueur `Navigation` dans la cellule : la +# rangee etait donc invisible au detecteur. Les fleches sont ajoutees ici. +# Les autres references de l'echantillon sont de la PROSE (un nom de fichier en +# `backticks`) ou des listes « voir aussi » titrees : elles ne sont pas des +# aretes, et ne doivent pas le devenir -- c'est la chaine de navigation qui est +# jugee, pas la simple mention. +NAV_KEYWORDS = ( + "precedent", "précédent", "prec", "préc", + "suivant", "suivante", "next", "prev", + "navigation", "index", ">>", "<<", + "←", "→", "↑", "↓", # ← → ↑ ↓ +) + +# Sous-ensemble employe pour scanner la LIGNE ENTIERE (et non le seul texte du +# lien). Mesure du 2026-09-21 : `MGS-10-CenterBias` ecrit sa rangee de nav ainsi +# +# **Série MetaGeneticSharp** | Précédent : [MGS-9 - Relief Everest](MGS-09-EverestRelief.ipynb) | [↑ Série MGS](README.md) +# +# -- le mot « Précédent » est sur la ligne, HORS du texte du lien, et le texte du +# lien est le titre du voisin. Scanner le seul `text+target` manquait l'arete. +# `index`/`prec`/`préc` sont EXCLUS de ce scan large : trop frequents en prose +# (« l'index de la liste », « precisement ») pour y servir de marqueur. +NAV_LINE_MARKERS = ( + "precedent", "précédent", "suivant", "suivante", "next", "prev", + "navigation", ">>", "<<", + "←", "→", "↑", "↓", +) + + +def _rel(path: Path) -> str: + """Chemin repo-relatif POSIX (stable cross-OS pour le baseline).""" + return path.relative_to(REPO_ROOT).as_posix() + + +def _looks_nav(text: str, target: str, line: str, cell_is_nav: bool) -> bool: + """True si le lien est une arete de navigation. + + Trois portees, parce que les trois conventions coexistent dans le depot et + qu'une portee trop etroite fabrique un faux orphelin (mesures du 2026-09-21) : + + 1. **le lien** — `[Suivant >>](13-foo.ipynb)` : le mot est dans le texte du + lien ou dans la cible. + 2. **la ligne** — `**Série MGS** | Précédent : [MGS-9 ...](MGS-09-....ipynb)` : + le mot est sur la ligne, HORS du lien, et le texte du lien est le titre + du voisin. Scan restreint a `NAV_LINE_MARKERS`. + 3. **la cellule** — le bloc canonique est une TABLE sous un titre, donc le + marqueur et les liens sont sur deux lignes differentes : + + ## Navigation + | [Sudoku-05-PSO](Sudoku-05-PSO-Csharp.ipynb) | | [Sudoku-07-...](...) | + + Ce qui n'est **pas** une arete, volontairement : une mention en prose (nom de + fichier entre `backticks`), une liste « voir aussi » titree, un lien de + parite de jumeaux (`| ↔ Python | [Search-03c — LDS (Python)](...)`). Ce sont + des references, pas la chaine de navigation — c'est la chaine qui est jugee. + """ + low = f"{text} {target}".lower() + if any(k in low for k in NAV_KEYWORDS): + return True + if any(k in line.lower() for k in NAV_LINE_MARKERS): + return True + return cell_is_nav + + +def nav_edges(nb_path: Path): + """Aretes sortantes de `nb_path` : les .ipynb cibles de ses liens de nav. + + Retourne une liste de chemins resolus (absolus, dedupliques). Un lien dont + la cible n'existe pas est **ignore** : c'est un 404, deja le metier de + check_notebook_navlinks.py, et il ne peut pas etre un noeud du graphe. + """ + try: + with open(nb_path, encoding="utf-8") as f: + nb = json.load(f) + except (OSError, json.JSONDecodeError): + return [] + out = [] + for cell in nb.get("cells", []): + if cell.get("cell_type") != "markdown": + continue + src = cell.get("source", []) + text_lines = src if isinstance(src, str) else "".join(src) + cell_is_nav = "navigation" in text_lines.lower() + for line in text_lines.splitlines(): + for m in LINK_PATTERN.finditer(line): + text, target = m.group(1), m.group(2) + if not _looks_nav(text, target, line, cell_is_nav): + continue + resolved = _resolve_target(nb_path, target) + if resolved.suffix.lower() != ".ipynb": + continue + if not resolved.is_file(): + continue + out.append(resolved) + # dedup en preservant l'ordre (determinisme du parcours) + seen, uniq = set(), [] + for r in out: + if r not in seen: + seen.add(r) + uniq.append(r) + return uniq + + +def build_graph(notebooks): + """Construit le graphe et indexe les series. + + Retourne (inbound, outbound, series) ou : + - `inbound[node]` = ensemble des noeuds pointant vers `node` + - `outbound[node]` = liste des noeuds pointes par `node` + - `series[dir]` = liste triee des noeuds de ce dossier + Seuls les noeuds de `notebooks` sont des noeuds ; une arete vers un notebook + hors du set (gitignored, hors perimetre) est ignoree. + """ + nodes = set(notebooks) + inbound = defaultdict(set) + outbound = defaultdict(list) + for nb in nodes: + for dst in nav_edges(nb): + if dst not in nodes: + continue + outbound[nb].append(dst) + inbound[dst].add(nb) + series = defaultdict(list) + for nb in nodes: + series[nb.parent].append(nb) + return inbound, outbound, series + + +def _reachable_from(entries, outbound): + """Noeuds atteignables par parcours en largeur depuis `entries`.""" + seen = set(entries) + queue = deque(entries) + while queue: + node = queue.popleft() + for nxt in outbound.get(node, ()): + if nxt not in seen: + seen.add(nxt) + queue.append(nxt) + return seen + + +def analyse(inbound, outbound, series): + """Applique le jugement par serie. Retourne un dict de rapport. + + Un finding est un couple (kind, key) ou `key` identifie la ligne : + - `orphan_entry` : notebook sans lien entrant, dans une serie qui en a + plus d'un (donc : rien ne mene a lui depuis la chaine) ; + - `unreachable` : notebook non-entry qu'aucune entree n'atteint. + Une serie sans entree est declaree non jugeable, jamais saine. + + Une serie n'est jugee que si elle **exhibe** une convention de navigation, + c'est-a-dire au moins une arete INTERNE. Sans cela le dossier n'est pas une + serie navigable (dossier de recherche, de scripts, de brouillons) : le juger + produirait un finding par notebook, tous faux, et un baseline de bruit. + L'exclusion est **comptee et publiee** (`not_judged`), jamais silencieuse. + """ + findings = [] + wrapped = [] + not_judged = [] + per_series = [] + for directory in sorted(series, key=lambda d: _rel(d)): + members = series[directory] + if len(members) < 2: + # Une serie d'un seul notebook n'a pas de chaine a juger. + not_judged.append({"series": _rel(directory), "notebooks": len(members), + "reason": "series_single_notebook"}) + continue + member_set = set(members) + internal_edges = sum(1 for nb in members + for dst in outbound.get(nb, ()) if dst in member_set) + if internal_edges == 0: + not_judged.append({"series": _rel(directory), "notebooks": len(members), + "reason": "no_internal_nav_edge"}) + continue + entries = sorted((nb for nb in members if not inbound.get(nb)), key=_rel) + if entries: + reach = _reachable_from(entries, outbound) + basis = entries + else: + # Aucun notebook n'est sans lien entrant : la chaine **boucle** (le + # « suivant » du dernier pointe le premier). C'est une convention de + # navigation legitime, pas une serie non jugeable -- la declarer + # telle laissait 18 series hors du garde. On se juge alors depuis le + # depart le plus couvrant : si partir de la atteint toute la serie, + # elle se parcourt en entier quel que soit le point d'entree. + wrapped.append({"series": _rel(directory), "notebooks": len(members)}) + best = max(sorted(members, key=_rel), + key=lambda n: len(_reachable_from([n], outbound) & member_set)) + basis = [best] + reach = _reachable_from(basis, outbound) + entry_set = set(basis) + unreachable = sorted( + (nb for nb in members if nb not in entry_set and nb not in reach), key=_rel + ) + # Une seule entree = serie saine par construction : pas de finding. + if len(entries) > 1: + for nb in entries: + findings.append({"kind": "orphan_entry", "notebook": _rel(nb), + "series": _rel(directory)}) + for nb in unreachable: + findings.append({"kind": "unreachable", "notebook": _rel(nb), + "series": _rel(directory)}) + per_series.append({ + "series": _rel(directory), + "notebooks": len(members), + "entries": [_rel(nb) for nb in entries], + "basis": [_rel(nb) for nb in basis], + "wrapped": not entries, + "unreachable": [_rel(nb) for nb in unreachable], + }) + findings.sort(key=lambda f: (f["kind"], f["notebook"])) + return {"findings": findings, "wrapped": wrapped, + "not_judged": not_judged, "series": per_series} + + +def _finding_keys(report): + """Cles de baseline : (kind, notebook). Le message est du confort, pas la cle.""" + return {(f["kind"], f["notebook"]) for f in report["findings"]} + + +def _write_baseline(report): + """Ecrit le baseline (snapshot des findings, supposes connus).""" + BASELINE_PATH.parent.mkdir(parents=True, exist_ok=True) + snapshot = sorted(report["findings"], key=lambda f: (f["kind"], f["notebook"])) + payload = { + "findings": snapshot, + "wrapped": sorted(report["wrapped"], key=lambda s: s["series"]), + } + with open(BASELINE_PATH, "w", encoding="utf-8", newline="\n") as f: + json.dump(payload, f, ensure_ascii=False, indent=2) + f.write("\n") + return BASELINE_PATH + + +def _load_baseline(): + """Charge les cles du baseline, ou set() si absent/illisible.""" + if not BASELINE_PATH.is_file(): + return set() + try: + with open(BASELINE_PATH, encoding="utf-8") as f: + data = json.load(f) + except (OSError, json.JSONDecodeError): + return set() + return {(f["kind"], f["notebook"]) for f in data.get("findings", [])} + + +def _select_report(report, series_filter): + """Restreint le rapport a un ensemble de series (--family / notebook cible).""" + if series_filter is None: + return report + keep = set(series_filter) + return { + "findings": [f for f in report["findings"] if f["series"] in keep], + "wrapped": [s for s in report["wrapped"] if s["series"] in keep], + "not_judged": [s for s in report["not_judged"] if s["series"] in keep], + "series": [s for s in report["series"] if s["series"] in keep], + } + + +def main(argv=None): + parser = argparse.ArgumentParser( + description="Verifie que chaque notebook d'une serie est ATTEIGNABLE " + "par sa chaine de navigation." + ) + parser.add_argument("notebook", nargs="?", + help="Un notebook : limite le rapport a sa serie (defaut: tout)") + parser.add_argument("--family", help="Limiter le RAPPORT a une famille (ex. Search, Sudoku)") + parser.add_argument("--baseline", action="store_true", + help="Ecrire le baseline (snapshot des findings actuels)") + parser.add_argument("--check", action="store_true", + help="Comparer au baseline ; exit 1 si NEW finding (regression)") + parser.add_argument("--json", action="store_true", help="Sortie JSON machine-readable") + parser.add_argument("--quiet", action="store_true", help="Sortie minimale (CI)") + parser.add_argument("--include-untracked", action="store_true", default=False, + help="Inclut les .ipynb sur disque non-tracked par git (legacy)") + args = parser.parse_args(argv) + + tracked_only = not args.include_untracked + + # Le graphe est TOUJOURS global : l'ensemble des entrees d'une serie depend + # des liens entrants venus de n'importe ou. --family / notebook ne font que + # restreindre le RAPPORT, jamais le calcul. + notebooks = list(_iter_notebooks(None, tracked_only=tracked_only)) + if not notebooks: + print("error: aucun notebook trouve sous MyIA.AI.Notebooks/", file=sys.stderr) + return 2 + + # Le filtre est exprime en chemins REPO-RELATIFS POSIX : c'est la cle sous + # laquelle `analyse` publie ses series. Comparer des Path a ces chaines + # filtrait silencieusement tout (0 serie jugee, rc=0 -- le pire des verts). + series_filter = None + if args.notebook: + p = Path(args.notebook) + if not p.is_absolute(): + p = REPO_ROOT / args.notebook + if not p.is_file(): + print(f"error: notebook introuvable: {args.notebook}", file=sys.stderr) + return 2 + series_filter = {_rel(p.resolve().parent)} + elif args.family: + series_filter = {_rel(nb.parent) for nb in notebooks + if nb.relative_to(NOTEBOOKS_ROOT).parts[0] == args.family} + if not series_filter: + print(f"error: famille inconnue: {args.family}", file=sys.stderr) + return 2 + + inbound, outbound, series = build_graph(notebooks) + report = _select_report(analyse(inbound, outbound, series), series_filter) + + if args.baseline: + path = _write_baseline(report) + print(f"baseline ecrit: {path} ({len(report['findings'])} findings connus, " + f"{len(report['not_judged'])} dossier(s) non juge(s), " + f"{len(report['wrapped'])} serie(s) bouclee(s))") + return 0 + + if args.check: + known = _load_baseline() + current = _finding_keys(report) + new = sorted(current - known) + fixed = sorted(known - current) + if new: + if not args.quiet: + print(f"FAIL: {len(new)} NEW finding(s) vs baseline:") + for kind, notebook in new: + print(f" [{kind}] {notebook}") + return 1 + if fixed and not args.quiet: + print(f"INFO: {len(fixed)} finding(s) resolus depuis le baseline " + f"(mettre le baseline a jour).") + if not args.quiet: + print(f"OK: 0 NEW finding vs baseline ({len(current)} connus, " + f"{len(notebooks)} notebook(s) au graphe).") + return 0 + + findings = report["findings"] + if args.json: + json.dump({"total_findings": len(findings), + "findings": findings, + "wrapped": report["wrapped"], + "not_judged": report["not_judged"], + "series": report["series"], + "scanned": len(notebooks)}, sys.stdout, ensure_ascii=False, indent=2) + sys.stdout.write("\n") + elif not args.quiet: + # Les exclusions sont PUBLIEES, jamais silencieuses : un dossier ecarte + # faute de convention de navigation n'est pas un dossier sain. + by_reason = defaultdict(int) + for s in report["not_judged"]: + by_reason[s["reason"]] += 1 + if by_reason: + detail = ", ".join(f"{n} {r}" for r, n in sorted(by_reason.items())) + print(f"INFO: {len(report['not_judged'])} dossier(s) NON juge(s) ({detail}).") + if report["wrapped"]: + # Convention « le suivant du dernier pointe le premier » : la serie + # est jugee quand meme, depuis son depart le plus couvrant. + print(f"INFO: {len(report['wrapped'])} serie(s) a chaine BOUCLEE " + f"(aucune entree ; jugee(s) depuis un depart arbitraire) : " + f"{', '.join(s['series'] for s in report['wrapped'][:4])}" + f"{' ...' if len(report['wrapped']) > 4 else ''}") + if not findings: + print(f"OK: chaque notebook est atteignable dans sa serie " + f"({len(report['series'])} serie(s) jugee(s), " + f"{len(notebooks)} notebook(s) au graphe).") + else: + orphan = [f for f in findings if f["kind"] == "orphan_entry"] + unreach = [f for f in findings if f["kind"] == "unreachable"] + print(f"FOUND {len(findings)} finding(s) " + f"({len(orphan)} entree(s) orpheline(s), " + f"{len(unreach)} notebook(s) inatteignable(s)):") + for f in findings: + print(f" [{f['kind']}] {f['notebook']} (serie {f['series']})") + return 1 if findings else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/notebook_tools/tests/test_check_notebook_nav_chain.py b/scripts/notebook_tools/tests/test_check_notebook_nav_chain.py new file mode 100644 index 0000000000..3c122c8b99 --- /dev/null +++ b/scripts/notebook_tools/tests/test_check_notebook_nav_chain.py @@ -0,0 +1,373 @@ +"""Tests for scripts/notebook_tools/check_notebook_nav_chain.py — nav-chain reachability guard. + +Why this test file exists +------------------------- +`check_notebook_navlinks.py` verifie que chaque cible de lien **existe** (404). +Il ne verifie pas que la chaine de navigation **atteint** chaque notebook : les +deux proprietes divergent exactement sur un notebook **insere** dont les voisins +pointent encore l'un vers l'autre. `12b` n'a alors aucun lien entrant, tous les +liens resolvent, le garde 404 est vert, et le notebook est inatteignable. C'est +la classe qui a laisse passer `QC-Py-12b`/`QC-Py-23c` (#17093), et qui est +**vivante** ailleurs dans le depot (`Sudoku-12b`, mesure du 2026-09-21). + +Sept clusters : + 1. TestLooksNav — les TROIS portees du marqueur (lien / ligne / cellule) et + les NON-aretes volontaires (prose, « voir aussi », parite de jumeaux). + Chaque cas porte la mesure qui l'a fait adopter (cf le module). + 2. TestNavEdges — extraction : .ipynb seuls, cible existante seule, dedup, + markdown seulement. + 3. TestBuildGraph — inbound/outbound/series + arete hors du set ignoree. + 4. TestAnalyse — les quatre jugements : chaine saine, notebook insere (la + classe fondeuse), ilot detache, chaine bouclee, dossier non navigable. + 5. TestBaselineIO — ecriture/lecture deterministe, absent, JSON corrompu. + 6. TestMainModes — exit codes, --check NEW, --baseline. + 7. TestSeriesFilterRegression — l'epingle du bug « Path compare a une chaine », + qui rendait `--family` **silencieusement vide** (0 serie jugee, rc=0). +""" +import json +import sys +from pathlib import Path + +import pytest + +# import du module sous test (depuis le dossier parent) +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) +import check_notebook_nav_chain as cnc # noqa: E402 + + +def _nb(cells): + """Notebook synthetique minimal (type, source) par cellule.""" + return { + "cells": [{"cell_type": t, "source": s, "metadata": {}} for (t, s) in cells], + "metadata": {}, "nbformat": 4, "nbformat_minor": 5, + } + + +def _write(path: Path, cells): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(_nb(cells)), encoding="utf-8") + return path + + +@pytest.fixture(autouse=True) +def _isolate_baseline(tmp_path, monkeypatch): + """REPO_ROOT et BASELINE_PATH rediriges : jamais le depot reel en test. + + `_rel()` lit `REPO_ROOT` au moment de l'appel, donc le monkeypatch suffit et + permet des chemins synthetiques sous tmp_path. + """ + monkeypatch.setattr(cnc, "REPO_ROOT", tmp_path) + # NOTEBOOKS_ROOT est calcule a l'import : `--family` fait un + # `relative_to(NOTEBOOKS_ROOT)` sur les chemins du tmp_path, donc le + # rederiger aussi, sinon ValueError au lieu d'un test. + monkeypatch.setattr(cnc, "NOTEBOOKS_ROOT", tmp_path / "MyIA.AI.Notebooks") + monkeypatch.setattr(cnc, "BASELINE_PATH", tmp_path / "baseline.json") + return tmp_path + + +# ---------------------------------------------------------------- 1. portees + +class TestLooksNav: + """Les trois portees, et les non-aretes. Chaque cas vient d'une mesure.""" + + def test_keyword_in_link_text(self): + # Cas majoritaire : [Suivant >>](13-foo.ipynb) + assert cnc._looks_nav("Suivant >>", "13-foo.ipynb", "x", False) + + def test_keyword_in_link_text_accented(self): + assert cnc._looks_nav("Précédent", "12-foo.ipynb", "", False) + + def test_arrow_in_link_text(self): + # MGS-07c : `[← MGS-7b LandscapeMultidim](...) · [MGS-8 ... →](...)` + assert cnc._looks_nav("← MGS-7b LandscapeMultidim", "x.ipynb", "", False) + assert cnc._looks_nav("MGS-8 LandscapeExplorer →", "y.ipynb", "", False) + + def test_marker_on_the_LINE_outside_the_link(self): + # MGS-10 : `**Série MGS** | Précédent : [MGS-9 - Relief Everest](...)` + # Le mot est hors du lien, et le texte du lien est le TITRE du voisin. + line = "**Série MetaGeneticSharp** | Précédent : [MGS-9 - Relief Everest](MGS-09-x.ipynb) | [↑ Série MGS](README.md)" + assert cnc._looks_nav("MGS-9 - Relief Everest", "MGS-09-x.ipynb", line, False) + + def test_marker_in_the_CELL_not_the_line(self): + # Sudoku-06 : le bloc est une TABLE sous un titre, donc marqueur et liens + # sont sur DEUX lignes. Portee ligne = faux orphelin mesure. + assert cnc._looks_nav("Sudoku-05-PSO", "Sudoku-05-PSO-Csharp.ipynb", "table row", True) + + def test_prose_filename_in_backticks_is_not_an_edge(self): + # GameTheory-24b : `Suite du banc toy \`GameTheory-24-Humour-Banc.ipynb\`` + assert not cnc._looks_nav("GameTheory-24-Humour-Banc.ipynb", + "GameTheory-24-Humour-Banc.ipynb", + "Suite du banc toy `GameTheory-24-Humour-Banc.ipynb`", False) + + def test_see_also_bullet_is_not_an_edge(self): + # GameTheory-15 : liste « voir aussi » titree. + line = "- [GameTheory-16 (Choix social / Mechanism Design)](GameTheory-16-MechanismDesign-Csharp.ipynb) : agregation" + assert not cnc._looks_nav("GameTheory-16 (Choix social / Mechanism Design)", + "GameTheory-16-MechanismDesign-Csharp.ipynb", line, False) + + def test_twin_parity_link_is_not_an_edge(self): + # Search-03c : `| ↔ Python | [Search-03c — LDS (Python)](...) |` — parite + # de jumeaux, pas chaine de navigation. + line = "| ↔ Python | [Search-03c — LDS (Python)](Search-03c-LimitedDiscrepancySearch.ipynb) | jumeau |" + assert not cnc._looks_nav("Search-03c — LDS (Python)", + "Search-03c-LimitedDiscrepancySearch.ipynb", line, False) + + def test_weak_words_are_not_line_markers(self): + # `index`/`prec`/`préc` sont exclus du scan de LIGNE (trop frequents en + # prose) meme s'ils restent valides dans le texte du lien. + assert not cnc._looks_nav("X", "x.ipynb", "l'index de la liste", False) + assert not cnc._looks_nav("X", "x.ipynb", "plus precisement", False) + + +# ------------------------------------------------------------- 2. extraction + +class TestNavEdges: + def test_extracts_only_ipynb_targets(self, tmp_path): + a = _write(tmp_path / "s" / "a.ipynb", [("markdown", "[Suivant](b.ipynb)\n[Index](R.md)")]) + _write(tmp_path / "s" / "b.ipynb", [("markdown", "x")]) + _write(tmp_path / "s" / "R.md", [("markdown", "x")]) + assert cnc.nav_edges(a) == [(tmp_path / "s" / "b.ipynb").resolve()] + + def test_missing_target_is_not_a_node(self, tmp_path): + # Un 404 est le metier de check_notebook_navlinks.py, pas une arete. + a = _write(tmp_path / "s" / "a.ipynb", [("markdown", "[Suivant](absent.ipynb)")]) + assert cnc.nav_edges(a) == [] + + def test_code_cells_are_ignored(self, tmp_path): + a = _write(tmp_path / "s" / "a.ipynb", [("code", "[Suivant](b.ipynb)")]) + _write(tmp_path / "s" / "b.ipynb", [("markdown", "x")]) + assert cnc.nav_edges(a) == [] + + def test_dedup_and_source_as_string(self, tmp_path): + a = _write(tmp_path / "s" / "a.ipynb", + [("markdown", "[Suivant](b.ipynb) [Suivant](b.ipynb)")]) + _write(tmp_path / "s" / "b.ipynb", [("markdown", "x")]) + assert len(cnc.nav_edges(a)) == 1 + + def test_unreadable_notebook_yields_no_edge(self, tmp_path): + p = tmp_path / "s" / "bad.ipynb" + p.parent.mkdir(parents=True, exist_ok=True) + p.write_text("{ not json", encoding="utf-8") + assert cnc.nav_edges(p) == [] + + +# ---------------------------------------------------------------- 3. graphe + +class TestBuildGraph: + def test_inbound_outbound_and_series(self, tmp_path): + a = _write(tmp_path / "s" / "a.ipynb", [("markdown", "[Suivant](b.ipynb)")]) + b = _write(tmp_path / "s" / "b.ipynb", [("markdown", "rien")]) + inbound, outbound, series = cnc.build_graph([a, b]) + assert outbound[a] == [b.resolve()] + assert inbound[b.resolve()] == {a.resolve()} + assert a.resolve() not in inbound + assert len(series[a.parent]) == 2 + + def test_edge_outside_the_node_set_is_ignored(self, tmp_path): + a = _write(tmp_path / "s" / "a.ipynb", [("markdown", "[Suivant](b.ipynb)")]) + _write(tmp_path / "s" / "b.ipynb", [("markdown", "x")]) + inbound, outbound, _ = cnc.build_graph([a]) # b hors du set + assert outbound[a] == [] + assert inbound == {} + + +# --------------------------------------------------------------- 4. analyse + +def _chain(tmp_path, ids, links): + """Cree une serie : `ids` = noms, `links` = {src: [dst, ...]}.""" + base = tmp_path / "MyIA.AI.Notebooks" / "Serie" + paths = {} + for i in ids: + cells = [("markdown", "\n".join(f"[Suivant]({d}.ipynb)" for d in links.get(i, [])))] + paths[i] = _write(base / f"{i}.ipynb", cells) + return base, paths + + +class TestAnalyse: + def test_healthy_single_entry_chain(self, tmp_path): + # 01 -> 02 -> 03 : une seule entree, tout atteignable -> aucun finding. + _, p = _chain(tmp_path, ["01", "02", "03"], {"01": ["02"], "02": ["03"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + assert r["findings"] == [] + assert r["series"][0]["entries"] == ["MyIA.AI.Notebooks/Serie/01.ipynb"] + + def test_inserted_notebook_is_flagged(self, tmp_path): + # LA CLASSE FONDATRICE (#17093 / QC-Py-12b) : 02b insere entre 02 et 03, + # mais 02 pointe encore 03 et 03 pointe encore 02 -> 02b sans lien entrant. + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + flagged = [f["notebook"] for f in r["findings"] if f["kind"] == "orphan_entry"] + assert "MyIA.AI.Notebooks/Serie/02b.ipynb" in flagged + assert "MyIA.AI.Notebooks/Serie/01.ipynb" in flagged # 2 entrees -> les deux + + def test_inserted_notebook_absent_once_linked_in(self, tmp_path): + # L'ETAT CIBLE (le fix de #17277) : 02 -> 02b -> 03. Plus aucun finding. + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["02b"], "02b": ["03"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + assert cnc.analyse(inbound, outbound, series)["findings"] == [] + + def test_detached_island_head_is_an_orphan_entry(self, tmp_path): + # 01 -> 02, et 07 -> 08 : 07 est une 2e entree (rien ne mene a lui). + # 08, lui, est ATTEIGNABLE depuis l'entree 07 : il ne doit PAS etre + # classe `unreachable`. Seule la tete de l'ilot est orpheline. + _, p = _chain(tmp_path, ["01", "02", "07", "08"], {"01": ["02"], "07": ["08"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + kinds = {(f["kind"], f["notebook"].split("/")[-1]) for f in r["findings"]} + assert ("orphan_entry", "07.ipynb") in kinds + assert not any(k == "unreachable" for k, _ in kinds) + + def test_detached_cycle_is_unreachable(self, tmp_path): + # 01 -> 02, et un cycle detache 07 <-> 08 : les deux ont un lien entrant + # (donc aucune entree), et aucune entree ne les atteint -> inatteignables. + _, p = _chain(tmp_path, ["01", "02", "07", "08"], + {"01": ["02"], "07": ["08"], "08": ["07"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + kinds = {(f["kind"], f["notebook"].split("/")[-1]) for f in r["findings"]} + assert ("unreachable", "07.ipynb") in kinds + assert ("unreachable", "08.ipynb") in kinds + assert not any(k == "orphan_entry" for k, _ in kinds) + + def test_wrapped_chain_is_judged_not_excluded(self, tmp_path): + # 01 -> 02 -> 03 -> 01 : AUCUNE entree. Convention legitime (le « suivant » + # du dernier pointe le premier) : la serie est jugee, pas ecartee. + _, p = _chain(tmp_path, ["01", "02", "03"], + {"01": ["02"], "02": ["03"], "03": ["01"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + assert r["findings"] == [] + assert len(r["wrapped"]) == 1 + assert r["series"][0]["wrapped"] is True + + def test_directory_without_internal_edge_is_not_judged(self, tmp_path): + # Dossier de recherche : aucun lien de nav interne -> hors scope, COMPTE. + _, p = _chain(tmp_path, ["r1", "r2"], {}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + assert r["findings"] == [] + assert r["not_judged"][0]["reason"] == "no_internal_nav_edge" + + def test_single_notebook_series_is_not_judged(self, tmp_path): + _, p = _chain(tmp_path, ["solo"], {}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + assert r["findings"] == [] + assert r["not_judged"][0]["reason"] == "series_single_notebook" + + def test_findings_are_sorted_for_baseline_stability(self, tmp_path): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + f = cnc.analyse(inbound, outbound, series)["findings"] + assert f == sorted(f, key=lambda x: (x["kind"], x["notebook"])) + + +# -------------------------------------------------------------- 5. baseline + +class TestBaselineIO: + def test_write_then_load_roundtrip(self, tmp_path): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + cnc._write_baseline(r) + assert cnc._load_baseline() == cnc._finding_keys(r) + + def test_write_is_deterministic(self, tmp_path): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + inbound, outbound, series = cnc.build_graph(list(p.values())) + r = cnc.analyse(inbound, outbound, series) + cnc._write_baseline(r) + first = cnc.BASELINE_PATH.read_bytes() + cnc._write_baseline(r) + assert cnc.BASELINE_PATH.read_bytes() == first + + def test_missing_baseline_is_empty(self): + assert cnc._load_baseline() == set() + + def test_corrupted_baseline_is_empty(self): + cnc.BASELINE_PATH.parent.mkdir(parents=True, exist_ok=True) + cnc.BASELINE_PATH.write_text("{ pas du json", encoding="utf-8") + assert cnc._load_baseline() == set() + + +# ------------------------------------------------------------------ 6. main + +class TestMainModes: + def _patch_iter(self, monkeypatch, paths): + monkeypatch.setattr(cnc, "_iter_notebooks", lambda *a, **k: list(paths)) + + def test_exit_1_on_findings_exit_0_when_healthy(self, tmp_path, monkeypatch): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + self._patch_iter(monkeypatch, p.values()) + assert cnc.main([]) == 1 + _, p2 = _chain(tmp_path / "h", ["01", "02"], {"01": ["02"]}) + self._patch_iter(monkeypatch, p2.values()) + assert cnc.main(["--quiet"]) == 0 + + def test_check_flags_only_new_findings(self, tmp_path, monkeypatch): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + self._patch_iter(monkeypatch, p.values()) + assert cnc.main(["--baseline", "--quiet"]) == 0 + assert cnc.main(["--check", "--quiet"]) == 0 + # on casse une arete de plus -> un finding NEW + _write(tmp_path / "MyIA.AI.Notebooks" / "Serie" / "04.ipynb", + [("markdown", "rien")]) + self._patch_iter(monkeypatch, list(p.values()) + + [tmp_path / "MyIA.AI.Notebooks" / "Serie" / "04.ipynb"]) + assert cnc.main(["--check", "--quiet"]) == 1 + + def test_unknown_notebook_is_exit_2(self, tmp_path, monkeypatch): + self._patch_iter(monkeypatch, []) + assert cnc.main([str(tmp_path / "nope.ipynb")]) == 2 + + def test_json_output_shape(self, tmp_path, monkeypatch, capsys): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + self._patch_iter(monkeypatch, p.values()) + cnc.main(["--json"]) + out = json.loads(capsys.readouterr().out) + assert out["total_findings"] == len(out["findings"]) > 0 + assert set(out) >= {"findings", "wrapped", "not_judged", "series", "scanned"} + + +# ------------------------------------------------- 7. epingle de regression + +class TestSeriesFilterRegression: + """Le filtre de serie comparait des `Path` a des chaines repo-relatives. + + Consequence mesuree : `--family Sudoku` rendait « 0 serie jugee », **rc=0** — + un vert silencieux, le pire des verts, sur un rapport vide. Pin : le filtre + doit selectionner la serie ET le rapport doit rester non vide. + """ + + def test_family_filter_selects_the_series(self, tmp_path, monkeypatch): + _, p = _chain(tmp_path, ["01", "02", "02b", "03"], + {"01": ["02"], "02": ["03"], "03": ["02"]}) + monkeypatch.setattr(cnc, "_iter_notebooks", lambda *a, **k: list(p.values())) + out = json.loads(_capture(cnc.main, ["--family", "Serie", "--json"])) + assert out["total_findings"] > 0 + assert len(out["series"]) == 1 + + def test_unknown_family_is_exit_2(self, tmp_path, monkeypatch): + _, p = _chain(tmp_path, ["01", "02"], {"01": ["02"]}) + monkeypatch.setattr(cnc, "_iter_notebooks", lambda *a, **k: list(p.values())) + assert cnc.main(["--family", "Inexistante", "--quiet"]) == 2 + + +def _capture(fn, argv): + """Capture stdout de `fn(argv)` (les tests de filtre en ont besoin).""" + import io + from contextlib import redirect_stdout + buf = io.StringIO() + with redirect_stdout(buf): + fn(argv) + return buf.getvalue() diff --git a/scripts/tests/baseline_nb_nav_chain.json b/scripts/tests/baseline_nb_nav_chain.json new file mode 100644 index 0000000000..036af1bbab --- /dev/null +++ b/scripts/tests/baseline_nb_nav_chain.json @@ -0,0 +1,2328 @@ +{ + "findings": [ + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-02-NormalForm-Part2-Python.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-02c-Travelers-Dilemma-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-03-Topology2x2-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-03a-Chemins-de-Swaps.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-03d-Plan-de-deformation.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-03e-Meta-Actions-Tarifees.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-04-NashEquilibrium-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-04c-NashExistence-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-04d-Marchandage-Asymetrique.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-05b-Lean-Minimax.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06-EvolutionTrust-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06b-Lean-RepeatedGames.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06c-RepeatedGames-FolkTheorem-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06d-Sympathie-vs-Engagement.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06f-Bounded-Agents-Python.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06g-Bounded-Agents-Lean.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-06h-Transparent-Institutions.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-07-ExtensiveForm-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-08-CombinatorialGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-08c-CombinatorialGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-09c-Stackelberg-SecurityGame.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-10-ForwardInduction-SPE-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-11-BayesianGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-12-ReputationGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-13d-Optimistic-CFR.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-14-DifferentialGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-15-CooperativeGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-15c-CooperativeGames-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-15e-Coalition-Power-SMT.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-16-MechanismDesign-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-16b-Automated-Mechanism-Design.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-16c-Extraction-de-Revenu-DSIC-IR.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-16d-Echange-de-Reins.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-16e-LLM-Players-Othman-Sandholm.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-17-MultiAgent-RL-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-17c-Lean-Lemons-Certificat.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-17c-Market-to-Balance-Sheet.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-17d-Lean-Screening-Signaling.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-18-Open-Games-et-Lentilles.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-20b-Chemin-Minimal-Temoins-Impossibilite.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-20c-Chemin-Minimal-3x2-Ordinal.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-23b-Lean-Assignment-Native.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-24-Humour-Banc.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/GameTheory-24b-Humour-Banc-Dur.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/SocialChoice/01-Arrow-Impossibility-Theorem-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory/SocialChoice" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/SocialChoice/04-Computational-Aggregation-SAT-Z3-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory/SocialChoice" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GameTheory/SocialChoice/06-Mobius-Aggregation-Pouvoir-Manipulation.ipynb", + "series": "MyIA.AI.Notebooks/GameTheory/SocialChoice" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications/04-13-Audiobook-FishAudio-S2Pro.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications/04-14-VoiceLeading-Rendu-GenAI.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications/04-15-MERT2-Music-Understanding.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications/04-16-SheetSage2-Audio-To-Score.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications/04-6-Audiobook-Pipeline.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications/04-8-Lecture-Analytique.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/04-Applications" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/FineTuning/FT-00b-LoRA-Hyperparams-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/FineTuning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/FineTuning/FT-00c-LoRA-SOTA-Comparison.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/FineTuning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/FineTuning/FT-05-ModelMerging-Routing_en.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/FineTuning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/03-Aspire-Observabilite.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/04-Aspire-Streaming-Agent.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/05-Aspire-Tests-Integration.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/06-Aspire-GardeFous-Roslyn.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/07-Aspire-SemanticFleet-MultiConnector.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/08-Aspire-AsyncFFI-Dotnet.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/09-Aspire-Harness-CopilotSdk.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_01_intro_post_training.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_02_sft_baseline.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_07_rewardspy_reward_hacking.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_08_grpo_from_scratch_toy_env.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_09_rloo_from_scratch_toy_env.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_10_gae_from_scratch_toy_env.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_11a_grpo_qwen35_rlvr.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_11b_grpo_qwen_rlvr_on_verifiers.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_11c_grpo_qwen17_rlvr.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_11d_multiseed_qwen35_4x100.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_12_multistep_delayed_credit.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_13_dapo_drgrpo_corrections.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_14_neural_thermodynamic_laws.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/RAG-et-Memoire-Semantique/04-Tokenisation-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/RAG-et-Memoire-Semantique" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/RAG-et-Memoire-Semantique/09-KernelMemory-Multimodal.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/RAG-et-Memoire-Semantique" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/Créateur de mail personnalisé.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/Notebook-Generated.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/Notebook-Template.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/Semantic-kernel-AutoInteractive.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/Workbook-Template-Python.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/Workbook-Template.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/09b_Prompt_Security_RedTeam.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/10c_Long_Context_Strategies.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/10f_ORTGenAI_DotNet_BakeOff.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/13b_Agent_Evaluation.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/22_Evaluating_Generated_Text.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/24_NGrammes_Modeles_De_Langue.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/25_CRF_Etiquetage_Sequentiel.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/GenAI/Texte/26_PCFG_CYK_Parsing.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Texte" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-01-PhiTrajectories-Python.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-03-RobustnessDelayedGratification-Python.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-07-ScaleFreeSignatures-Python.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-11-CausalAgencyProfiles.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-12e-Value-of-Information-Animat.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-13b-DecroisementDynamiqueObservable.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-14-FreeEnergySurprise.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15b-SensitivityCanonicity.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15c-MetaProxyObstruction.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15d-CechObstruction.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15e-Bridge2-RecoverabilityAgency.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15f-Bridge1bis-DecoupledFamily.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15g-EmpiricalHuangExploitation.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15h-Bridge1bis-AsymmetricFamily.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15i-Bridge1bis-2DLandscape.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15j-NerveDiscriminant.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15k-RecollementMacroCells.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-15l-IndependanceGenerateur.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-16-MDLTwoPartCode.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-17-EpsilonMachine.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-17b-Grokking-CompressionProgress.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-21c-SAECatastrophes.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-22-LLMSubstrat.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-22b-CausalInterventionEngine.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-23-PersonaCatastrophe.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-25-InoculationRL.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-27-SymbolInvention.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-28-CollectiveAdoption.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-29-ConceptInoculation.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-31-ContrasteTroisSubstrats.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-32-StratificationCausaleLife.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-33-SoupCollisions.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-34-BancRecollementLectures.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-35b-HumorCausalPairs-SAE.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-35c-HumorDepthProfile-SAE.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-36-FLens-FactoredGeometry.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-38-SLens-SelfLocation.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-39-CompositionRegards.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-40a-TriangulationCausale.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-40b-AnalogCognitionWaves.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-41-SAE-GeometrieFeatures.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Annexe-ProxyContextuality.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Argumentation-BeliefTrajectories.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Dissociation-PhatSelfReference.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Dissociation-SaillancePregnance.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Greffe4-VoteOnChain.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Greffe5-AttributionCausale.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-Synthese-CrossSubstrat.ipynb", + "series": "MyIA.AI.Notebooks/IIT/ICT-Series" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/IIT-03-CoarseGrainingMacroPhi.ipynb", + "series": "MyIA.AI.Notebooks/IIT" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/IIT-04-Le-Probleme-de-Frontiere.ipynb", + "series": "MyIA.AI.Notebooks/IIT" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/IIT/IIT-05-Lentilles-et-Dissociations.ipynb", + "series": "MyIA.AI.Notebooks/IIT" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.11-Regularisation-Sparse-LASSO.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.11c-Lasso-SOTA-Comparison.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.11d-Optimisation-ADMM-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.12-Donnees-Desequilibrees.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.14-Explicabilite-SHAP-LIME-Contrefactuels.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.3d-Modele-Gaussien-LDA-QDA.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.5c-Equite-Sous-Groupes.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.7c-SVM-SOTA-Comparison.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.8c-Borne-Temoin-Concentration.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.9b-GenEFT-Theorie-Effective.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours/2.9d-Features-Circulaires-Helice-Nombres.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/02-ML-Cours" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.0-Theorie-Information.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.10-Modeles-Generatifs-Diffusion-SOTA.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.3-Regularisation.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.4-Attention-Transformer-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.4c-MoE-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.6b-Modeles-Generatifs-PyTorch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.6c-Modeles-Generatifs-Diffusion-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.6d-Modeles-Generatifs-Score-SDE-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.6e-Modeles-Generatifs-Conditionnels-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.7-Distillation-Maitre-Eleve.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.9-Compression-Quantization-FP.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.9b-Compression-Pruning-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.9c-Pruning-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.9f-Compression-Pruning-SOTA.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04-Vision/4.2d-Detection-AnchorFree-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04-Vision" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04-Vision/4.2e-Detection-FocalLoss-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04-Vision" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04-Vision/4.2h-YOLOv5-Bench-Ultralytics.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04-Vision" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering/WS-00a-Ondelettes-1D-from-scratch.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering/WS-01-Denoising-SOTA.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering/WS-02-Scattering-SOTA.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering/WS-03-Synthese-Scattering-vs-ResNet.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/04b-Wavelet-Scattering" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star/Lab12b-Sequential-Orchestration.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star/Lab12c-Agent-Handoff.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star/Lab12d-Token-Usage.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star/Lab12e-Session-Persistence.ipynb", + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day5-DS-Star" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/ML.Net/ML-4b-ModelComparison-Validity-Python.ipynb", + "series": "MyIA.AI.Notebooks/ML/ML.Net" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/ML.Net/ML-5b-Series-Temporelles-Classiques-Python.ipynb", + "series": "MyIA.AI.Notebooks/ML/ML.Net" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/ML/ML.Net/TP-prevision-ventes.ipynb", + "series": "MyIA.AI.Notebooks/ML/ML.Net" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/Causal-Fairness.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-1-Estimand-et-Intervention.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-2-Contrefactuel-Individuel.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-3-Decouverte-de-Structure.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-4-Sensibilite-Confounder-Cache.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-5-Instrument-Faible.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/Quasi-Experimental.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecInfer/DecInfer-02-Lean-ExpectedUtility.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecInfer" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecInfer/DecInfer-09-Lean-Gittins.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecInfer" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC/DecPyMC-10-Ruine-Lundberg.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC/DecPyMC-12-Freq-Sev-Hierarchique.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC/DecPyMC-8-Actuarial-Credibility.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/Infer/Infer-18-Change-Point.ipynb", + "series": "MyIA.AI.Notebooks/Probas/Infer" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/Infer/Infer-19-Survival-Analysis.ipynb", + "series": "MyIA.AI.Notebooks/Probas/Infer" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/Infer/Infer-1b-Premiers-Modeles.ipynb", + "series": "MyIA.AI.Notebooks/Probas/Infer" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/Infer/Infer-20-Quotients-et-Fibres.ipynb", + "series": "MyIA.AI.Notebooks/Probas/Infer" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/PyMC/PyMC-16-Sparse-Gaussian-Process.ipynb", + "series": "MyIA.AI.Notebooks/Probas/PyMC" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/PyMC/PyMC-18-Change-Point.ipynb", + "series": "MyIA.AI.Notebooks/Probas/PyMC" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Probas/PyMC/PyMC-19-Survival-Analysis.ipynb", + "series": "MyIA.AI.Notebooks/Probas/PyMC" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/ML-Research-Template.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/c1330_xrp_dt_foldwise_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/c875_hmm_alpha_dm_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/hmm_alpha_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m11e_ensemble_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m12_har_rv_j_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m15_lstm_rv_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m15_lstm_rv_sc_validation.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m3_har_asymmetric_semivariance.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m4_dlinear_vol_sc_validation.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/m5_hmm_regime_research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/research_l1_tsmom.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/research_l2_dual_momentum.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/research_l3_trend.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/research_l4_decision_transformer.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline/research_what_dl_can_predict.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/ML-Training-Pipeline" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-05-Universe-Selection.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-06b-Derivatives-Valuation-From-Scratch.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-12b-Backtest-Validity.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-16-Alternative-Data.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-18-ML-Features-Engineering.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-21-Portfolio-Optimization-ML.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-23c-TimesFM-Foundation-Models.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-29-Derivatives-Valuation.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-31-Transformer-Training.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-35-RL-Portfolio-Construction.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-Cloud-03b-RiskParity-Composite.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-Cloud-13-VolTargeting.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-Dataset-Workflow.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_asset_class_momentum.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_commodity_term_structure.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_defensive_etf_rotation.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_long_short_harvest.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_macro_factor_rotation.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_piotroski_fscore.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_puppies_of_dow.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor/research_volatility_regime_ml.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/projects/Research-Executor" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/RL-7b-Climbing-Game.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_10_reward_shaping.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_11_pomdp.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_12_distributional_rl.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_13_curiosity_exploration.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_14_hierarchical_rl.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_16_dream_rsi.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_17_k_server_wfa.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_18_matroid_secretary.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_1c_prolog_distillation.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_6e_grpo_from_scratch.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rl_8_model_based_dyna_q.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_0_reward_model_from_scratch.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_0b_preference_dataset_bias.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_0c_reward_hacking_case_study.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_0d_reward_trainer_sota.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_0e_trl_DPO_SOTA.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_0f_comparaison_GRPO_TRL_et_PPO_maison.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_1_ppo_lm_rlhf.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_3_reward_hacking.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/RL/rlpt_4_dpo_vs_ppo.ipynb", + "series": "MyIA.AI.Notebooks/RL" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-11b-Picross-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-1b-NQueens-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-2-GraphColoring-Statistical-Validity-Python.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-20b-SudokuBenchmark-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-23-Factorio-Balancer.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-5-Timetabling-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-6-Minesweeper-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-7b-Wordle-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-8-MiniZinc-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-13b-TSP-Metaheuristics-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-18b-HyperparameterTuning-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-18c-HyperparameterTuning-Rustuna-vs-Optuna.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-22-AlgorithmSelection-Python.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-24-MAPF-Guarantee-Audit.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-27-Sparse-Index-Tracking-Walk-Forward.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-28-LearningToBranch-Generalization-Audit.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-30-OrbitalAssembly-Certificate-Audit.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-31-RCPSP-Max-Feasibility-Bounds.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Search/App-14-ConnectFour-Adversarial-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Search" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Search/App-14c-ConnectFour-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Search" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Search/App-32-Szpiro-Pasten-2026.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Search" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-01-StateSpace-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-02b-NetworkX-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03-Informed-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03b-PatternDatabases-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03b-PatternDatabases.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03c-LimitedDiscrepancySearch-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03c-LimitedDiscrepancySearch.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03d-WeightedAstar-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-05-GeneticAlgorithms-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-07-MCTS-And-Beyond-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-09-LinearProgramming-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-09b-SpuriousMinima.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-09c-CombinatorialDiscrepancy.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-11-Metaheuristics-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-11c-Empirical-Algorithm-Selection.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-12a-Composer-Regards.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part2-CSP/CSP-3-Advanced-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part2-CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part2-CSP/CSP-6-Hybridization-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part2-CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part2-CSP/CSP-7-Soft-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part2-CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part2-CSP/CSP-9-Distributed-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part2-CSP" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-07d-MichalewiczDixonPrice.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-12-AxisAlignment.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-13-LandscapeDebias.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-17-ParameterControl.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-17b-Empirical-Algorithm-Selection.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-20-Langage-de-Composition.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-vs-mealpy/MGS-28-BareBonesPSO-vs-Mealpy.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-vs-mealpy" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-vs-mealpy/MGS-29-GA-vs-Mealpy.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-vs-mealpy" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-vs-mealpy/MGS-31-Synthese-Croisee.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-vs-mealpy" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Sudoku/Sudoku-12b-Z3-Linq2Z3-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Sudoku" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Sudoku/Sudoku-13-SymbolicAutomata-Python.ipynb", + "series": "MyIA.AI.Notebooks/Sudoku" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Sudoku/Sudoku-18-Comparison-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Sudoku" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/Sudoku/Sudoku-19-Lean-Propagation.ipynb", + "series": "MyIA.AI.Notebooks/Sudoku" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-0-init_agent.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-3-orchestration_agent.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Agentic-5-jtms.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_ArgumentProfile.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Argumentum_Cards.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Dated_Graphs.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Formal_Richness_Matrix.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Multi_Backend_Routing.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Observatoire-1-Initiation.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Ontology_AIF.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Ontology_CrossLinks.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Ontology_Virtues.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Recollement_Lectures.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Recollement_Strate6.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Restitution_3_Actes.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis/Argument_Analysis_Toulmin_Model.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Argument_Analysis" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-12b-Lean-Sensitivity-Theorem.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-13b-CHSH-Tsirelson-Native.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-14b-Finiteness-Lean-Companion.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-15b-Lean-Grothendieck.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-15c-Lean-Grothendieck-Companion.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-16g-Conway-Canons.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-16h-Conway-PatternTour-Native.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-16j-Conway-Hashlife-Correctness-Native.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-17c-Knots-Companion-Formel.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-20b-PFR-Primitives-Transportables.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-21c-Descente-Budget.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-23b-Lean-ERC20-Native-Companion.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-24-Calibration-Native-Companion.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-27-EdgeColoring-Tutte-Companion.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-29-Hecke-Operators-Native.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-31-Euler-Navier-Stokes.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-34-Calculabilite-et-Limites.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-7b-Examples.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-8b-Erdos-Formal-Conjectures-Native.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical/Planners-5b-Lean-Relaxation.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical/Planners-6-Domains-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-01-Introduction-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-02-Sudoku-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-03-Tactics-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-04-Strings-Regex-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-05-Quantifiers-Proofs-Python.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-06-Advanced-Optimization-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-14-BitVectors-Overflow-Python.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-16c-Meal-Planner-Patient-Capstone-Python.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-16d-Meal-Planner-Convergence-Scale-Python.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-16e-Meal-Planner-Optimize-Python.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-18-Sudoku-Modes-Python.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API/Z3-Python-17-Array-Theory.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-API" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/07_Meal_Planner_Data_External.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/10_Witness_Generation_Automata.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/14_Optimize_MaxSAT.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/15_BitVectors_Overflow.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/16_RealArithmetic.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/18_Einsteins_Riddle.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb/SW-11-CSharp-KnowledgeGraphs.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb/SW-14-Python-Coup-Ontologique.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb/SW-16-Python-ProofCarryingOntologies.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb/SW-3b-Python-GraphOperations.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb/SW-5b-Python-LinkedData.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb/SW-6b-Python-RDFS.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SemanticWeb" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-1-LogicalLearning-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-10-ActiveAutomataLearning-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-12b-PavlovDLS-Reproduction-output.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-12b-PavlovDLS-Reproduction.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-13-Discover-TPR-output.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-13-Discover-TPR.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-1b-LogicalLearning-Lean-Native.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-2-KnowledgeBasedLearning-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-3-RelevanceLearning-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-4-InductiveLogicProgramming-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-5-InverseResolution-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-6-ModernILP-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning/SL-8-KnowledgeGraphs-ILP-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SymbolicLearning" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-07a-Extended-Frameworks-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-07b-Ranking-Probabilistic-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-09-Preferences-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-11-Causal-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-12-Grounded-Via-TweetyProject.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-4-Aspic-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-5b-Lean-Argumentation.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "orphan_entry", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-5e-Propositional-Lab-Lean.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Tweety" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/02-Advanced/02-5-Multi-Model-TTS-Gateway.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/02-Advanced" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/Audio/02-Advanced/02-6-MIDI-Generation.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Audio/02-Advanced" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/Image/examples/literature-visual.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Image/examples" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/Image/examples/science-diagrams.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/Image/examples" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/PostTraining/PT_03_dpo_direct_preference.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/PostTraining" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/01-SemanticKernel-Intro.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/02-SemanticKernel-Advanced.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/03-SemanticKernel-Agents.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/04-SemanticKernel-Filters-Observability.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/05-SemanticKernel-VectorStores.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/06-SemanticKernel-ProcessFramework.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/07-SemanticKernel-MultiModal.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/08-SemanticKernel-MCP.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/09-SemanticKernel-Building-CLR.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/10-SemanticKernel-NotebookMaker.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/10a-SemanticKernel-NotebookMaker-batch.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/10b-SemanticKernel-NotebookMaker-batch-parameterized.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/fort-boyard-csharp.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/GenAI/SemanticKernel/fort-boyard-python.ipynb", + "series": "MyIA.AI.Notebooks/GenAI/SemanticKernel" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/IIT/IIT-01-IntroToPyPhi.ipynb", + "series": "MyIA.AI.Notebooks/IIT" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/IIT/IIT-02-AdvancedTopics.ipynb", + "series": "MyIA.AI.Notebooks/IIT" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/ML/ML.Net/ML-10-TSAD-Benchmark-Flaws-Python.ipynb", + "series": "MyIA.AI.Notebooks/ML/ML.Net" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/ML/ML.Net/ML-11-MatrixProfile-Multidim-Python.ipynb", + "series": "MyIA.AI.Notebooks/ML/ML.Net" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC/DecPyMC-11-Valeur-Info-Souscription.ipynb", + "series": "MyIA.AI.Notebooks/Probas/DecisionTheory/DecPyMC" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-01-Setup.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-02-Platform-Fundamentals.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-03-Data-Management.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/QuantConnect/Python/QC-Py-04-Research-Workflow.ipynb", + "series": "MyIA.AI.Notebooks/QuantConnect/Python" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-15-SportsScheduling.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-15b-SportsScheduling-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-16-Crossword-CSP-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-16-Crossword-CSP.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-19-ProceduralGeneration-WFC-CSharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/CSP/App-19-ProceduralGeneration-WFC.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Applications/Hybrid/App-13-TSP-Metaheuristics.ipynb", + "series": "MyIA.AI.Notebooks/Search/Applications/Hybrid" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03e-AStar-Optimality.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-09d-Lean-Discrepancy-Komlos.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-11b-Metaheuristiques-Deep-Part2.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-11b-Metaheuristiques-Deep-Part3.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part1-Foundations/Search-11b-Metaheuristiques-Deep-Part4.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part1-Foundations" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part2-CSP/CSP-8-Temporal-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part2-CSP" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-09-EverestRelief.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-10-CenterBias.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-14-IslandSynergyFound.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-15-LandscapeAnalysis.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-16-AlgorithmSelection.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-18-CecBanc.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-19-MetropolisReinsertion.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics/MGS-21-Representation-vs-Algorithme.ipynb", + "series": "MyIA.AI.Notebooks/Search/Part4-Metaheuristics" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Lean/Lean-23-ERC20-Invariant-Companion.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Lean" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical/Planners-4-Fast-Downward-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical/Planners-5-Heuristics-Csharp.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical/Planners-5c-Differentiel-Atteignabilite.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/Planners/02-Classical" + }, + { + "kind": "unreachable", + "notebook": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3/03_Sudoku_Modes_Comparison.ipynb", + "series": "MyIA.AI.Notebooks/SymbolicAI/SMT/Z3-Linq2Z3" + } + ], + "wrapped": [ + { + "series": "MyIA.AI.Notebooks/GenAI/00-GenAI-Environment", + "notebooks": 6 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Audio/01-Foundation", + "notebooks": 5 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Audio/03-Orchestration", + "notebooks": 3 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Image/01-Foundation", + "notebooks": 6 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Image/03-Orchestration", + "notebooks": 4 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Image/04-Applications", + "notebooks": 4 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Vibe-Coding/Claude-Code/notebooks", + "notebooks": 5 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Video/03-Orchestration", + "notebooks": 3 + }, + { + "series": "MyIA.AI.Notebooks/GenAI/Video/04-Applications", + "notebooks": 6 + }, + { + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/01-PythonForDataScience/notebooks", + "notebooks": 2 + }, + { + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day4-Foundations", + "notebooks": 2 + }, + { + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day6-MLE-Star", + "notebooks": 3 + }, + { + "series": "MyIA.AI.Notebooks/ML/DataScienceWithAgents/Track2-GoogleADK/Day7-Production", + "notebooks": 2 + }, + { + "series": "MyIA.AI.Notebooks/SymbolicAI/Planners/04-NeuroSymbolic", + "notebooks": 4 + }, + { + "series": "MyIA.AI.Notebooks/SymbolicAI/SmartContracts/01-Solidity-Foundation", + "notebooks": 4 + }, + { + "series": "MyIA.AI.Notebooks/SymbolicAI/SmartContracts/03-Foundry-Testing", + "notebooks": 3 + }, + { + "series": "MyIA.AI.Notebooks/SymbolicAI/SmartContracts/04-Privacy-Cryptography", + "notebooks": 3 + }, + { + "series": "MyIA.AI.Notebooks/SymbolicAI/SmartContracts/05-Alternative-Chains", + "notebooks": 5 + } + ] +}