@jjlmoya/utils-science 1.33.0 → 1.34.0

package/src/tool/three-body-problem/entry.ts

@@ -0,0 +1,26 @@
+import type { ScienceToolEntry } from '../../types';
+
+export const threeBodyProblem: ScienceToolEntry = {
+  id: 'three-body-problem-simulator',
+  icons: {
+    bg: 'mdi:orbit-variant',
+    fg: 'mdi:vector-polyline',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/three-body-problem/i18n/de.ts

@@ -0,0 +1,162 @@
+import { bibliography } from '../bibliography';
+import type { ToolLocaleContent } from '../../../types';
+
+const slug = 'dreikoerperproblem-simulator';
+const title = 'Dreikörperproblem Simulator';
+const description = 'Simuliere drei Gravitationskörper in einer zweidimensionalen Ebene mit einstellbaren Massen, Geschwindigkeitsvektoren, Spuren und stabilen oder chaotischen Voreinstellungen.';
+
+const howTo = [
+  {
+    name: 'Wähle eine orbitale Voreinstellung',
+    text: 'Beginne mit der Achterbahn für einen stabilen Referenzfall, dem Lagrange-Dreieck für ein rotierendes Gleichgewicht oder der Schleudervoreinstellung für eine sichtbar chaotische Begegnung.',
+  },
+  {
+    name: 'Passe Massen und Geschwindigkeitsvektoren an',
+    text: 'Nutze die Schieberegler für jeden Körper, um Masse und anfängliche Geschwindigkeitskomponenten zu ändern. Kleine Änderungen können ein Muster bewahren, verformen oder vollständig zerstören.',
+  },
+  {
+    name: 'Lies die Diagnosewerte',
+    text: 'Beobachte die Gesamtenergie, die nächste und entfernteste Entfernung sowie den Massenschwerpunkt, um zu verstehen, ob die numerische Umlaufbahn gebunden bleibt oder auseinanderdriftet.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Was ist das Dreikörperproblem?',
+    answer: 'Das Dreikörperproblem fragt, wie sich drei Massen bewegen, wenn jeder Körper die beiden anderen gravitativ anzieht. Anders als beim Zweikörperproblem gibt es keine allgemeine geschlossene Gleichung, die jede mögliche Konfiguration löst, daher werden die meisten praktischen Fälle mit numerischer Integration untersucht.',
+  },
+  {
+    question: 'Warum sind Dreikörperumlaufbahnen instabil?',
+    answer: 'Viele Dreikörpersysteme sind empfindlich gegenüber Anfangsbedingungen. Eine winzige Änderung der Geschwindigkeit, Position oder Masse verändert den Zeitpunkt naher Begegnungen, und diese Begegnungen können dramatisch Energie austauschen. Das Ergebnis ist ein System, das eine Weile gebunden bleiben und dann plötzlich einen Körper ausstoßen kann.',
+  },
+  {
+    question: 'Was zeigt die Achterbahn-Voreinstellung?',
+    answer: 'Die Achterbahn-Voreinstellung ist eine berühmte periodische Lösung für drei gleiche Massen. Jeder Körper folgt derselben Bahn mit einem Phasenversatz und zeigt, dass das Dreikörperproblem elegante stabile Inseln innerhalb einer viel größeren chaotischen Landschaft enthalten kann.',
+  },
+  {
+    question: 'Ist dies ein physikalisch exakter Astronomie-Simulator?',
+    answer: 'Dieses Werkzeug verwendet ein abgeschwächtes newtonsches Modell und einen symplektischen Geschwindigkeits-Verlet-Schritt, damit die Bewegung für das Lernen treu und stabil wirkt. Es ist für die interaktive Erkundung konzipiert, nicht für die hochpräzise Ephemeridenvorhersage.',
+  },
+  {
+    question: 'Wie sollte ich die Gesamtenergie interpretieren?',
+    answer: 'Negative Gesamtenergie deutet normalerweise auf ein gebundenes System hin, während Energie nahe Null eine Flucht erleichtern kann. In einer numerischen Simulation warnt eine große Energiedrift auch davor, dass der Zeitschritt oder die Begegnungsgeometrie den Integrator überlastet.',
+  },
+];
+
+export const content: ToolLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    title,
+    kicker: 'Gravitations-Chaos-Labor',
+    canvasLabel: 'Interaktive zweidimensionale Dreikörper-Orbit-Leinwand',
+    presetsLabel: 'Orbitale Voreinstellungen',
+    figureEightPreset: 'Achterbahn',
+    lagrangePreset: 'Lagrange-Dreieck',
+    slingshotPreset: 'Schleuder',
+    pauseButton: 'Pause',
+    playButton: 'Abspielen',
+    resetButton: 'Zurücksetzen',
+    speedLabel: 'Simulationsgeschwindigkeit',
+    trailLabel: 'Spurlänge',
+    massLabel: 'Masse',
+    velocityXLabel: 'Geschwindigkeit X',
+    velocityYLabel: 'Geschwindigkeit Y',
+    energyLabel: 'Gesamtenergie',
+    separationLabel: 'Entfernungsbereich',
+    centerMassLabel: 'Massenschwerpunkt',
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Interaktiver Dreikörperproblem-Simulator für orbitales Chaos',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Dreikörperproblem ist eine der klarsten Demonstrationen dafür, dass einfache Gesetze komplizierte Bewegungen erzeugen können. Die newtonsche Gravitation liefert eine kompakte Kraftregel, aber sobald ein dritter massiver Körper zum System hinzukommt, formt jeder Orbit kontinuierlich die beiden anderen um. Dieser Simulator lässt dich direkt mit dieser Instabilität experimentieren: Wähle eine bekannte Konfiguration, passe Massen und Geschwindigkeitsvektoren an und beobachte, ob die Körper eine sich wiederholende Umlaufbahn, ein rotierendes Dreieck oder ein chaotisches Streuereignis bilden.',
+    },
+    {
+      type: 'title',
+      text: 'Was die Voreinstellungen zeigen',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Voreinstellung', 'Physikalische Idee', 'Worauf achten'],
+      rows: [
+        ['<strong>Achterbahn</strong>', 'Eine periodische Lösung mit gleichen Massen, bei der alle drei Körper dieselbe Schleife teilen.', 'Der Orbit bleibt nur organisiert, wenn Symmetrie und Geschwindigkeitsgleichgewicht sorgfältig erhalten bleiben.'],
+        ['<strong>Lagrange-Dreieck</strong>', 'Drei Körper besetzen ein gleichseitiges Dreieck, das sich um den Massenschwerpunkt dreht.', 'Massenbilanz und Tangentialgeschwindigkeit verhindern, dass das Dreieck nach innen kollabiert.'],
+        ['<strong>Schleuder</strong>', 'Eine nahe Begegnung überträgt Energie zwischen den Körpern.', 'Ein Körper kann an Geschwindigkeit gewinnen, während ein anderer stärker gebunden wird, was zeigt, warum chaotische Ausstöße auftreten.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum kleine Änderungen wichtig sind',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Bei einem Zweikörper-Orbit bieten der Massenschwerpunkt und die Orbitalellipse ein stabiles geometrisches Bild. In einem Dreikörpersystem wirken nahe Vorbeiflüge wie gravitative Verhandlungen: Ein Körper kann orbitale Energie ausleihen, scharf die Richtung ändern oder eine geordnete Schleife in ein Streuereignis verwandeln. Diese Empfindlichkeit ist der Grund, warum reale astrophysikalische Systeme wie Dreifachsterne, Planeten-Mond-Begegnungen und frühe Sonnensystem-Planetesimale oft numerische Integration erfordern und nicht eine einzige einfache Formel.',
+    },
+    {
+      type: 'title',
+      text: 'Wie man die Diagnose verwendet',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Gesamtenergie</strong> hilft dir zu beurteilen, ob das System gebunden ist und ob die numerische Integration stabil bleibt.',
+        '<strong>Entfernungsbereich</strong> zeigt die nächsten und entferntesten Paarabstände, wodurch Beinahekollisionen und Ausstöße leicht zu erkennen sind.',
+        '<strong>Massenschwerpunkt</strong> sollte relativ stabil bleiben, wenn der anfängliche Impuls ausgeglichen ist; eine Drift deutet auf eine absichtlich asymmetrische Konfiguration oder einen geänderten Geschwindigkeitsvektor hin.',
+        '<strong>Spurlänge</strong> offenbart die langfristige Struktur: Kurze Spuren betonen die aktuelle Interaktion, während lange Spuren sich wiederholende Schleifen und langsame orbitale Präzession sichtbar machen.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Im Werkzeug verwendetes numerisches Modell',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Simulator verwendet die newtonsche invers-quadratische Anziehung mit einem kleinen Glättungsterm, der visuelle Explosionen bei extrem nahen Vorbeiflügen verhindert. Die Bewegung wird mit einem Geschwindigkeits-Verlet-Schritt vorangetrieben, einer gängigen Wahl für Orbit-Demonstrationen, da er das Energieverhalten besser handhabt als ein einfaches Euler-Update. Das Ergebnis ist ein reaktionsschnelles Bildungsmodell, das das qualitative Verhalten des Dreikörperproblems sichtbar macht, ohne professionelle Himmelsmechanik-Software ersetzen zu wollen.',
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: title,
+      description,
+      applicationCategory: 'ScientificApplication',
+      operatingSystem: 'Any',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: faq.map((item) => ({
+        '@type': 'Question',
+        name: item.question,
+        acceptedAnswer: {
+          '@type': 'Answer',
+          text: item.answer,
+        },
+      })),
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: title,
+      step: howTo.map((step) => ({
+        '@type': 'HowToStep',
+        name: step.name,
+        text: step.text,
+      })),
+    },
+  ],
+};

package/src/tool/three-body-problem/i18n/en.ts

@@ -0,0 +1,162 @@
+import { bibliography } from '../bibliography';
+import type { ToolLocaleContent } from '../../../types';
+
+const slug = 'three-body-problem-simulator';
+const title = 'Three Body Problem Simulator';
+const description = 'Simulate three gravitational bodies in a two-dimensional plane with editable masses, velocity vectors, trails, and stable or chaotic presets.';
+
+const howTo = [
+  {
+    name: 'Choose an orbital preset',
+    text: 'Start with the figure-eight orbit for a stable benchmark, the Lagrange triangle for a rotating equilibrium, or the slingshot preset for a visibly chaotic encounter.',
+  },
+  {
+    name: 'Adjust masses and velocity vectors',
+    text: 'Use the sliders for each body to change mass and initial velocity components. Small changes can preserve a pattern, deform it, or destroy it entirely.',
+  },
+  {
+    name: 'Read the diagnostics',
+    text: 'Watch total energy, nearest and farthest separation, and center of mass to understand whether the numerical orbit remains bounded or is drifting apart.',
+  },
+];
+
+const faq = [
+  {
+    question: 'What is the three-body problem?',
+    answer: 'The three-body problem asks how three masses move when each body gravitationally attracts the other two. Unlike the two-body problem, there is no general closed-form equation that solves every possible configuration, so most practical cases are explored with numerical integration.',
+  },
+  {
+    question: 'Why are three-body orbits unstable?',
+    answer: 'Many three-body systems are sensitive to initial conditions. A tiny change in velocity, position, or mass changes the timing of close encounters, and those encounters can exchange energy dramatically. The result is a system that may remain bounded for a while and then suddenly eject one body.',
+  },
+  {
+    question: 'What does the figure-eight preset show?',
+    answer: 'The figure-eight preset is a famous periodic solution for three equal masses. Each body follows the same path with a phase offset, demonstrating that the three-body problem can contain elegant stable islands inside a much larger chaotic landscape.',
+  },
+  {
+    question: 'Is this a physically exact astronomy simulator?',
+    answer: 'This tool uses a softened Newtonian model and a symplectic-style velocity Verlet step so the motion feels faithful and stable for learning. It is designed for interactive exploration rather than high-precision ephemeris prediction.',
+  },
+  {
+    question: 'How should I interpret total energy?',
+    answer: 'Negative total energy usually indicates a bound system, while energy closer to zero can make escape easier. In a numerical simulation, large energy drift also warns that the time step or encounter geometry is stressing the integrator.',
+  },
+];
+
+export const content: ToolLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    title,
+    kicker: 'Gravitational chaos lab',
+    canvasLabel: 'Interactive two-dimensional three-body orbit canvas',
+    presetsLabel: 'Orbital presets',
+    figureEightPreset: 'Figure eight',
+    lagrangePreset: 'Lagrange triangle',
+    slingshotPreset: 'Slingshot',
+    pauseButton: 'Pause',
+    playButton: 'Play',
+    resetButton: 'Reset',
+    speedLabel: 'Simulation speed',
+    trailLabel: 'Trail length',
+    massLabel: 'Mass',
+    velocityXLabel: 'Velocity X',
+    velocityYLabel: 'Velocity Y',
+    energyLabel: 'Total energy',
+    separationLabel: 'Separation range',
+    centerMassLabel: 'Center of mass',
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Interactive Three-Body Problem Simulator for Orbital Chaos',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'The three-body problem is one of the clearest demonstrations that simple laws can produce complicated motion. Newtonian gravity gives a compact force rule, but the moment a third massive body joins the system, each orbit continuously reshapes the other two. This simulator lets you experiment with that instability directly: choose a known configuration, adjust masses and velocity vectors, and watch whether the bodies form a repeating orbit, a rotating triangle, or a chaotic scattering event.',
+    },
+    {
+      type: 'title',
+      text: 'What the Presets Demonstrate',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Preset', 'Physical idea', 'What to look for'],
+      rows: [
+        ['<strong>Figure eight</strong>', 'A periodic equal-mass solution where all three bodies share the same loop.', 'The orbit remains organized only when symmetry and velocity balance are carefully preserved.'],
+        ['<strong>Lagrange triangle</strong>', 'Three bodies occupy an equilateral triangle that rotates around the center of mass.', 'Mass balance and tangential velocity keep the triangle from collapsing inward.'],
+        ['<strong>Slingshot</strong>', 'A close encounter transfers energy between bodies.', 'One body can gain speed while another becomes more tightly bound, revealing why chaotic ejections occur.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Why Small Changes Matter',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'In a two-body orbit, the center of mass and orbital ellipse provide a stable geometric picture. In a three-body system, close passes act like gravitational negotiations: a body can borrow orbital energy, change direction sharply, or convert an orderly loop into a scattering event. That sensitivity is why real astrophysical systems such as triple stars, planet-moon encounters, and early solar-system planetesimals often require numerical integration rather than a single neat formula.',
+    },
+    {
+      type: 'title',
+      text: 'How to Use the Diagnostics',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Total energy</strong> helps you judge whether the system is bound and whether the numerical integration is staying stable.',
+        '<strong>Separation range</strong> shows the closest and farthest pair distances, making near-collisions and ejections easy to spot.',
+        '<strong>Center of mass</strong> should remain relatively steady when the initial momentum is balanced; drift suggests an intentionally asymmetric setup or a changed velocity vector.',
+        '<strong>Trail length</strong> reveals long-term structure: short trails emphasize the current interaction, while long trails expose repeating loops and slow orbital precession.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Numerical Model Used in the Tool',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'The simulator uses Newtonian inverse-square attraction with a small softening term that prevents visual blow-ups during extremely close passes. Motion is advanced with a velocity Verlet style step, a common choice for orbital demonstrations because it handles energy behavior better than a simple Euler update. The result is a responsive educational model that makes the qualitative behavior of the three-body problem visible without pretending to replace professional celestial mechanics software.',
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: title,
+      description,
+      applicationCategory: 'ScientificApplication',
+      operatingSystem: 'Any',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: faq.map((item) => ({
+        '@type': 'Question',
+        name: item.question,
+        acceptedAnswer: {
+          '@type': 'Answer',
+          text: item.answer,
+        },
+      })),
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: title,
+      step: howTo.map((step) => ({
+        '@type': 'HowToStep',
+        name: step.name,
+        text: step.text,
+      })),
+    },
+  ],
+};

