Théorie de l’Information

Comprendre la mesure de l’information (bits, entropie de Shannon) et les principes de compression et transmission.

Claude Shannon

Le problème fondamental de la communication est de reproduire en un point, exactement ou approximativement, un message choisi en un autre point. – Claude Shannon

En 1948, Claude Shannon publie A Mathematical Theory of Communication et pose les bases de la théorie de l’information : l’information devient une grandeur physique mesurable, au même titre que l’énergie ou la température. Cette théorie est le fondement invisible de tout le numérique — de la compression ZIP aux intelligences artificielles.

L’information comme grandeur physique

Définition intuitive

L’information est la réduction d’incertitude apportée par un événement. Plus un événement est improbable, plus il est surprenant — et plus il transporte d’information.

Exemples :

• Apprendre qu’il neige en juillet → beaucoup d’information
• Apprendre que le soleil s’est levé → presque aucune information

L’information n’est pas dans le message lui-même, mais dans l’inattendu qu’il contient.

Les trois axiomes de Shannon

Shannon exige de toute mesure d’information qu’elle vérifie :

1. Continuité — une variation légère de probabilité implique une variation légère d’information.
2. Maximalité — l’incertitude est maximale quand tous les événements possibles sont équiprobables.
3. Additivité — l’information de deux événements indépendants est la somme de leurs informations.

La seule fonction vérifiant ces trois axiomes est :

\[I(p) = -\log_2 p\]

Le bit — mesurer la surprise

Le bit (binary digit) est l’unité fondamentale de l’information. Il correspond à la surprise apportée par l’un des deux résultats d’une pièce équilibrée (\(p = \tfrac{1}{2}\)).

\[I(p) = -\log_2 p \quad \text{(bits)}\]

Plus \(p\) est petit (événement rare), plus \(I(p)\) est grand (surprise élevée).

Simulateur — Contenu informationnel I(p)

Ajustez la probabilité d’un événement et observez sa valeur informationnelle sur la courbe.

viewof inf_p = aptitek.createSlider({
  label: "Probabilité de l'événement (%)",
  value: 50, min: 1, max: 99, step: 1
})

Probabilité p	Information I(p)
%	bits

inf_ip = (-Math.log2(inf_p / 100)).toFixed(3)

renderIPChart = {
  inf_p;
  const xs = Array.from({length: 198}, (_, i) => (i + 1) / 200 * 100);
  const ys = xs.map(x => -Math.log2(x / 100));
  const p0 = inf_p, I0 = -Math.log2(p0 / 100);
  window.Plotly.newPlot("inf-ip-canvas", [
    {
      x: xs, y: ys, mode: "lines", name: "I(p)",
      line: { color: getThemeColor("--sol-blue", "#268bd2"), width: 2.5 },
      fill: "tozeroy", fillcolor: "rgba(38,139,210,0.07)",
      hovertemplate: "p = %{x:.0f}%<br>I = %{y:.3f} bits<extra></extra>"
    },
    {
      x: [p0], y: [I0], mode: "markers",
      marker: { size: 13, color: getThemeColor("--sol-red", "#dc322f"), symbol: "circle-open", line: { width: 3, color: getThemeColor("--sol-red", "#dc322f") } },
      hovertemplate: "p = %{x}%<br>I = %{y:.3f} bits<extra></extra>"
    }
  ], {
    xaxis: { title: "Probabilité p (%)", range: [0, 100] },
    yaxis: { title: "I(p)  (bits)", range: [0, 7] },
    paper_bgcolor: "transparent", plot_bgcolor: "transparent",
    margin: { t: 20, b: 50, l: 65, r: 20 },
    template: getPlotlyTheme(), showlegend: false
  }, { responsive: true, displayModeBar: false });
}

Exemples remarquables :

Événement	Probabilité	Information
Pile ou face (équilibré)	\(\tfrac{1}{2}\)	\(1\) bit
Face d’un dé à 6 faces	\(\tfrac{1}{6}\)	\(\approx 2{,}58\) bits
Carte tirée parmi 52	\(\tfrac{1}{52}\)	\(\approx 5{,}70\) bits
Octet précis parmi 256	\(\tfrac{1}{256}\)	\(8\) bits exactement

L’entropie de Shannon

L’entropie \(H(X)\) mesure l’incertitude moyenne d’une source : c’est la quantité d’information qu’on espère recevoir à chaque symbole émis. C’est l’espérance de \(I(p)\) :

\[H(X) = -\sum_{i=1}^{N} p_i \log_2 p_i \quad \text{(bits par symbole)}\]

