Misc bugfix and improvements to probabilities storage

Author: diegochine

client/app.js

@@ -4,7 +4,7 @@ import Modal from './design-system/components/modal/modal.js';
 import { initializeHelpModal } from './src/shell/help.js';
 import { loadConfig } from './src/shell/config.js';
 import { createActivityLogger } from './src/shell/activity-logger.js';
-import { clamp, safeNumber } from './src/shared/math.js';
+import { clamp, safeNumber, roundToPercentages } from './src/shared/math.js';
 import { formatProbability } from './src/shared/format.js';
 import { buildDeviceDefinition } from './src/probability-lab/domain/devices.js';
 import simulateSingleTrials from './src/probability-lab/engine/simulate-single.js';
@@ -100,6 +100,15 @@ const sliderInstances = {
   },
 };
 
+// Store authoritative float probabilities as source of truth (keyed by deviceKey)
+const floatProbabilities = {
+  single: new Map(), // key: 'coin', 'die', etc. -> Array<number>
+  two: {
+    a: new Map(),
+    b: new Map(),
+  },
+};
+
 // Store speed slider instance
 let speedSlider = null;
 let settingsModal = null;
@@ -537,8 +546,15 @@ function renderOutcomeSliders(
   deviceKey,
   labels,
   probabilities,
-  onChange
+  onChange,
+  floatProbMap
 ) {
+  // Get or initialize authoritative float probabilities from persistent storage
+  if (!floatProbMap.has(deviceKey)) {
+    floatProbMap.set(deviceKey, [...probabilities]);
+  }
+  let currentFloatProbs = floatProbMap.get(deviceKey);
+
   // Check if sliders already exist for this device
   const existingKeys = [];
   for (const key of instanceMap.keys()) {
@@ -549,11 +565,15 @@ function renderOutcomeSliders(
 
   // If sliders exist, update their values instead of recreating
   if (existingKeys.length > 0) {
+    // Update source of truth from incoming probabilities
+    currentFloatProbs = [...probabilities];
+    floatProbMap.set(deviceKey, currentFloatProbs);
+    const percentages = roundToPercentages(currentFloatProbs);
     for (let i = 0; i < labels.length; i++) {
       const sliderKey = `${deviceKey}-${i}`;
       const slider = instanceMap.get(sliderKey);
-      if (slider) {
-        slider.setValue(Math.round(probabilities[i] * 100), null, false);
+      if (slider && i < percentages.length) {
+        slider.setValue(percentages[i], null, false);
       }
     }
     return;
@@ -563,6 +583,9 @@ function renderOutcomeSliders(
   container.innerHTML = '';
   container.classList.remove('pl-bias-options--custom');
 
+  // Calculate initial percentages using largest-remainder rounding
+  const initialPercentages = roundToPercentages(currentFloatProbs);
+
   for (let i = 0; i < labels.length; i++) {
     const sliderKey = `${deviceKey}-${i}`;
     const wrapper = document.createElement('div');
@@ -583,36 +606,35 @@ function renderOutcomeSliders(
       min: 0,
       max: 100,
       step: 1,
-      value: Math.round(probabilities[i] * 100),
+      value: initialPercentages[i],
       showInputs: true,
       onChange: (percentageValue) => {
         const probabilityValue = percentageValue / 100;
 
-        // Get current probabilities from all sliders
-        const currentProbabilities = [];
-        for (let j = 0; j < labels.length; j++) {
-          const otherKey = `${deviceKey}-${j}`;
-          const otherSlider = instanceMap.get(otherKey);
-          if (otherSlider) {
-            const otherValue = otherSlider.getValue();
-            currentProbabilities[j] = otherValue / 100;
-          } else {
-            currentProbabilities[j] = probabilities[j];
-          }
-        }
-
+        // Read other probabilities from authoritative float source (not from sliders)
+        const currentProbabilities = floatProbMap.get(deviceKey);
         const normalized = normalizeProbabilities(currentProbabilities, i, probabilityValue);
 
-        // Update all sliders with normalized values
+        // Convert to integer percentages using largest-remainder rounding
+        const percentages = roundToPercentages(normalized);
+
+        // Derive quantized float probabilities from the integer percentages
+        // This ensures 0% displayed = 0.0 stored = impossible in simulation
+        const quantized = percentages.map(p => p / 100);
+
+        // Update source of truth in persistent storage with quantized values
+        floatProbMap.set(deviceKey, quantized);
+
+        // Update all sliders with the integer percentages
         for (let j = 0; j < labels.length; j++) {
           const otherKey = `${deviceKey}-${j}`;
           const otherSlider = instanceMap.get(otherKey);
-          if (otherSlider) {
-            otherSlider.setValue(Math.round(normalized[j] * 100), null, false);
+          if (otherSlider && j < percentages.length) {
+            otherSlider.setValue(percentages[j], null, false);
           }
         }
 
-        onChange(normalized);
+        onChange(quantized);
       },
     });
 
@@ -621,16 +643,21 @@ function renderOutcomeSliders(
 }
 
 function renderBiasControls(container, device, values, onChange) {
-  // Determine which instance map to use based on container
+  // Determine which instance map and float prob map to use based on container
   let instanceMap;
+  let floatProbMap;
   if (container === els.biasOptions) {
     instanceMap = sliderInstances.single;
+    floatProbMap = floatProbabilities.single;
   } else if (container === els.biasOptionsA) {
     instanceMap = sliderInstances.two.a;
+    floatProbMap = floatProbabilities.two.a;
   } else if (container === els.biasOptionsB) {
     instanceMap = sliderInstances.two.b;
+    floatProbMap = floatProbabilities.two.b;
   } else {
     instanceMap = sliderInstances.single; // fallback
+    floatProbMap = floatProbabilities.single;
   }
 
   const deviceKey = device;
@@ -662,7 +689,8 @@ function renderBiasControls(container, device, values, onChange) {
       deviceKey,
       outcomes,
       probabilities,
-      (normalized) => onChange('customProbabilities', normalized)
+      (normalized) => onChange('customProbabilities', normalized),
+      floatProbMap
     );
     return;
   }
@@ -678,7 +706,8 @@ function renderBiasControls(container, device, values, onChange) {
       deviceKey,
       labels,
       probabilities,
-      (normalized) => onChange('coinProbabilities', normalized)
+      (normalized) => onChange('coinProbabilities', normalized),
+      floatProbMap
     );
     return;
   }
@@ -692,7 +721,8 @@ function renderBiasControls(container, device, values, onChange) {
       deviceKey,
       labels,
       probabilities,
-      (normalized) => onChange('dieProbabilities', normalized)
+      (normalized) => onChange('dieProbabilities', normalized),
+      floatProbMap
     );
     return;
   }

client/src/probability-lab/domain/devices.js

@@ -12,6 +12,23 @@ const DEVICE_META = {
 
 const MAX_CUSTOM_OUTCOMES = 50;
 
+/**
+ * Sanitizes and normalizes probability arrays.
+ * Ensures all values are non-negative and sum to 1.0.
+ *
+ * @param {Array<number>} probs - Array of probabilities to sanitize
+ * @param {Array<number>} fallback - Fallback array if probs is invalid
+ * @returns {Array<number>} Normalized probabilities summing to 1.0
+ */
+function sanitizeProbabilities(probs, fallback) {
+  const clamped = probs.map(p => Math.max(0, p));
+  const sum = clamped.reduce((a, p) => a + p, 0);
+  if (sum > 0) {
+    return clamped.map(p => p / sum);
+  }
+  return fallback;
+}
+
 function baseDefinition(kind, extra = {}) {
   const meta = DEVICE_META[kind] ?? {};
   return {
@@ -80,118 +97,14 @@ export function buildDeviceDefinition(config) {
   if (config.device === 'coin') {
     const labels = ['Heads', 'Tails'];
     let probabilities = config.coinProbabilities ?? [0.5, 0.5];
-
-    // Ensure all probabilities are clamped and normalized
-    // First, normalize the input probabilities
-    let sum = probabilities.reduce((acc, p) => acc + p, 0);
-    if (sum <= 0) {
-      probabilities = [0.5, 0.5];
-      return baseDefinition('coin', { labels, probabilities, cdf: buildCdf(probabilities) });
-    }
-
-    let normalized = probabilities.map((p) => p / sum);
-
-    // Clamp values that are out of bounds and redistribute excess
-    let clamped = normalized.map((p) => clamp(p, 0.01, 0.99));
-    let clampedSum = clamped.reduce((acc, p) => acc + p, 0);
-
-    // If clamping reduced the sum, redistribute the difference proportionally
-    if (clampedSum < 1.0) {
-      const excess = 1.0 - clampedSum;
-      // Find values that can accept more probability (those below 0.99)
-      const canAcceptMore = clamped.map((p, i) => p < 0.99 ? i : -1).filter(i => i >= 0);
-      if (canAcceptMore.length > 0) {
-        // Distribute excess proportionally among values that can accept more
-        const weights = canAcceptMore.map(i => clamped[i]);
-        const weightSum = weights.reduce((acc, w) => acc + w, 0);
-        if (weightSum > 0) {
-          canAcceptMore.forEach((idx, i) => {
-            clamped[idx] = Math.min(0.99, clamped[idx] + (weights[i] / weightSum) * excess);
-          });
-        } else {
-          // Equal distribution if weights are zero
-          const perValue = excess / canAcceptMore.length;
-          canAcceptMore.forEach(idx => {
-            clamped[idx] = Math.min(0.99, clamped[idx] + perValue);
-          });
-        }
-      }
-    }
-
-    // Final normalization to ensure sum is exactly 1.0
-    clampedSum = clamped.reduce((acc, p) => acc + p, 0);
-    if (clampedSum > 0) {
-      probabilities = clamped.map((p) => p / clampedSum);
-      // Final clamp check (shouldn't be needed, but safety check)
-      probabilities = probabilities.map((p) => clamp(p, 0.01, 0.99));
-      const finalSum = probabilities.reduce((acc, p) => acc + p, 0);
-      if (finalSum > 0) {
-        probabilities = probabilities.map((p) => p / finalSum);
-      }
-    } else {
-      probabilities = [0.5, 0.5];
-    }
-
+    probabilities = sanitizeProbabilities(probabilities, [0.5, 0.5]);
     return baseDefinition('coin', { labels, probabilities, cdf: buildCdf(probabilities) });
   }
 
   if (config.device === 'die') {
     const labels = ['1', '2', '3', '4', '5', '6'];
-    let probabilities;
-
-    probabilities = config.dieProbabilities ?? [1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6];
-
-    // Ensure all probabilities are clamped and normalized
-    // First, normalize the input probabilities
-    let sum = probabilities.reduce((acc, p) => acc + p, 0);
-    if (sum <= 0) {
-      probabilities = [1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6];
-      return baseDefinition('die', { labels, probabilities, cdf: buildCdf(probabilities) });
-    }
-
-    let normalized = probabilities.map((p) => p / sum);
-
-    // Clamp values that are out of bounds and redistribute excess
-    let clamped = normalized.map((p) => clamp(p, 0.01, 0.8));
-    let clampedSum = clamped.reduce((acc, p) => acc + p, 0);
-
-    // If clamping reduced the sum, redistribute the difference proportionally
-    if (clampedSum < 1.0) {
-      const excess = 1.0 - clampedSum;
-      // Find values that can accept more probability (those below 0.8)
-      const canAcceptMore = clamped.map((p, i) => p < 0.8 ? i : -1).filter(i => i >= 0);
-      if (canAcceptMore.length > 0) {
-        // Distribute excess proportionally among values that can accept more
-        const weights = canAcceptMore.map(i => clamped[i]);
-        const weightSum = weights.reduce((acc, w) => acc + w, 0);
-        if (weightSum > 0) {
-          canAcceptMore.forEach((idx, i) => {
-            clamped[idx] = Math.min(0.8, clamped[idx] + (weights[i] / weightSum) * excess);
-          });
-        } else {
-          // Equal distribution if weights are zero
-          const perValue = excess / canAcceptMore.length;
-          canAcceptMore.forEach(idx => {
-            clamped[idx] = Math.min(0.8, clamped[idx] + perValue);
-          });
-        }
-      }
-    }
-
-    // Final normalization to ensure sum is exactly 1.0
-    clampedSum = clamped.reduce((acc, p) => acc + p, 0);
-    if (clampedSum > 0) {
-      probabilities = clamped.map((p) => p / clampedSum);
-      // Final clamp check (shouldn't be needed, but safety check)
-      probabilities = probabilities.map((p) => clamp(p, 0.01, 0.8));
-      const finalSum = probabilities.reduce((acc, p) => acc + p, 0);
-      if (finalSum > 0) {
-        probabilities = probabilities.map((p) => p / finalSum);
-      }
-    } else {
-      probabilities = [1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6];
-    }
-
+    let probabilities = config.dieProbabilities ?? [1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6];
+    probabilities = sanitizeProbabilities(probabilities, [1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6]);
     return baseDefinition('die', { labels, probabilities, cdf: buildCdf(probabilities) });
   }
 

client/src/shared/math.js

@@ -11,3 +11,45 @@ export function safeNumber(value, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+/**
+ * Converts float probabilities to integer percentages using largest-remainder rounding.
+ * Guarantees the result sums to exactly 100.
+ *
+ * @param {Array<number>} probabilities - Array of float probabilities (should sum to 1.0)
+ * @returns {Array<number>} Array of integers (0-100) that sum to exactly 100
+ */
+export function roundToPercentages(probabilities) {
+  if (!Array.isArray(probabilities) || probabilities.length === 0) {
+    return [];
+  }
+
+  // Step 1: Floor each probability × 100 to get integer parts
+  const floors = probabilities.map(p => Math.floor(p * 100));
+  const floorSum = floors.reduce((sum, f) => sum + f, 0);
+
+  // Step 2: Calculate shortfall
+  const shortfall = 100 - floorSum;
+
+  if (shortfall <= 0) {
+    // Already at or above 100, return floors (shouldn't happen with valid probabilities)
+    return floors;
+  }
+
+  // Step 3: Calculate fractional remainders and create index-remainder pairs
+  const remainders = probabilities.map((p, i) => ({
+    index: i,
+    remainder: (p * 100) - floors[i],
+  }));
+
+  // Step 4: Sort by remainder (descending)
+  remainders.sort((a, b) => b.remainder - a.remainder);
+
+  // Step 5: Distribute shortfall one point at a time to largest remainders
+  const result = [...floors];
+  for (let i = 0; i < shortfall && i < remainders.length; i++) {
+    result[remainders[i].index]++;
+  }
+
+  return result;
+}
+