package/src/tool/three-body-problem/i18n/es.ts

@@ -0,0 +1,162 @@
+import { bibliography } from '../bibliography';
+import type { ToolLocaleContent } from '../../../types';
+
+const slug = 'simulador-problema-tres-cuerpos';
+const title = 'Simulador del Problema de los Tres Cuerpos';
+const description = 'Simula tres cuerpos gravitacionales en un plano bidimensional con masas editables, vectores de velocidad, estelas y ajustes preestablecidos estables o caóticos.';
+
+const howTo = [
+  {
+    name: 'Elige un ajuste orbital preestablecido',
+    text: 'Empieza con la órbita en forma de ocho para una referencia estable, el triángulo de Lagrange para un equilibrio rotatorio o el ajuste de honda gravitatoria para un encuentro visiblemente caótico.',
+  },
+  {
+    name: 'Ajusta las masas y los vectores de velocidad',
+    text: 'Usa los deslizadores de cada cuerpo para cambiar la masa y las componentes iniciales de la velocidad. Cambios pequeños pueden conservar un patrón, deformarlo o destruirlo por completo.',
+  },
+  {
+    name: 'Lee los diagnósticos',
+    text: 'Vigila la energía total, la separación máxima y mínima, y el centro de masas para saber si la órbita numérica sigue siendo estable o se está desintegrando.',
+  },
+];
+
+const faq = [
+  {
+    question: '¿Qué es el problema de los tres cuerpos?',
+    answer: 'El problema de los tres cuerpos pregunta cómo se mueven tres masas cuando cada una atrae gravitacionalmente a las otras dos. A diferencia del problema de dos cuerpos, no existe una ecuación general de forma cerrada que resuelva toda configuración posible, por lo que la mayoría de los casos prácticos se exploran con integración numérica.',
+  },
+  {
+    question: '¿Por qué son inestables las órbitas de tres cuerpos?',
+    answer: 'Muchos sistemas de tres cuerpos son sensibles a las condiciones iniciales. Un cambio mínimo en la velocidad, la posición o la masa altera el momento de los encuentros cercanos, y esos encuentros pueden intercambiar energía de forma drástica. El resultado es un sistema que puede permanecer estable un tiempo y luego expulsar de repente a uno de los cuerpos.',
+  },
+  {
+    question: '¿Qué muestra el ajuste preestablecido de la órbita en forma de ocho?',
+    answer: 'El ajuste en forma de ocho es una famosa solución periódica para tres masas iguales. Cada cuerpo sigue la misma trayectoria con un desfase, demostrando que el problema de los tres cuerpos puede contener islas estables y elegantes dentro de un panorama mucho más caótico.',
+  },
+  {
+    question: '¿Es este un simulador astronómico físicamente exacto?',
+    answer: 'Esta herramienta usa un modelo newtoniano suavizado y un paso tipo Verlet de velocidad simpléctico para que el movimiento sea fiel y estable para el aprendizaje. Está diseñada para exploración interactiva, no para predicción de alta precisión de efemérides.',
+  },
+  {
+    question: '¿Cómo debo interpretar la energía total?',
+    answer: 'La energía total negativa suele indicar un sistema ligado, mientras que una energía cercana a cero puede facilitar la fuga. En una simulación numérica, una deriva energética grande también advierte que el paso temporal o la geometría del encuentro están forzando al integrador.',
+  },
+];
+
+export const content: ToolLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    title,
+    kicker: 'Laboratorio de caos gravitacional',
+    canvasLabel: 'Lienzo interactivo bidimensional de órbita de tres cuerpos',
+    presetsLabel: 'Ajustes orbitales preestablecidos',
+    figureEightPreset: 'Figura en ocho',
+    lagrangePreset: 'Triángulo de Lagrange',
+    slingshotPreset: 'Honda gravitatoria',
+    pauseButton: 'Pausa',
+    playButton: 'Reproducir',
+    resetButton: 'Reiniciar',
+    speedLabel: 'Velocidad de simulación',
+    trailLabel: 'Longitud de estela',
+    massLabel: 'Masa',
+    velocityXLabel: 'Velocidad X',
+    velocityYLabel: 'Velocidad Y',
+    energyLabel: 'Energía total',
+    separationLabel: 'Rango de separación',
+    centerMassLabel: 'Centro de masas',
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Simulador interactivo del problema de los tres cuerpos para caos orbital',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'El problema de los tres cuerpos es una de las demostraciones más claras de que leyes simples pueden producir movimiento complicado. La gravedad newtoniana da una regla de fuerza compacta, pero en cuanto un tercer cuerpo masivo se une al sistema, cada órbita remodela continuamente a las otras dos. Este simulador te permite experimentar directamente con esa inestabilidad: elige una configuración conocida, ajusta masas y vectores de velocidad, y observa si los cuerpos forman una órbita repetitiva, un triángulo rotatorio o un evento de dispersión caótica.',
+    },
+    {
+      type: 'title',
+      text: 'Qué demuestran los ajustes preestablecidos',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Ajuste', 'Idea física', 'Qué observar'],
+      rows: [
+        ['<strong>Figura en ocho</strong>', 'Una solución periódica de masas iguales donde los tres cuerpos comparten el mismo bucle.', 'La órbita se mantiene organizada solo cuando la simetría y el equilibrio de velocidades se conservan cuidadosamente.'],
+        ['<strong>Triángulo de Lagrange</strong>', 'Tres cuerpos ocupan un triángulo equilátero que gira alrededor del centro de masas.', 'El equilibrio de masas y la velocidad tangencial evitan que el triángulo colapse hacia adentro.'],
+        ['<strong>Honda gravitatoria</strong>', 'Un encuentro cercano transfiere energía entre los cuerpos.', 'Un cuerpo puede ganar velocidad mientras otro se vuelve más ligado, revelando por qué ocurren las eyecciones caóticas.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Por qué los pequeños cambios importan',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'En una órbita de dos cuerpos, el centro de masas y la elipse orbital ofrecen una imagen geométrica estable. En un sistema de tres cuerpos, los pasos cercanos actúan como negociaciones gravitacionales: un cuerpo puede tomar prestada energía orbital, cambiar de dirección bruscamente o convertir un bucle ordenado en un evento de dispersión. Esa sensibilidad es la razón por la que los sistemas astrofísicos reales, como las estrellas triples, los encuentros planeta-luna y los planetesimales del sistema solar temprano, a menudo requieren integración numérica en lugar de una única fórmula simple.',
+    },
+    {
+      type: 'title',
+      text: 'Cómo usar los diagnósticos',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Energía total</strong> te ayuda a juzgar si el sistema está ligado y si la integración numérica se mantiene estable.',
+        '<strong>Rango de separación</strong> muestra las distancias de par más cercanas y más lejanas, haciendo fáciles de detectar las casi colisiones y las eyecciones.',
+        '<strong>Centro de masas</strong> debería permanecer relativamente estable cuando el momento inicial está equilibrado; la deriva sugiere una configuración intencionalmente asimétrica o un vector de velocidad alterado.',
+        '<strong>Longitud de estela</strong> revela la estructura a largo plazo: las estelas cortas enfatizan la interacción actual, mientras que las largas exponen bucles repetitivos y precesión orbital lenta.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Modelo numérico usado en la herramienta',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'El simulador usa la atracción newtoniana de cuadrado inverso con un pequeño término de suavizado que evita explosiones visuales durante pasos extremadamente cercanos. El movimiento avanza con un paso tipo Verlet de velocidad, una elección común para demostraciones orbitales porque maneja el comportamiento energético mejor que una simple actualización de Euler. El resultado es un modelo educativo receptivo que hace visible el comportamiento cualitativo del problema de los tres cuerpos sin pretender reemplazar el software profesional de mecánica celeste.',
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: title,
+      description,
+      applicationCategory: 'ScientificApplication',
+      operatingSystem: 'Any',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: faq.map((item) => ({
+        '@type': 'Question',
+        name: item.question,
+        acceptedAnswer: {
+          '@type': 'Answer',
+          text: item.answer,
+        },
+      })),
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: title,
+      step: howTo.map((step) => ({
+        '@type': 'HowToStep',
+        name: step.name,
+        text: step.text,
+      })),
+    },
+  ],
+};