Entropie d’une source binaire

Une source émet «0» avec probabilité \(p\) et «1» avec probabilité \(1 - p\).

viewof inf_ep = aptitek.createSlider({
  label: "Probabilité de «0» (p)",
  value: 50, min: 1, max: 99, step: 1
})

p («0»)	1 − p («1»)	Entropie H
%	%	bits/symb.

inf_ep1 = 100 - inf_ep
inf_hval = {
  const p = inf_ep / 100, q = 1 - p;
  const t1 = p > 0 ? -p * Math.log2(p) : 0;
  const t2 = q > 0 ? -q * Math.log2(q) : 0;
  return (t1 + t2).toFixed(4);
}

renderEntropyChart = {
  inf_ep;
  const xs = Array.from({length: 198}, (_, i) => (i + 1) / 200 * 100);
  const ys = xs.map(x => { const p = x/100, q = 1-p; return -p*Math.log2(p) - q*Math.log2(q); });
  const p0 = inf_ep, H0 = parseFloat(inf_hval);
  window.Plotly.newPlot("inf-entropy-canvas", [
    {
      x: xs, y: ys, mode: "lines",
      line: { color: getThemeColor("--sol-green", "#859900"), width: 2.5 },
      fill: "tozeroy", fillcolor: "rgba(133,153,0,0.08)",
      hovertemplate: "p = %{x:.0f}%<br>H = %{y:.4f} bits<extra></extra>"
    },
    {
      x: [p0], y: [H0], mode: "markers",
      marker: { size: 13, color: getThemeColor("--sol-orange", "#cb4b16"), symbol: "circle-open", line: { width: 3, color: getThemeColor("--sol-orange", "#cb4b16") } },
      hovertemplate: "p = %{x}%<br>H = %{y:.4f} bits<extra></extra>"
    }
  ], {
    xaxis: { title: "p (%)", range: [0, 100] },
    yaxis: { title: "H(p)  (bits/symbole)", range: [0, 1.15] },
    paper_bgcolor: "transparent", plot_bgcolor: "transparent",
    margin: { t: 30, b: 50, l: 65, r: 20 },
    template: getPlotlyTheme(), showlegend: false,
    annotations: [{
      x: 50, y: 1.0, text: "Maximum : H = 1 bit  (p = 50 %)",
      showarrow: true, arrowhead: 2, arrowcolor: "#586e75",
      ax: 0, ay: -28, font: { size: 11 }
    }]
  }, { responsive: true, displayModeBar: false });
}

Interprétation clé : H est maximale (\(H = 1\) bit) à \(p = 0{,}5\) — la source est totalement imprévisible. Elle vaut 0 aux extrêmes (\(p = 0\) ou \(p = 1\)) — quand l’issue est certaine, il n’y a rien à apprendre.

Entropie de différentes sources

La distribution de probabilités d’une source détermine son entropie, mais la séquence qu’elle produit révèle quelque chose de plus : à haute entropie, les tirages sont dispersés sans motif apparent ; à faible entropie, ils se groupent ; une source déterministe produit un patron parfaitement régulier.

Comparer des sources

N symboles	Entropie H	H max (\(\log_2 N\))
	bits	bits

mutable inf_src_key = "Pièce équilibrée"

_srcTabWatcher = {
  const w = createTabsetWatcher(
    ".inf-src-tabs",
    {
      "Pièce équilibrée": "Pièce équilibrée",
      "Pièce biaisée":    "Pièce biaisée",
      "Dé équilibré":     "Dé équilibré",
      "Dé biaisé":        "Dé biaisé",
      "8 symboles":       "8 symboles équiprobables",
      "Cyclique":         "Séquence cyclique"
    },
    (val) => { mutable inf_src_key = val; }
  );
  invalidation.then(() => w.destroy());
  return null;
}

inf_regen = Generators.observe((change) => {
  let clicks = 0;
  let retryId = null;
  let cleanup = () => {};

  const bind = () => {
    const button = document.getElementById("inf-regen-btn");
    if (!button) {
      retryId = setTimeout(bind, 50);
      return;
    }

    const onClick = (event) => {
      event.preventDefault();
      change(++clicks);
    };

    button.addEventListener("click", onClick);
    change(clicks);
    cleanup = () => button.removeEventListener("click", onClick);
  };

  bind();

  return () => {
    if (retryId) clearTimeout(retryId);
    cleanup();
  };
})

