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 + } + ] +}