@jjlmoya/utils-science 1.30.0 → 1.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-science",
-    "version": "1.30.0",
+    "version": "1.31.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -12,10 +12,11 @@ import { radioactiveDecay } from '../tool/radioactive-decay/index';
 import { naturalSelectionDrift } from '../tool/natural-selection-drift/index';
 import { entropySecondLaw } from '../tool/entropy-second-law/index';
 import { phaseDiagramCriticalPoints } from '../tool/phase-diagram-critical-points/index';
+import { twinParadoxVisualizer } from '../tool/twin-paradox-visualizer/index';
 
 export const scienceCategory: ScienceCategoryEntry = {
   icon: 'mdi:flask',
-  tools: [colonyCounter, asteroidImpact, microwaveDetector, simulationProbability, cellularRenewal, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, phaseDiagramCriticalPoints],
+  tools: [colonyCounter, asteroidImpact, microwaveDetector, simulationProbability, cellularRenewal, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, phaseDiagramCriticalPoints, twinParadoxVisualizer],
   i18n: {
     es: () => import('./i18n/es').then((m) => m.content),
     en: () => import('./i18n/en').then((m) => m.content),

package/src/entries.ts

@@ -12,6 +12,7 @@ export { radioactiveDecay } from './tool/radioactive-decay/entry';
 export { naturalSelectionDrift } from './tool/natural-selection-drift/entry';
 export { entropySecondLaw } from './tool/entropy-second-law/entry';
 export { phaseDiagramCriticalPoints } from './tool/phase-diagram-critical-points/entry';
+export { twinParadoxVisualizer } from './tool/twin-paradox-visualizer/entry';
 export { scienceCategory } from './category';
 import { asteroidImpact } from './tool/asteroid-impact/entry';
 import { cellularRenewal } from './tool/cellular-renewal/entry';
@@ -26,4 +27,5 @@ import { radioactiveDecay } from './tool/radioactive-decay/entry';
 import { naturalSelectionDrift } from './tool/natural-selection-drift/entry';
 import { entropySecondLaw } from './tool/entropy-second-law/entry';
 import { phaseDiagramCriticalPoints } from './tool/phase-diagram-critical-points/entry';
-export const ALL_ENTRIES = [asteroidImpact, cellularRenewal, colonyCounter, microwaveDetector, simulationProbability, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, phaseDiagramCriticalPoints];
+import { twinParadoxVisualizer } from './tool/twin-paradox-visualizer/entry';
+export const ALL_ENTRIES = [asteroidImpact, cellularRenewal, colonyCounter, microwaveDetector, simulationProbability, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, phaseDiagramCriticalPoints, twinParadoxVisualizer];

package/src/index.ts

@@ -13,6 +13,7 @@ export { RADIOACTIVE_DECAY_TOOL } from './tool/radioactive-decay/index';
 export { NATURAL_SELECTION_DRIFT_TOOL } from './tool/natural-selection-drift/index';
 export { ENTROPY_SECOND_LAW_TOOL } from './tool/entropy-second-law/index';
 export { PHASE_DIAGRAM_CRITICAL_POINTS_TOOL } from './tool/phase-diagram-critical-points/index';
+export { TWIN_PARADOX_VISUALIZER_TOOL } from './tool/twin-paradox-visualizer/index';
 
 export type {
   KnownLocale,

package/src/tests/locale_completeness.test.ts

@@ -18,7 +18,7 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('all 13 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(13);
+  it('all 14 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(14);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { scienceCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 13 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(13);
+    it('should have 14 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(14);
     });
 
     it('scienceCategory should be defined', () => {

package/src/tool/twin-paradox-visualizer/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { twinParadoxVisualizer } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await twinParadoxVisualizer.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/twin-paradox-visualizer/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Twin Paradox without One-Way Velocity Assumptions',
+    url: 'https://link.springer.com/article/10.1023/A:1018748702460',
+  },
+  {
+    name: 'Spacetime Physics: Introduction to Special Relativity',
+    url: 'https://ia800503.us.archive.org/22/items/SpacetimePhysicsIntroductionToSpecialRelativityTaylorWheelerPDF/Spacetime%20Physics%20-%20Introduction%20to%20Special%20Relativity%20%5BTaylor-Wheeler%5DPDF.pdf',
+  },
+];

package/src/tool/twin-paradox-visualizer/component.astro

@@ -0,0 +1,205 @@
+---
+import './twin-paradox-visualizer.css';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui } = Astro.props;
+---
+
+<div class="twin-lab" id="twin-lab" data-years-unit={ui.yearsUnit} data-years-short-unit={ui.yearsShortUnit}>
+  <section class="twin-viewport" aria-label={ui.visualTitle}>
+    <div class="twin-orbit">
+      <div class="twin-earth">
+        <span>{ui.earthTwin}</span>
+        <strong id="twin-earth-age">30.0</strong>
+      </div>
+      <div class="twin-path" aria-hidden="true">
+        <div class="twin-turnaround" id="twin-turnaround"></div>
+        <div class="twin-ship" id="twin-ship"></div>
+      </div>
+      <div class="twin-ship-clock">
+        <span>{ui.travelingTwin}</span>
+        <strong id="twin-ship-age">30.0</strong>
+      </div>
+    </div>
+    <svg class="twin-worldline" id="twin-worldline" viewBox="0 0 640 260" role="img" aria-label={ui.worldlineLabel}>
+      <g class="twin-lab-grid" id="twin-lab-grid" aria-hidden="true"></g>
+      <path class="twin-earth-line" d="M112 220 V38"></path>
+      <path class="twin-ship-line" id="twin-ship-line" d="M112 220 L350 74 L588 220"></path>
+      <circle class="twin-event" cx="112" cy="220" r="7"></circle>
+      <circle class="twin-event twin-event-return" id="twin-return-event" cx="588" cy="220" r="7"></circle>
+    </svg>
+  </section>
+
+  <section class="twin-console" aria-label={ui.controlsTitle}>
+    <div class="twin-presets">
+      <button type="button" data-velocity="0.50" data-years="12">{ui.presetCruise}</button>
+      <button type="button" data-velocity="0.86" data-years="20" class="active">{ui.presetRelativistic}</button>
+      <button type="button" data-velocity="0.98" data-years="40">{ui.presetExtreme}</button>
+    </div>
+
+    <label class="twin-field" for="twin-velocity">
+      <span>{ui.velocityLabel}</span>
+      <output id="twin-velocity-output">0.86c</output>
+      <input id="twin-velocity" type="range" min="0.05" max="0.99" value="0.86" step="0.01" />
+    </label>
+
+    <label class="twin-field" for="twin-years">
+      <span>{ui.earthYearsLabel}</span>
+      <output id="twin-years-output">20 {ui.yearsUnit}</output>
+      <input id="twin-years" type="range" min="2" max="80" value="20" step="1" />
+    </label>
+
+    <div class="twin-readout">
+      <div class="twin-reunion">
+        <span>{ui.ageGapLabel}</span>
+        <strong><span id="twin-age-gap-value">-</span><small>{ui.yearsShortUnit}</small></strong>
+      </div>
+      <div class="twin-results">
+        <div class="twin-metric">
+          <span>{ui.gammaLabel}</span>
+          <strong id="twin-gamma">-</strong>
+        </div>
+        <div class="twin-metric">
+          <span>{ui.shipTimeLabel}</span>
+          <strong id="twin-ship-time">-</strong>
+        </div>
+        <div class="twin-metric">
+          <span>{ui.distanceLabel}</span>
+          <strong id="twin-distance">-</strong>
+        </div>
+      </div>
+    </div>
+  </section>
+</div>
+
+<script>
+  import { calculateTwinParadox } from './logic';
+
+  const root = document.getElementById('twin-lab');
+  const velocityInput = document.getElementById('twin-velocity') as HTMLInputElement | null;
+  const yearsInput = document.getElementById('twin-years') as HTMLInputElement | null;
+  const velocityOutput = document.getElementById('twin-velocity-output');
+  const yearsOutput = document.getElementById('twin-years-output');
+  const earthAge = document.getElementById('twin-earth-age');
+  const shipAge = document.getElementById('twin-ship-age');
+  const ageGap = document.getElementById('twin-age-gap-value');
+  const gammaText = document.getElementById('twin-gamma');
+  const shipTime = document.getElementById('twin-ship-time');
+  const distanceText = document.getElementById('twin-distance');
+  const ship = document.getElementById('twin-ship');
+  const turnaround = document.getElementById('twin-turnaround');
+  const shipLine = document.getElementById('twin-ship-line');
+  const returnEvent = document.getElementById('twin-return-event');
+  const grid = document.getElementById('twin-lab-grid');
+  const worldline = document.getElementById('twin-worldline');
+  const presetButtons = document.querySelectorAll<HTMLButtonElement>('.twin-presets button');
+  const departureAge = 30;
+  const svgNamespace = 'http://www.w3.org/2000/svg';
+  const yearsUnit = root?.dataset.yearsUnit ?? '';
+  const yearsShortUnit = root?.dataset.yearsShortUnit ?? '';
+
+  function formatYears(value: number): string {
+    return value.toFixed(value >= 10 ? 1 : 2);
+  }
+
+  function setFill(input: HTMLInputElement) {
+    const min = Number(input.min);
+    const max = Number(input.max);
+    const value = Number(input.value);
+    const progress = ((value - min) / (max - min)) * 100;
+    input.style.setProperty('--fill', `${progress}%`);
+  }
+
+  function buildGrid() {
+    if (!grid) return;
+
+    for (let y = 44; y <= 220; y += 22) {
+      for (let x = 92; x <= 592; x += 28) {
+        const dot = document.createElementNS(svgNamespace, 'circle');
+        dot.setAttribute('cx', x.toString());
+        dot.setAttribute('cy', y.toString());
+        dot.setAttribute('r', ((x + y) % 3 === 0 ? 1.55 : 1.05).toString());
+        dot.dataset.x = x.toString();
+        dot.dataset.y = y.toString();
+        grid.append(dot);
+      }
+    }
+  }
+
+  function warpGrid(velocity: number, gamma: number) {
+    if (!grid || !worldline) return;
+
+    const contraction = 1 / gamma;
+    const skew = velocity * 0.32;
+    grid.querySelectorAll<SVGCircleElement>('circle').forEach((dot) => {
+      const rawX = Number(dot.dataset.x);
+      const rawY = Number(dot.dataset.y);
+      const centerX = 112;
+      const centerY = 220;
+      const dx = rawX - centerX;
+      const dy = rawY - centerY;
+      const warpedX = centerX + dx * (0.72 + contraction * 0.28) + dy * skew;
+      const warpedY = centerY + dy * (1.04 - velocity * 0.16);
+      dot.setAttribute('cx', warpedX.toFixed(2));
+      dot.setAttribute('cy', warpedY.toFixed(2));
+      dot.style.opacity = `${0.12 + velocity * 0.25}`;
+    });
+
+    worldline.style.setProperty('--grid-compression', contraction.toFixed(3));
+  }
+
+  function update() {
+    if (!velocityInput || !yearsInput) return;
+
+    const velocity = Number(velocityInput.value);
+    const earthYears = Number(yearsInput.value);
+    const result = calculateTwinParadox({ earthYears, velocityFractionC: velocity });
+    const shipProgress = Math.min(94, Math.max(8, 9 + velocity * 72));
+    const bendY = Math.max(52, 168 - velocity * 104);
+    const returnX = Math.min(598, 270 + earthYears * 4);
+
+    velocityOutput!.textContent = `${velocity.toFixed(2)}c`;
+    yearsOutput!.textContent = `${earthYears} ${yearsUnit}`;
+    earthAge!.textContent = (departureAge + earthYears).toFixed(1);
+    shipAge!.textContent = (departureAge + result.shipYears).toFixed(1);
+    ageGap!.textContent = formatYears(result.ageGapYears);
+    gammaText!.textContent = `${result.gamma.toFixed(3)}x`;
+    shipTime!.textContent = `${formatYears(result.shipYears)} ${yearsShortUnit}`;
+    distanceText!.textContent = `${result.earthDistanceLightYears.toFixed(1)} ly`;
+
+    ship?.style.setProperty('--ship-progress', `${shipProgress}%`);
+    ship?.style.setProperty('--clock-rate', `"${result.shipClockRatePercent.toFixed(1)}%"`);
+    turnaround?.style.setProperty('--turnaround-progress', `${shipProgress}%`);
+    shipLine?.setAttribute('d', `M112 220 L350 ${bendY.toFixed(1)} L${returnX.toFixed(1)} 220`);
+    returnEvent?.setAttribute('cx', returnX.toFixed(1));
+    warpGrid(velocity, result.gamma);
+    setFill(velocityInput);
+    setFill(yearsInput);
+  }
+
+  velocityInput?.addEventListener('input', () => {
+    presetButtons.forEach((button) => button.classList.remove('active'));
+    update();
+  });
+  yearsInput?.addEventListener('input', () => {
+    presetButtons.forEach((button) => button.classList.remove('active'));
+    update();
+  });
+
+  presetButtons.forEach((button) => {
+    button.addEventListener('click', () => {
+      if (!velocityInput || !yearsInput) return;
+      presetButtons.forEach((item) => item.classList.remove('active'));
+      button.classList.add('active');
+      velocityInput.value = button.dataset.velocity ?? velocityInput.value;
+      yearsInput.value = button.dataset.years ?? yearsInput.value;
+      update();
+    });
+  });
+
+  buildGrid();
+  update();
+</script>

package/src/tool/twin-paradox-visualizer/entry.ts

@@ -0,0 +1,26 @@
+import type { ScienceToolEntry } from '../../types';
+
+export const twinParadoxVisualizer: ScienceToolEntry = {
+  id: 'twin-paradox-visualizer',
+  icons: {
+    bg: 'mdi:clock-time-eight-outline',
+    fg: 'mdi:rocket-outline',
+  },
+  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/twin-paradox-visualizer/i18n/de.ts

@@ -0,0 +1,168 @@
+import { bibliography } from '../bibliography';
+import type { ToolLocaleContent } from '../../../types';
+
+const slug = 'zwillingsparadoxon-visualisierer';
+const title = 'Zwillingsparadoxon Visualisierer: Spezielle Relativitätstheorie Zeitdilatation';
+const description = 'Visualisieren Sie, wie die spezielle Relativitätstheorie einen schnell reisenden Zwilling jünger zurückkehren lässt als den Zwilling, der auf der Erde geblieben ist.';
+
+const howTo = [
+  {
+    name: 'Geschwindigkeit des Raumschiffs einstellen',
+    text: 'Nutzen Sie den Geschwindigkeitsregler, um einen Bruchteil der Lichtgeschwindigkeit zu wählen, und beobachten Sie, wie der Lorentzfaktor ansteigt.',
+  },
+  {
+    name: 'Missionsdauer im Erdsystem festlegen',
+    text: 'Stellen Sie ein, wie viele Jahre für den auf der Erde verbleibenden Zwilling während der gesamten Hin- und Rückreise vergehen.',
+  },
+  {
+    name: 'Uhren und Weltlinien vergleichen',
+    text: 'Lesen Sie den Altersunterschied, die vergangene Zeit im Raumschiff, die Entfernung im Erdsystem und die gekrümmte Weltlinie ab, die den Wechsel des Inertialsystems des reisenden Zwillings markiert.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Was ist das Zwillingsparadoxon in der speziellen Relativitätstheorie?',
+    answer: 'Das Zwillingsparadoxon ist ein Gedankenexperiment, bei dem ein Zwilling mit relativistischer Geschwindigkeit durch das Weltall reist und später jünger zur Erde zurückkehrt als der auf der Erde gebliebene Zwilling. Es erscheint paradox, weil zunächst jeder Zwilling den anderen als bewegt beschreiben kann, aber der reisende Zwilling beim Umkehren das Inertialsystem wechselt, sodass die beiden Pfade durch die Raumzeit nicht symmetrisch sind.',
+  },
+  {
+    question: 'Warum altert der reisende Zwilling weniger?',
+    answer: 'In der speziellen Relativitätstheorie hängt die vergangene Eigenzeit vom Pfad durch die Raumzeit ab. Eine Uhr, die sich mit Geschwindigkeit v relativ zu einem Inertialsystem bewegt, tickt um den Lorentzfaktor gamma langsamer. Der Reisende sammelt auf dem Hin- und Rückweg weniger Eigenzeit an als der auf der Erde gebliebene Zwilling.',
+  },
+  {
+    question: 'Verursacht die Beschleunigung den Altersunterschied?',
+    answer: 'Beschleunigung ist wichtig, da sie dem Reisenden ermöglicht, die Richtung umzukehren und zur Erde zurückzukehren, aber der Altersunterschied wird aus dem gesamten Raumzeitpfad berechnet, nicht allein aus der Beschleunigung. Selbst wenn die Umkehr sehr kurz wäre, würde der Reisepfad immer noch weniger Eigenzeit enthalten als der Pfad auf der Erde.',
+  },
+  {
+    question: 'Was bedeutet der Lorentzfaktor gamma?',
+    answer: 'Der Lorentzfaktor gamma ist gleich 1 geteilt durch die Quadratwurzel aus 1 minus v Quadrat durch c Quadrat. Er gibt an, wie stark sich Zeitintervalle, Längen und Energien zwischen Inertialsystemen unterscheiden. Bei alltäglichen Geschwindigkeiten ist gamma fast 1, nahe der Lichtgeschwindigkeit steigt er jedoch stark an.',
+  },
+  {
+    question: 'Kann dieser Effekt im wirklichen Leben gemessen werden?',
+    answer: 'Ja. Die Zeitdilatation wurde mit schnellen Teilchen, auf Flugzeugen mitgeführten Atomuhren, Satellitennavigationssystemen und Teilchenbeschleunigern gemessen. Das Zwillingsparadoxon verwendet eine extreme Reisegeschichte, aber der zugrunde liegende Uhreneffekt ist ein routinemäßig bestätigter Bestandteil der modernen Physik.',
+  },
+];
+
+export const content: ToolLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    visualTitle: 'Raumzeit-Visualisierung des Zwillingsparadoxons',
+    controlsTitle: 'Steuerung des Zwillingsparadoxons',
+    worldlineLabel: 'Weltliniendiagramm für den Erdzwilling und den reisenden Zwilling',
+    earthTwin: 'Alter des Erdzwillings',
+    travelingTwin: 'Alter des Reisenden',
+    presetCruise: 'Reiseflug',
+    presetRelativistic: 'Relativistisch',
+    presetExtreme: 'Extrem',
+    velocityLabel: 'Schiffsgeschwindigkeit',
+    earthYearsLabel: 'Vergangene Zeit auf der Erde',
+    ageGapLabel: 'Altersunterschied bei der Rückkehr',
+    gammaLabel: 'Lorentzfaktor',
+    shipTimeLabel: 'Eigenzeit des Reisenden',
+    distanceLabel: 'Entfernung bis zum Wendepunkt',
+    yearsUnit: 'Jahre',
+    yearsShortUnit: 'Jahre',
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Zwillingsparadoxon Rechner für die Spezielle Relativitätstheorie',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Zwillingsparadoxon Visualisierer verwandelt eine der berühmtesten Ideen der speziellen Relativitätstheorie in ein interaktives Raumzeitdiagramm. Stellen Sie eine Raumschiffgeschwindigkeit als Bruchteil der Lichtgeschwindigkeit ein, wählen Sie, wie viele Jahre auf der Erde vergehen, und der Rechner berechnet den Lorentzfaktor, die Eigenzeit des Reisenden, den Altersunterschied bei der Wiedervereinigung und die Entfernung bis zum Wendepunkt. Das visuelle Layout trennt die Erduhr von der Raumschiffuhr, sodass die Asymmetrie sichtbar wird, anstatt in Formeln versteckt zu sein.',
+    },
+    {
+      type: 'title',
+      text: 'Wie die Berechnung funktioniert',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die zentrale Größe ist der Lorentzfaktor: gamma = 1 / sqrt(1 - v^2 / c^2). Für eine einfache Hin- und Rückreise mit konstanter Reisegeschwindigkeit ist die vom Reisenden erlebte Zeit die Missionsdauer im Erdsystem geteilt durch gamma. Der Unterschied zwischen diesen beiden Dauern ist der Altersunterschied bei der Wiedervereinigung der Zwillinge. Das Tool zeigt auch die Entfernung im Erdsystem bis zum Wendepunkt an, die der Hälfte der gesamten Erdzeit multipliziert mit der Schiffsgeschwindigkeit in Lichtjahren pro Jahr entspricht.',
+    },
+    {
+      type: 'table',
+      headers: ['Geschwindigkeit', 'Lorentzfaktor', 'Taktrate des Reisenden', 'Physikalische Bedeutung'],
+      rows: [
+        ['0.50c', '1.155', '86.6% der Erdrate', 'Ein spürbarer, aber moderater relativistischer Effekt.'],
+        ['0.86c', '1.960', '51.0% der Erdrate', 'Der Reisende altert während des Reiseflugs etwa halb so schnell.'],
+        ['0.98c', '5.025', '19.9% der Erdrate', 'Extreme Zeitdilatation dominiert das Missionsergebnis.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum die Situation nicht symmetrisch ist',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Auf den ersten Blick kann jeder Zwilling sagen, der andere bewege sich, was das Ergebnis widersprüchlich erscheinen lässt. Die Auflösung ist, dass der Erdzwilling näherungsweise in einem Inertialsystem verbleibt, während der reisende Zwilling aufbricht, die Richtung umkehrt und zurückkehrt. Dieser Wechsel des Inertialsystems führt zu einem anderen Pfad durch die Raumzeit für den Reisenden. Die vom Tool gezeichnete Weltlinie knickt am Wendepunkt ab, während die Weltlinie des Erdzwillings gerade bleibt.',
+    },
+    {
+      type: 'title',
+      text: 'Das Weltliniendiagramm lesen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine Weltlinie ist eine Karte eines Objekts durch die Raumzeit und nicht nur durch den Raum. In diesem Visualisierer stellt die vertikale Erdinie den Zwilling dar, der zu Hause bleibt. Der abgewinkelte rote Pfad stellt den Reisenden dar, der die Erde verlässt und zurückkehrt. Höhere Geschwindigkeiten lassen den Reisepfad dramatischer abknicken und verringern die auf der Raumschiffuhr angesammelte Eigenzeit.',
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Altersunterschied:</strong> wie viel jünger der Reisende bei der Wiedervereinigung ist.',
+        '<strong>Lorentzfaktor:</strong> der Multiplikator, der die Zeit im Erdsystem mit der Eigenzeit des Reisenden verknüpft.',
+        '<strong>Eigenzeit des Reisenden:</strong> die tatsächlich vergangene Zeit, gemessen von einer Uhr an Bord des Raumschiffs.',
+        '<strong>Entfernung bis zum Wendepunkt:</strong> die Entfernung im Erdsystem, bevor der Reisende die Richtung umkehrt.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Praktische Beweise für die Zeitdilatation',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Zwillingsparadoxon ist ein klares Gedankenexperiment, aber die Zeitdilatation ist nicht spekulativ. Myonen, die in der oberen Atmosphäre entstehen, überleben lange genug, um den Boden zu erreichen, weil ihre bewegten Uhren aus Erdsicht dilatiert sind. Atomuhrexperimente in Flugzeugen und präzise Satellitennavigation erfordern ebenfalls relativistische Korrekturen. Dieselbe Mathematik, die hinter diesem Visualisierer steckt, ist Teil der Zeitmessinfrastruktur moderner GPS-Systeme.',
+    },
+  ],
+  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,
+      })),
+    },
+  ],
+};