inf_src_data = {
  const db = {
    "Pièce équilibrée":         { labels: ["Pile","Face"],                    probs: [0.5, 0.5],                               mode: "random" },
    "Pièce biaisée":            { labels: ["Pile","Face"],                    probs: [0.9, 0.1],                               mode: "random" },
    "Dé équilibré":             { labels: ["1","2","3","4","5","6"],          probs: [1/6,1/6,1/6,1/6,1/6,1/6],               mode: "random" },
    "Dé biaisé":                { labels: ["1","2","3","4","5","6"],          probs: [0.5,0.1,0.1,0.1,0.1,0.1],               mode: "random" },
    "8 symboles équiprobables": { labels: ["A","B","C","D","E","F","G","H"],  probs: [.125,.125,.125,.125,.125,.125,.125,.125], mode: "random" },
    "Séquence cyclique":        { labels: ["A","B","C","D","E","F"],          probs: [1/6,1/6,1/6,1/6,1/6,1/6],               mode: "cyclic" }
  };
  return db[inf_src_key] || db["Pièce équilibrée"];
}

inf_src_n    = inf_src_data.labels.length
inf_src_h    = inf_src_data.probs.reduce((a, p) => a + (p > 0 ? -p * Math.log2(p) : 0), 0).toFixed(4)
inf_src_hmax = Math.log2(inf_src_n).toFixed(4)

inf_src_palette = [
  getThemeColor("--sol-blue"),
  getThemeColor("--sol-green"),
  getThemeColor("--sol-orange"),
  getThemeColor("--sol-red"),
  getThemeColor("--sol-violet"),
  getThemeColor("--sol-cyan"),
  getThemeColor("--sol-magenta"),
  getThemeColor("--sol-yellow")
]

renderSrcChart = {
  inf_src_data;
  inf_src_palette;
  const { labels, probs } = inf_src_data;
  const colors = labels.map((_, i) => inf_src_palette[i % inf_src_palette.length]);
  createBar("inf-src-canvas",
    { x: labels, y: probs.map(p => +(p * 100).toFixed(2)) },
    "Distribution",
    {
      marker: {
        color: colors,
        line: { color: colors.map(c => aptitek.utils.rgba(c, 0.55)), width: 1.5 }
      },
      layout: {
        yaxis: {
          title: "Probabilité (%)",
          range: [0, 110],
          gridcolor: aptitek.utils.rgba(getThemeColor("--sol-base1"), 0.18),
          zerolinecolor: aptitek.utils.rgba(getThemeColor("--sol-base1"), 0.35)
        },
        paper_bgcolor: "transparent", plot_bgcolor: "transparent",
        margin: { t: 40, b: 40, l: 60, r: 20 }
      }
    }
  );
}

scatter_samples = {
  inf_src_data;
  inf_regen;
  const { probs, mode, labels } = inf_src_data;
  const N = 200;
  if (mode === "cyclic") return Array.from({length: N}, (_, i) => i % labels.length);
  const cumul = probs.reduce((acc, p) => { acc.push((acc.length ? acc[acc.length - 1] : 0) + p); return acc; }, []);
  return Array.from({length: N}, () => { const r = Math.random(); const i = cumul.findIndex(c => r < c); return i === -1 ? probs.length - 1 : i; });
}

renderScatterChart = {
  scatter_samples;
  inf_src_palette;
  const { labels } = inf_src_data;
  const N = scatter_samples.length;
  const traces = labels.map((lbl, i) => {
    const xs = scatter_samples.reduce((a, s, idx) => { if (s === i) a.push(idx); return a; }, []);
    return { x: xs, y: Array(xs.length).fill(lbl), mode: "markers", name: lbl,
      marker: {
        size: 5,
        color: inf_src_palette[i % inf_src_palette.length],
        opacity: 0.78,
        line: { color: aptitek.utils.rgba(getThemeColor("--sol-base03"), 0.25), width: 0.5 }
      },
      hovertemplate: `#%{x} → ${lbl}<extra></extra>` };
  });
  window.Plotly.newPlot("inf-scatter-canvas", traces, {
    title: { text: "Séquence — 200 tirages", font: { size: 13 } },
    xaxis: {
      title: "Index",
      range: [-2, N + 2],
      gridcolor: aptitek.utils.rgba(getThemeColor("--sol-base1"), 0.14),
      zerolinecolor: aptitek.utils.rgba(getThemeColor("--sol-base1"), 0.28)
    },
    yaxis: {
      title: "Symbole",
      autorange: "reversed",
      gridcolor: aptitek.utils.rgba(getThemeColor("--sol-base1"), 0.10)
    },
    paper_bgcolor: "transparent", plot_bgcolor: "transparent",
    margin: { t: 40, b: 50, l: 80, r: 20 },
    template: getPlotlyTheme(), showlegend: false
  }, { responsive: true, displayModeBar: false });
}

À retenir : la séquence cyclique a la même entropie marginale qu’un dé équilibré (\(H = \log_2 6\)), mais sa séquence est parfaitement prévisible. Shannon mesure l’incertitude par symbole isolé, pas les corrélations temporelles.

Unités et ordres de grandeur

L’unité de base est le bit (b). En pratique, on stocke et transfère l’information en octets (o) : 1 octet = 8 bits. Les unités suivantes s’enchaînent en puissances de mille (SI) ou de deux (IEC).

Règle logarithmique des unités

Déplacez le curseur pour explorer l’échelle de gauche (bit) à droite (pétaoctet). Les objets du quotidien sont positionnés à leur taille réelle sur la règle logarithmique.

viewof inf_unit_zoom = aptitek.createSlider({
  label: "Unité explorée",
  labels: ["bit", "octet", "Ko", "Mo", "Go", "To", "Po"],
  value: 2, min: 0, max: 6, step: 1
})

INF_UNITS = [
  { name: "bit",       sym: "b",  icon: "⚙️", log10: Math.log10(1/8), val: "1/8 octet",  desc: "L'unité atomique. Représente deux états : 0 ou 1.",                          ex: ["Résultat d'un lancer de pièce", "Pixel binaire (noir/blanc)", "État d'une porte logique"],   iec: { sym: "—", val: "—", ecart: "—",     ecart_pct: 0,    note: "Le bit est universel — aucune distinction SI/IEC." } },
  { name: "octet",     sym: "o",  icon: "🔤", log10: 0,               val: "8 bits",     desc: "L'unité de stockage de base. Encode un caractère ASCII ou une valeur 0–255.", ex: ["1 caractère texte (ASCII)", "1 pixel en niveaux de gris", "1 couleur RGB = 3 octets"],       iec: { sym: "—", val: "—", ecart: "—",     ecart_pct: 0,    note: "L'octet est universel — aucune distinction SI/IEC." } },
  { name: "kilooctet", sym: "Ko", icon: "📝", log10: 3,               val: "10³ octets", desc: "La plus petite unité de fichier pratique du quotidien.",                     ex: ["SMS (160 c.) ≈ 0,16 Ko", "Fichier texte court ≈ 2 Ko", "Code source d'une fonction"],         iec: { sym: "Kio", val: "2¹⁰ o = 1 024 o",     ecart: "+2,4 %", ecart_pct: 2.4,  note: "100 Ko (fabricant) = 97,7 Kio dans l'OS." } },
  { name: "mégaoctet", sym: "Mo", icon: "🖼️", log10: 6,               val: "10⁶ octets", desc: "Photo numérique, page web complète ou fichier audio court.",                  ex: ["Photo JPEG ≈ 3 Mo", "Page web complète ≈ 2 Mo", "1 min de musique MP3 ≈ 1 Mo"],            iec: { sym: "Mio", val: "2²⁰ o ≈ 1,05 Mo",     ecart: "+4,9 %", ecart_pct: 4.9,  note: "500 Mio affichés par l'OS = 524 Mo selon le fabricant." } },
  { name: "gigaoctet", sym: "Go", icon: "🎬", log10: 9,               val: "10⁹ octets", desc: "Capacité d'un film HD, d'une barrette RAM ou du génome humain brut.",         ex: ["Film HD ≈ 4 Go", "Génome humain brut ≈ 3 Go", "Application mobile ≈ 0,1–1 Go"],           iec: { sym: "Gio", val: "2³⁰ o ≈ 1,07 Go",     ecart: "+7,4 %", ecart_pct: 7.4,  note: "Clé USB 8 Go (fabricant) = 7,45 Gio dans l'OS." } },
  { name: "téraoctet", sym: "To", icon: "💾", log10: 12,              val: "10¹² octets", desc: "Disques durs et SSD grand public. Des bibliothèques vidéo entières.",         ex: ["SSD 1 To ≈ 250 000 photos", "HDD 4 To ≈ 1 000 films HD", "Wikipedia intégral (texte) ≈ 22 Go"], iec: { sym: "Tio", val: "2⁴⁰ o ≈ 1,10 To",    ecart: "+10,0 %", ecart_pct: 10.0, note: "Disque 1 To (fabricant) = 931 Gio dans Windows/macOS." } },
  { name: "pétaoctet", sym: "Po", icon: "🏢", log10: 15,              val: "10¹⁵ octets", desc: "Échelle des data centers et grandes plateformes mondiales.",                  ex: ["Facebook photos > 100 Po", "CERN LHC ≈ 15 Po/an", "Toute la musique jamais enregistrée ≈ 3 Po"], iec: { sym: "Pio", val: "2⁵⁰ o ≈ 1,13 Po",    ecart: "+12,6 %", ecart_pct: 12.6, note: "1 Po (SI) ≈ 888 Tio selon la définition IEC." } },
]

INF_OBJECTS = [
  { name: "SMS",      bytes: 160,    y: 0.55, icon: "💬", color: "--sol-blue" },
  { name: "E-mail",   bytes: 25e3,   y: 0.80, icon: "✉️", color: "--sol-cyan" },
  { name: "Page web", bytes: 500e3,  y: 0.55, icon: "🌐", color: "--sol-green" },
  { name: "Photo",    bytes: 3e6,    y: 0.80, icon: "🖼️", color: "--sol-blue" },
  { name: "MP3",      bytes: 4e6,    y: 1.05, icon: "🎵", color: "--sol-yellow" },
  { name: "Génome",   bytes: 3e9,    y: 0.80, icon: "🧬", color: "--sol-violet" },
  { name: "Film HD",  bytes: 4e9,    y: 0.55, icon: "🎬", color: "--sol-orange" },
  { name: "SSD 1To",  bytes: 1e12,   y: 0.55, icon: "💾", color: "--sol-red" },
]

unit_example_icon = (text) => {
  const key = String(text);
  if (key.includes("Photo")) return "🖼️";
  if (key.includes("Page web")) return "🌐";
  if (key.includes("MP3") || key.includes("musique")) return "🎵";
  if (key.includes("SMS")) return "💬";
  if (key.includes("texte")) return "📝";
  if (key.includes("Code")) return "⌨️";
  if (key.includes("Film")) return "🎬";
  if (key.includes("Génome")) return "🧬";
  if (key.includes("SSD") || key.includes("HDD")) return "💾";
  if (key.includes("Wikipedia")) return "📚";
  if (key.includes("CERN")) return "🔬";
  if (key.includes("Facebook")) return "🏢";
  return "📦";
}

inf_unit_focus        = INF_UNITS[inf_unit_zoom]
inf_unit_name         = inf_unit_focus.name
inf_unit_icon         = inf_unit_focus.icon
inf_unit_sym          = inf_unit_focus.sym
inf_unit_val          = inf_unit_focus.val
inf_unit_desc         = inf_unit_focus.desc
inf_unit_ex1          = inf_unit_focus.ex[0]
inf_unit_ex2          = inf_unit_focus.ex[1]
inf_unit_ex3          = inf_unit_focus.ex[2]
inf_unit_ex1_icon     = unit_example_icon(inf_unit_ex1)
inf_unit_ex2_icon     = unit_example_icon(inf_unit_ex2)
inf_unit_ex3_icon     = unit_example_icon(inf_unit_ex3)
inf_unit_iec_sym      = inf_unit_focus.iec.sym
inf_unit_iec_val      = inf_unit_focus.iec.val
inf_unit_iec_ecart    = inf_unit_focus.iec.ecart
inf_unit_iec_ecart_pct = inf_unit_focus.iec.ecart_pct
inf_unit_iec_note     = inf_unit_focus.iec.note

renderUnitsChart = {
  inf_unit_zoom;
  const focusLog = INF_UNITS[inf_unit_zoom].log10;

  const unitTicks = {
    x: INF_UNITS.map(u => u.log10),
    y: Array(7).fill(0),
    mode: "markers",
    type: "scatter",
    marker: {
      size:   INF_UNITS.map((_, i) => i === inf_unit_zoom ? 18 : 12),
      color:  INF_UNITS.map((_, i) => i === inf_unit_zoom ? getThemeColor("--sol-red",  "#dc322f") : getThemeColor("--sol-blue", "#268bd2")),
      symbol: INF_UNITS.map((_, i) => i === inf_unit_zoom ? "diamond" : "triangle-up"),
      line:   { width: 0 }
    },
    hovertemplate: INF_UNITS.map(u => `${u.name} (${u.sym})<extra></extra>`),
    name: ""
  };

  const objDots = {
    x: INF_OBJECTS.map(o => Math.log10(o.bytes)),
    y: INF_OBJECTS.map(o => o.y),
    mode: "markers+text",
    type: "scatter",
    marker: {
      size: 24,
      color: INF_OBJECTS.map(o => aptitek.utils.rgba(getThemeColor(o.color), 0.16)),
      line: {
        color: INF_OBJECTS.map(o => getThemeColor(o.color)),
        width: 2
      },
      symbol: "circle"
    },
    text: INF_OBJECTS.map(o => o.icon),
    textposition: "middle center",
    textfont: {
      size: 15,
      color: INF_OBJECTS.map(o => getThemeColor(o.color))
    },
    hovertemplate: INF_OBJECTS.map(o => `${o.name}<extra></extra>`),
    name: ""
  };

  const shapes = [
    { type: "line", x0: -1.5, x1: 16, y0: 0, y1: 0,
      line: { color: getThemeColor("--sol-base1", "#93a1a1"), width: 3 } },
    ...INF_OBJECTS.map(o => ({
      type: "line",
      x0: Math.log10(o.bytes), x1: Math.log10(o.bytes), y0: 0, y1: o.y,
      line: { color: getThemeColor("--sol-base1", "#93a1a1"), width: 1, dash: "dot" }
    })),
    { type: "line", x0: focusLog, x1: focusLog, y0: -0.4, y1: 0,
      line: { color: getThemeColor("--sol-red", "#dc322f"), width: 2 } }
  ];

  window.Plotly.newPlot("inf-units-canvas", [unitTicks, objDots], {
    xaxis: {
      range: [-1.5, 16],
      tickvals: [-0.9, 0, 3, 6, 9, 12, 15],
      ticktext: ["bit", "octet", "Ko", "Mo", "Go", "To", "Po"],
      title: "← Plus petit  ·  Taille (log₁₀ octets)  ·  Plus grand →",
      showgrid: true, gridcolor: "rgba(147,161,161,0.15)"
    },
    yaxis: { range: [-0.55, 1.35], showticklabels: false, showgrid: false, zeroline: false },
    paper_bgcolor: "transparent", plot_bgcolor: "transparent",
    margin: { t: 15, b: 70, l: 20, r: 20 },
    template: getPlotlyTheme(), showlegend: false, shapes
  }, { responsive: true, displayModeBar: false });
}

SI Unité SI

IEC Équivalent IEC

Écart

0 %

Type de contenu

Exemple

Exemple

Exemple

Les préfixes SI (décimaux) et IEC (binaires) diffèrent légèrement — d’où les capacités qui semblent « perdues ».

Mb ≠ MB — un facteur 8 qui trompe tout le monde

Les opérateurs télécom et FAI expriment les débits en mégabits par seconde (Mb/s ou Mbps), tandis que les fichiers et le stockage sont mesurés en mégaoctets (Mo ou MB).

Notation	Nom	Valeur
Mb	mégabit	\(10^6\) bits
MB / Mo	mégaoctet	\(10^6\) octets = \(8 \times 10^6\) bits
Gb	gigabit	\(10^9\) bits
GB / Go	gigaoctet	\(10^9\) octets = \(8 \times 10^9\) bits

Exemple concret : une connexion annoncée à 100 Mb/s transfère au maximum \(100 \div 8 = \mathbf{12{,}5\ \text{Mo/s}}\) de données. Un fichier de 1 Go prend donc au minimum \(1000 \div 12{,}5 = 80\) secondes à télécharger — pas 10 secondes.

Propriétés fondamentales

Non-négativité

\[I(p) \geq 0 \quad \forall p \in \,]0, 1]\]

L’information ne peut pas être négative. Elle est nulle uniquement pour un événement certain (\(p = 1\)) : ce qui est sûr n’apporte rien de nouveau.

Additivité

\[I(p_1 \cdot p_2) = I(p_1) + I(p_2)\]

Pour deux événements indépendants, l’information totale est la somme. C’est la propriété qui justifie le choix du logarithme : \(-\log_2(p_1 p_2) = -\log_2 p_1 - \log_2 p_2\).

Maximalité uniforme

\[H(X) \leq \log_2 N\]

L’entropie d’une source à \(N\) symboles est maximale quand la distribution est uniforme. Pour un dé équilibré : \(H = \log_2 6 \approx 2{,}58\) bits/face.

Décroissance monotone

\[p_1 > p_2 \implies I(p_1) < I(p_2)\]

\(I\) est strictement décroissante : plus un événement est probable, moins il est informatif. La surprise grandit avec la rareté.