mumo-engine 1.0.0__py3-none-any.whl

mumo_engine-1.0.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: mumo-engine
+Version: 1.0.0
+Summary: Boundary-based statistics and risk-corridor calculations
+Author: Mumo Framework Authors
+License-Expression: MIT
+Keywords: statistics,risk,boundaries,mumo
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+================================================================================
+MUMO MATHEMATICAL FRAMEWORK ENGINE (mumo-engine)
+================================================================================
+Version: 1.0.0
+Author: Mumo Framework Authors
+License: MIT (LICENSE)
+
+--------------------------------------------------------------------------------
+1. EXECUTIVE SUMMARY & LIBRARY PURPOSE
+--------------------------------------------------------------------------------
+The Mumo Framework (`mumo-engine`) is an advanced mathematical computing 
+library designed to replace legacy statistical metrics (such as standard 
+deviation, raw arithmetic means, and isolated medians) with dynamic risk-corridor 
+tracking, extreme boundary isolation, consensus core squeezing, autotuned parameter 
+self-calibration, and multi-dimensional tensor risk modeling.
+
+Traditional statistical tools suffer from critical real-world limitations:
+- Standard deviation produces abstract squared variance units rather than 
+  unit-accurate risk limits.
+- Single outliers or sensor typos skew basic mean calculations.
+- Single-point medians flip wildly in large streaming data.
+- Manual tuning parameters introduce human operator bias.
+
+The Mumo Engine solves these problems by establishing boundary envelopes, dynamic 
+consensus squeezing, calculus-based derivative velocity tracking, and automated 
+parameter self-calibration across massive datasets and GPU-accelerated matrices.
+
+
+--------------------------------------------------------------------------------
+2. PIPELINE ARCHITECTURE DIAGRAM
+--------------------------------------------------------------------------------
+
+                        [ THE TOTAL SC-PGMF PIPELINE ]
+                                      |
+         +----------------------------+----------------------------+
+         |                            |                            |
+         v                            v                            v
+[ Boundary Modules ]         [ Core Stabilisers ]        [ Calculus Tensors ]
+* P-MPU (Ceiling Limit)      * P-GMCSI (True Baseline)   * Derivatives (Velocity)
+* P-MPD (Safety Floor)       * P-MBTS (Tension Weight)   * Integrals (Total Strain)
+* MBV (Risk Corridor)        * MAEI (Master Engines)     * Matrices (Multi-Scale)
+
+
+--------------------------------------------------------------------------------
+3. COMPLETE FORMULA BREAKDOWN: FUNCTIONS, SYMBOLS & GAPS FILLED
+--------------------------------------------------------------------------------
+
+[SECTION A: FOUNDATIONAL MUMO MODEL (Small Sample Sizes: n, k = 1)]
+
+1. Mumo Potential Upside (MPU)
+   * Formula: MPU = ( x_n + (sum(x_i for i=1 to n-1) / (n-1)) ) / 2
+   * Symbol Definitions:
+       - x_n : The single maximum value in the sorted dataset X.
+       - x_i : Individual baseline entries in the sorted dataset.
+       - n   : Total number of data points.
+   * Function: Evaluates maximum peak performance capability relative to baseline.
+   * Gap Filled: Replaces raw maximum values (which are highly vulnerable to 
+     single data entry errors or noise spikes) with a baseline-anchored peak limit.
+
+2. Mumo Potential Downside (MPD)
+   * Formula: MPD = ( x_1 + (sum(x_i for i=2 to n) / (n-1)) ) / 2
+   * Symbol Definitions:
+       - x_1 : The single minimum value in the sorted dataset X.
+       - x_i : Individual baseline entries in the upper dataset.
+       - n   : Total number of data points.
+   * Function: Evaluates system risk floor safety relative to the remaining baseline.
+   * Gap Filled: Eliminates raw minimum metrics by evaluating worst-case failure 
+     risk in proportion to baseline health.
+
+3. Mumo Average (MA)
+   * Formula: MA = ( MPU + MPD ) / 2
+   * Function: Establishes the central equilibrium point between MPU and MPD.
+   * Gap Filled: Provides an unwarped balance point for small sample counts.
+
+
+[SECTION B: GENERALIZED & PARAMETRIC BOUNDARY MODULES (Big Data & Slice k)]
+
+4. Parametric Mumo Potential Upside (P-MPU)
+   * Formula: P-MPU = alpha * (sum(top k) / k) + (1 - alpha) * (sum(remaining) / (n - k))
+   * Symbol Definitions:
+       - k     : Boundary slice size (number of top/bottom boundary elements).
+       - alpha : Weighting slider controlling boundary sensitivity (0 <= alpha <= 1).
+       - n     : Total size of the data array.
+   * Function: Calculates continuous upper performance capacity across massive data streams.
+   * Gap Filled: Prevents single data typos or corrupted streaming telemetry from 
+     warping performance capacity estimates.
+
+5. Parametric Mumo Potential Downside (P-MPD)
+   * Formula: P-MPD = alpha * (sum(bottom k) / k) + (1 - alpha) * (sum(remaining) / (n - k))
+   * Function: Establishes a flexible operational safety floor across large database streams.
+   * Gap Filled: Stops transient system glitches from triggering false automated 
+     emergency shutdown routines.
+
+6. Parametric Generalized Mumo Average (P-GMA)
+   * Formula: P-GMA = beta * (P-MPU) + (1 - beta) * (P-MPD)
+   * Symbol Definitions:
+       - beta : Risk-reward balance parameter slider (0 <= beta <= 1).
+   * Function: Blends peak upside boundaries and risk floors according to operational goals.
+   * Gap Filled: Enables real-time tuning of automated trading bots or server network 
+     throttling based on target risk tolerance.
+
+7. Mumo Bounds of Variance (MBV)
+   * Formula: MBV = P-MPU - P-MPD
+   * Function: Measures the physical width of the operational risk corridor.
+   * Gap Filled: Replaces statistical standard deviation (which yields abstract 
+     squared units) with a unit-accurate physical range measurement matching the input data.
+
+
+[SECTION C: CORE STABILISERS]
+
+8. Parametric Generalized Mumo Core-Squeeze Index (P-GMCSI)
+   * Formula: P-GMCSI = alpha * (sum(Core Cluster C_k) / k) + (1 - alpha) * (sum(Remaining Mass) / (n - k))
+   * Symbol Definitions:
+       - C_k : The contiguous central k-value slice of the sorted dataset.
+       - R_{n-k} : Every value outside C_k; this set contains n-k values.
+       - Slice position: start at index floor((n-k)/2) in the sorted dataset.
+   * Function: Squeezes middle elements to produce an uncorrupted central consensus value.
+   * Gap Filled: Eliminates median flipping in large datasets while preserving full 
+     consensus awareness of outer wing mass.
+
+   For dynamic fractional sizing, set k = max(1, floor(p*n)) (capped at n-1)
+   using autotune_parameters(data, fraction=p).k. This is the framework's
+   fractional-size mode (equivalent to delta=1); omitting it leaves k under
+   caller control (equivalent to delta=0). The calculation functions
+   themselves remain deterministic and accept k as an ordinary parameter.
+   When using k for P-MBTS, MAEI, or MCHI as well, choose p < 0.5 so
+   2*k < n and P-MBTS has at least one value remaining between its two
+   boundary slices.
+
+9. Mumo Adaptive Equilibrium Index (MAEI)
+   * Formula: MAEI = gamma * (P-GMA) + (1 - gamma) * (P-GMCSI)
+   * Symbol Definitions:
+       - gamma : Balance switch between outer threat boundary tracking and inner core stability.
+   * Function: Master Engine unifying boundary limits and core consensus into one metric.
+   * Gap Filled: Provides hardware engines with dynamic mathematical survival instincts.
+
+
+[SECTION D: AUTOTUNE ZERO-BIAS ENGINE (SC-PGMF)]
+
+10. Autotune Self-Calibration (SC-MPU, SC-MPD, SC-GMA, SC-GMCSI, SC-MAEI)
+    * Formulas:
+        k_auto     = floor(p * n)
+        alpha_auto = (x_n - x_1) / mean(x)
+        beta_auto  = (x_n - mean(x)) / MBV_baseline
+    * Symbol Definitions:
+        - p : Target fractional boundary depth (e.g., 0.05 for 5%).
+        - delta, omega : Mode switches (0 = manual, 1 = fully automated autotune).
+    * Function: Auto-derives k, alpha, and beta parameters straight from data volume and variance.
+    * Gap Filled: Erases human parameter bias and eliminates manual recalibration during sudden market spikes.
+
+
+[SECTION E: CALCULUS TENSORS & MULTI-DIMENSIONAL EXTENSIONS]
+
+11. Risk Derivatives (Velocity & Acceleration)
+    * Formulas:
+        Velocity     = d(MBV)/dt = d(P-MPU)/dt - d(P-MPD)/dt
+        Acceleration = d^2(MBV)/dt^2
+    * Function: Tracks the rate of expansion and acceleration of system risk corridors over time vectors.
+    * Gap Filled: Predicts market crashes or hardware failures before safety floors break by detecting positive acceleration.
+
+12. Cumulative Risk Mass Integration (Total Exposure Volume)
+    * Formula: Total Exposure Volume = integral_a^b ( P-MPD(t) - f(t) ) dt
+    * Symbol Definitions:
+        - f(t) : Continuous metric spot curve over time t from a to b.
+    * Function: Integrates continuous structural strain volume over time windows.
+    * Gap Filled: Quantifies cumulative physical fatigue or financial drawdown duration rather than static point snapshots.
+
+13. Multi-Dimensional Risk Matrix (Tensor Surface Transformation)
+    * Formula: Y = Omega * X
+    * Symbol Definitions:
+        - X     : High-dimensional data matrix of multi-asset streams.
+        - Omega : Automated parameter state matrix.
+    * Function: Executes multi-asset risk surface calculations simultaneously.
+    * Gap Filled: Enables GPU hardware to compute thousands of asset risk metrics in a single clock cycle.
+
+
+--------------------------------------------------------------------------------
+4. INSTALLATION & QUICKSTART
+--------------------------------------------------------------------------------
+Install via PyPI:
+    pip install mumo-engine
+
+Python Example:
+    from mumo_framework import MumoEngine
+
+    data = [12.0, 15.2, 11.8, 45.0, 14.1, 13.9, 10.5]
+
+    # Calculate Ceiling, Safety Floor, and Risk Corridor Width
+    p_mpu = MumoEngine.calculate_p_mpu(data, k=2, alpha=0.7)
+    p_mpd = MumoEngine.calculate_p_mpd(data, k=2, alpha=0.7)
+    mbv   = MumoEngine.calculate_mbv(data, k=2, alpha=0.7)
+
+    print(f"Performance Ceiling (P-MPU): {p_mpu:.2f}")
+    print(f"Safety Floor (P-MPD):        {p_mpd:.2f}")
+    print(f"Risk Corridor Width (MBV):   {mbv:.2f}")
+
+Fractional core/boundary sizing:
+    params = MumoEngine.autotune_parameters(data, fraction=0.10)
+    p_gmcsi = MumoEngine.calculate_p_gmcsi(data, k=params.k, alpha=0.7)
+
+For combined P-MBTS, MAEI, or MCHI calculations, use a fraction below 0.5
+and a dataset of at least three values so the returned k satisfies 2*k < n.
+
+Interactive calculator:
+    python -m mumo_framework
+
+The calculator accepts numbers separated by commas or spaces over as many
+input lines as needed. Submit a blank line to finish the dataset, then enter
+k, alpha, beta, and gamma. Its dataset size is limited by available memory.
+P-MBTS uses the mean of the values remaining after removing the lowest k and
+highest k entries as mu_rest_core; therefore, it requires 2*k < n.
+
+Interactive desktop calculator:
+    mumo-framework-gui
+
+Or, when running from the source checkout:
+    python -m mumo_gui
+
+The desktop calculator lets you edit or paste a dataset and interactively adjust
+k, alpha, beta, and gamma. Results update as the data or parameters change.
+It uses Python's built-in Tkinter interface and adds no third-party dependencies.
+
+
+--------------------------------------------------------------------------------
+5. LICENSE
+--------------------------------------------------------------------------------
+This project is licensed under the MIT License. See the accompanying LICENSE
+file for full terms.
+
+Based on the original Mumo Mathematical Framework created by Mumo Framework Authors (Root Project).

mumo_engine-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mumo_framework.py,sha256=5Ic9wNniA8umITis_s0irgOOY2crl0gXMx-SWtTJlp4,19589
+mumo_gui.py,sha256=Lc19gUEQ6Y0Od7fE6XLVJ0yCGkAZSDaMqcmHAfg8Nhw,12938
+mumo_engine-1.0.0.dist-info/licenses/LICENSE,sha256=U98_Lr-sm-XQxYvF_87awv4rBBnbTQLROaUFmOmQ-OA,1079
+mumo_engine-1.0.0.dist-info/METADATA,sha256=MScomEZKyWZNhSnUPQjkcXFuDyGTMeE-Iwc7J6XmFC0,12111
+mumo_engine-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mumo_engine-1.0.0.dist-info/entry_points.txt,sha256=HxnKiwgwGLTM7HOf_LmoEZQu-n5vUkQzDBkreke5xvU,90
+mumo_engine-1.0.0.dist-info/top_level.txt,sha256=kYMn7AUPAdA9TtL6p7zCLtuSmmOspilP-lG1TcTjehw,24
+mumo_engine-1.0.0.dist-info/RECORD,,

mumo_engine-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mumo_engine-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mumo-framework = mumo_framework:main
+mumo-framework-gui = mumo_gui:main

mumo_engine-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mumo Framework Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mumo_engine-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+mumo_framework
+mumo_gui

mumo_framework.py

@@ -0,0 +1,545 @@
+"""Statistical boundary and risk-corridor calculations for the Mumo framework.
+
+Based on the original Mumo Mathematical Framework created by Mumo Framework Authors (Root Project).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+from typing import Iterable, List, Optional, Sequence, Tuple
+
+__version__ = "1.0.0"
+
+
+def _finite_float(value: object, name: str) -> float:
+    if isinstance(value, (bool, str, bytes)):
+        raise TypeError("{} must be a real number".format(name))
+    try:
+        result = float(value)
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise TypeError("{} must be a real number".format(name)) from exc
+    if not math.isfinite(result):
+        raise ValueError("{} must be finite".format(name))
+    return result
+
+
+def _ordered_data(data: Iterable[float]) -> List[float]:
+    if isinstance(data, (str, bytes)):
+        raise TypeError("data must be an iterable of numbers")
+    try:
+        iterator = iter(data)
+    except TypeError as exc:
+        raise TypeError("data must be an iterable of numbers") from exc
+    values = [_finite_float(value, "data value") for value in iterator]
+    if len(values) < 2:
+        raise ValueError("data must contain at least two values")
+    return sorted(values)
+
+
+def _positive_integer(value: int, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError("{} must be an integer".format(name))
+    if value <= 0:
+        raise ValueError("{} must be greater than zero".format(name))
+    return value
+
+
+def _slice_size(k: int, n: int) -> int:
+    value = _positive_integer(k, "k")
+    if value >= n:
+        raise ValueError("k must be smaller than the number of data values")
+    return value
+
+
+def _weight(value: float, name: str) -> float:
+    result = _finite_float(value, name)
+    if not 0.0 <= result <= 1.0:
+        raise ValueError("{} must be between 0 and 1".format(name))
+    return result
+
+
+def _mean(values: Sequence[float]) -> float:
+    return math.fsum(values) / len(values)
+
+
+def calculate_mpu(data: Iterable[float]) -> float:
+    """Return MPU: the average of the maximum and the remaining-data mean."""
+    values = _ordered_data(data)
+    return (values[-1] + _mean(values[:-1])) / 2.0
+
+
+def calculate_mpd(data: Iterable[float]) -> float:
+    """Return MPD: the average of the minimum and the remaining-data mean."""
+    values = _ordered_data(data)
+    return (values[0] + _mean(values[1:])) / 2.0
+
+
+def calculate_ma(data: Iterable[float]) -> float:
+    """Return the foundational Mumo average, (MPU + MPD) / 2."""
+    return (calculate_mpu(data) + calculate_mpd(data)) / 2.0
+
+
+def calculate_mbts(data: Iterable[float]) -> float:
+    """Return MBTS using the edge range and the mean of interior values."""
+    values = _ordered_data(data)
+    if len(values) < 3:
+        raise ValueError("MBTS requires at least three data values")
+    rest_mean = _mean(values[1:-1])
+    return ((values[-1] - values[0]) / 2.0 + rest_mean) / 2.0
+
+
+def calculate_mpu_k(data: Iterable[float], k: int) -> float:
+    """Return the unweighted generalized upside metric for the top k values."""
+    values = _ordered_data(data)
+    size = _slice_size(k, len(values))
+    return (_mean(values[-size:]) + _mean(values[:-size])) / 2.0
+
+
+def calculate_mpd_k(data: Iterable[float], k: int) -> float:
+    """Return the unweighted generalized downside metric for the bottom k."""
+    values = _ordered_data(data)
+    size = _slice_size(k, len(values))
+    return (_mean(values[:size]) + _mean(values[size:])) / 2.0
+
+
+def calculate_gma_k(data: Iterable[float], k: int) -> float:
+    """Return GMA for a boundary slice of size k."""
+    return (calculate_mpu_k(data, k) + calculate_mpd_k(data, k)) / 2.0
+
+
+def calculate_p_mpu(data: Iterable[float], k: int, alpha: float = 0.5) -> float:
+    """Return parametric upside, weighting the top-k slice by alpha."""
+    values = _ordered_data(data)
+    size = _slice_size(k, len(values))
+    weight = _weight(alpha, "alpha")
+    return weight * _mean(values[-size:]) + (1.0 - weight) * _mean(values[:-size])
+
+
+def calculate_p_mpd(data: Iterable[float], k: int, alpha: float = 0.5) -> float:
+    """Return parametric downside, weighting the bottom-k slice by alpha."""
+    values = _ordered_data(data)
+    size = _slice_size(k, len(values))
+    weight = _weight(alpha, "alpha")
+    return weight * _mean(values[:size]) + (1.0 - weight) * _mean(values[size:])
+
+
+def calculate_p_gma(
+    data: Iterable[float],
+    k: int,
+    alpha: float = 0.5,
+    beta: float = 0.5,
+) -> float:
+    """Blend parametric upside and downside using beta."""
+    balance = _weight(beta, "beta")
+    upside = calculate_p_mpu(data, k, alpha)
+    downside = calculate_p_mpd(data, k, alpha)
+    return balance * upside + (1.0 - balance) * downside
+
+
+def calculate_mbv(data: Iterable[float], k: int, alpha: float = 0.5) -> float:
+    """Return MBV, the unit-preserving width between parametric boundaries."""
+    return calculate_p_mpu(data, k, alpha) - calculate_p_mpd(data, k, alpha)
+
+
+def calculate_p_mbts(
+    data: Iterable[float], k: int, alpha: float = 0.5
+) -> float:
+    """Return parametric MBTS using edge slices and the remaining-data mean.
+
+    The supplied formula's ``mu_rest_core`` is interpreted as the mean of
+    values left after removing the bottom-k and top-k boundary slices.
+    """
+    values = _ordered_data(data)
+    size = _slice_size(k, len(values))
+    if 2 * size >= len(values):
+        raise ValueError("P-MBTS requires at least one value outside both k-slices")
+    weight = _weight(alpha, "alpha")
+    upper_mean = _mean(values[-size:])
+    lower_mean = _mean(values[:size])
+    rest_core_mean = _mean(values[size:-size])
+    return ((upper_mean - lower_mean) / 2.0 + weight * rest_core_mean) / 2.0
+
+
+def calculate_p_gmcsi(
+    data: Iterable[float], k: int, alpha: float = 0.5
+) -> float:
+    """Return P-GMCSI using the centered k-value core cluster.
+
+    Values are sorted first. The core is the contiguous slice starting at
+    ``floor((n - k) / 2)``; the remainder contains every value outside it.
+    For fractional sizing, obtain ``k`` from
+    ``autotune_parameters(data, fraction=p).k``.
+    """
+    values = _ordered_data(data)
+    size = _slice_size(k, len(values))
+    weight = _weight(alpha, "alpha")
+    start = (len(values) - size) // 2
+    core = values[start : start + size]
+    remainder = values[:start] + values[start + size :]
+    return weight * _mean(core) + (1.0 - weight) * _mean(remainder)
+
+
+def calculate_maei(
+    data: Iterable[float],
+    k: int,
+    alpha: float = 0.5,
+    beta: float = 0.5,
+    gamma: float = 0.5,
+) -> float:
+    """Blend the generalized average and core-squeeze index using gamma."""
+    balance = _weight(gamma, "gamma")
+    generalized = calculate_p_gma(data, k, alpha, beta)
+    core = calculate_p_gmcsi(data, k, alpha)
+    return balance * generalized + (1.0 - balance) * core
+
+
+def calculate_mchi(
+    data: Iterable[float],
+    k: int,
+    alpha: float = 0.5,
+    gamma: float = 0.5,
+) -> float:
+    """Blend parametric MBTS and the core-squeeze index using gamma."""
+    balance = _weight(gamma, "gamma")
+    tension = calculate_p_mbts(data, k, alpha)
+    core = calculate_p_gmcsi(data, k, alpha)
+    return balance * tension + (1.0 - balance) * core
+
+
+@dataclass(frozen=True)
+class MumoParameters:
+    """Autotuned parameters for a dataset."""
+
+    k: int
+    alpha: float
+    beta: float
+    gamma: float = 0.5
+
+
+def autotune_parameters(
+    data: Iterable[float],
+    fraction: float = 0.05,
+    mbv_baseline: Optional[float] = None,
+    gamma: float = 0.5,
+) -> MumoParameters:
+    """Derive bounded k, alpha, and beta values from a dataset.
+
+    The boundary/core size is ``floor(fraction * n)``, clamped to
+    ``[1, n - 1]`` so both the selected slice and its remainder are nonempty.
+    The specification's alpha and beta ratios are clamped to [0, 1]. If no
+    MBV baseline is supplied, the observed data range is used. Constant data
+    receives neutral alpha/beta settings where the corresponding ratio is
+    undefined.
+
+    When the returned ``k`` will also be used for P-MBTS, MAEI, or MCHI, it
+    must additionally satisfy ``2 * k < n``; choose a fraction below 0.5
+    for the usual fractional-sizing workflow.
+    """
+    values = _ordered_data(data)
+    proportion = _finite_float(fraction, "fraction")
+    if not 0.0 < proportion <= 1.0:
+        raise ValueError("fraction must be greater than 0 and at most 1")
+    balance = _weight(gamma, "gamma")
+
+    size = min(len(values) - 1, max(1, math.floor(proportion * len(values))))
+    span = values[-1] - values[0]
+    average = _mean(values)
+    if span == 0.0:
+        alpha = 0.0
+    elif average == 0.0:
+        alpha = 1.0
+    else:
+        alpha = min(1.0, max(0.0, span / abs(average)))
+
+    baseline = span if mbv_baseline is None else _finite_float(
+        mbv_baseline, "mbv_baseline"
+    )
+    if baseline < 0.0:
+        raise ValueError("mbv_baseline must not be negative")
+    if baseline == 0.0:
+        if span != 0.0:
+            raise ValueError("mbv_baseline must be non-zero for non-constant data")
+        beta = 0.5
+    else:
+        beta = min(1.0, max(0.0, (values[-1] - average) / baseline))
+    return MumoParameters(k=size, alpha=alpha, beta=beta, gamma=balance)
+
+
+def _time_values(times: Optional[Sequence[float]], count: int) -> List[float]:
+    if times is None:
+        return [float(index) for index in range(count)]
+    if len(times) != count:
+        raise ValueError("times and values must have the same length")
+    result = [_finite_float(value, "time") for value in times]
+    if any(right <= left for left, right in zip(result, result[1:])):
+        raise ValueError("times must be strictly increasing")
+    return result
+
+
+def risk_velocity(
+    mbv_values: Iterable[float], times: Optional[Sequence[float]] = None
+) -> List[float]:
+    """Return interval risk velocities (first differences of MBV over time)."""
+    values = [_finite_float(value, "MBV value") for value in mbv_values]
+    if len(values) < 2:
+        raise ValueError("at least two MBV values are required")
+    time_values = _time_values(times, len(values))
+    return [
+        (right_value - left_value) / (right_time - left_time)
+        for left_value, right_value, left_time, right_time in zip(
+            values, values[1:], time_values, time_values[1:]
+        )
+    ]
+
+
+def risk_acceleration(
+    mbv_values: Iterable[float], times: Optional[Sequence[float]] = None
+) -> List[float]:
+    """Return acceleration estimates between adjacent risk-velocity intervals."""
+    values = [_finite_float(value, "MBV value") for value in mbv_values]
+    if len(values) < 3:
+        raise ValueError("at least three MBV values are required")
+    time_values = _time_values(times, len(values))
+    velocity = risk_velocity(values, time_values)
+    midpoints = [
+        (left + right) / 2.0 for left, right in zip(time_values, time_values[1:])
+    ]
+    return [
+        (right_velocity - left_velocity) / (right_time - left_time)
+        for left_velocity, right_velocity, left_time, right_time in zip(
+            velocity, velocity[1:], midpoints, midpoints[1:]
+        )
+    ]
+
+
+def cumulative_exposure(
+    floor_values: Iterable[float],
+    observations: Iterable[float],
+    times: Optional[Sequence[float]] = None,
+) -> float:
+    """Integrate floor minus observed values with the trapezoidal rule."""
+    floors = [_finite_float(value, "floor value") for value in floor_values]
+    spots = [_finite_float(value, "observation") for value in observations]
+    if len(floors) != len(spots):
+        raise ValueError("floor_values and observations must have the same length")
+    if len(floors) < 2:
+        raise ValueError("at least two points are required for integration")
+    time_values = _time_values(times, len(floors))
+    gaps = [floor - spot for floor, spot in zip(floors, spots)]
+    return math.fsum(
+        (left_gap + right_gap) * (right_time - left_time) / 2.0
+        for left_gap, right_gap, left_time, right_time in zip(
+            gaps, gaps[1:], time_values, time_values[1:]
+        )
+    )
+
+
+def _matrix(values: Iterable[Iterable[float]], name: str) -> List[List[float]]:
+    if isinstance(values, (str, bytes)):
+        raise TypeError("{} must be a matrix".format(name))
+    try:
+        rows = [
+            [_finite_float(value, "{} value".format(name)) for value in row]
+            for row in values
+        ]
+    except TypeError as exc:
+        raise TypeError("{} must be a matrix of numbers".format(name)) from exc
+    if not rows or not rows[0]:
+        raise ValueError("{} must not be empty".format(name))
+    width = len(rows[0])
+    if any(len(row) != width for row in rows):
+        raise ValueError("{} must be rectangular".format(name))
+    return rows
+
+
+def boundary_matrix(
+    data: Iterable[Iterable[float]], k: int, alpha: float = 0.5
+) -> List[Tuple[float, float, float]]:
+    """Calculate (P-MPU, P-MPD, MBV) for each row in a dataset matrix."""
+    rows = _matrix(data, "data")
+    return [
+        (
+            calculate_p_mpu(row, k, alpha),
+            calculate_p_mpd(row, k, alpha),
+            calculate_mbv(row, k, alpha),
+        )
+        for row in rows
+    ]
+
+
+def matrix_multiply(
+    omega: Iterable[Iterable[float]], data: Iterable[Iterable[float]]
+) -> List[List[float]]:
+    """Multiply two compatible rectangular matrices (Y = Omega * X)."""
+    left = _matrix(omega, "omega")
+    right = _matrix(data, "data")
+    if len(left[0]) != len(right):
+        raise ValueError("omega columns must match data rows")
+    columns = list(zip(*right))
+    return [
+        [math.fsum(a * b for a, b in zip(row, column)) for column in columns]
+        for row in left
+    ]
+
+
+def _read_interactive_dataset() -> List[float]:
+    print("Enter numbers separated by spaces or commas; use multiple lines.")
+    print("Press Enter on a blank line when you have finished the dataset.")
+    values: List[float] = []
+    while True:
+        line = input("data> ").strip()
+        if not line:
+            break
+        try:
+            line_values = [
+                _finite_float(token, "data value")
+                for token in line.replace(",", " ").split()
+            ]
+        except (TypeError, ValueError) as exc:
+            print("Invalid data: {}. Please re-enter that line.".format(exc))
+            continue
+        values.extend(line_values)
+    return values
+
+
+def _read_interactive_float(prompt: str) -> float:
+    while True:
+        try:
+            return _finite_float(input(prompt).strip(), prompt.strip())
+        except (TypeError, ValueError) as exc:
+            print("Invalid number: {}. Please try again.".format(exc))
+
+
+def _read_interactive_int(prompt: str) -> int:
+    while True:
+        raw = input(prompt).strip()
+        try:
+            return int(raw)
+        except ValueError:
+            print("Please enter a whole number.")
+
+
+def _read_interactive_k(count: int) -> int:
+    maximum = (count - 1) // 2
+    while True:
+        value = _read_interactive_int(
+            "Boundary/core size k (1 to {}): ".format(maximum)
+        )
+        if 1 <= value <= maximum:
+            return value
+        print("For these formulas, k must be at least 1 and 2*k must be < n.")
+
+
+def _read_interactive_weight(name: str) -> float:
+    while True:
+        value = _read_interactive_float("{} (0 to 1): ".format(name))
+        try:
+            return _weight(value, name)
+        except ValueError as exc:
+            print("{} Please try again.".format(exc))
+
+
+def main() -> int:
+    """Run an interactive prompt for calculating Mumo formulas."""
+    print("Mumo Framework interactive calculator")
+    print("Enter as many data values as needed; available memory is the limit.")
+    try:
+        while True:
+            try:
+                data = _read_interactive_dataset()
+                values = _ordered_data(data)
+                k = _read_interactive_k(len(values))
+                alpha = _read_interactive_weight("alpha")
+                beta = _read_interactive_weight("beta")
+                gamma = _read_interactive_weight("gamma")
+
+                results = [
+                    ("MPU", calculate_mpu(values)),
+                    ("MPD", calculate_mpd(values)),
+                    ("MA", calculate_ma(values)),
+                    ("MBTS", calculate_mbts(values)),
+                    ("MPU-k", calculate_mpu_k(values, k)),
+                    ("MPD-k", calculate_mpd_k(values, k)),
+                    ("GMA-k", calculate_gma_k(values, k)),
+                    ("P-MPU", calculate_p_mpu(values, k, alpha)),
+                    ("P-MPD", calculate_p_mpd(values, k, alpha)),
+                    ("P-GMA", calculate_p_gma(values, k, alpha, beta)),
+                    ("MBV", calculate_mbv(values, k, alpha)),
+                    ("P-MBTS", calculate_p_mbts(values, k, alpha)),
+                    ("P-GMCSI", calculate_p_gmcsi(values, k, alpha)),
+                    ("MAEI", calculate_maei(values, k, alpha, beta, gamma)),
+                    ("MCHI", calculate_mchi(values, k, alpha, gamma)),
+                ]
+                print("\nResults ({} values):".format(len(values)))
+                for name, result in results:
+                    print("{:10s} {:.10g}".format(name + ":", result))
+                print("Autotuned:", autotune_parameters(values))
+            except (TypeError, ValueError) as exc:
+                print("Could not calculate results: {}".format(exc))
+
+            again = input("\nCalculate another dataset? [y/N]: ").strip().lower()
+            if again not in ("y", "yes"):
+                return 0
+    except (EOFError, KeyboardInterrupt):
+        print("\nExiting Mumo calculator.")
+        return 0
+
+
+class MumoEngine:
+    """Convenient namespace exposing the framework's calculations."""
+
+    calculate_mpu = staticmethod(calculate_mpu)
+    calculate_mpd = staticmethod(calculate_mpd)
+    calculate_ma = staticmethod(calculate_ma)
+    calculate_mbts = staticmethod(calculate_mbts)
+    calculate_mpu_k = staticmethod(calculate_mpu_k)
+    calculate_mpd_k = staticmethod(calculate_mpd_k)
+    calculate_gma_k = staticmethod(calculate_gma_k)
+    calculate_p_mpu = staticmethod(calculate_p_mpu)
+    calculate_p_mpd = staticmethod(calculate_p_mpd)
+    calculate_p_gma = staticmethod(calculate_p_gma)
+    calculate_mbv = staticmethod(calculate_mbv)
+    calculate_p_mbts = staticmethod(calculate_p_mbts)
+    calculate_p_gmcsi = staticmethod(calculate_p_gmcsi)
+    calculate_maei = staticmethod(calculate_maei)
+    calculate_mchi = staticmethod(calculate_mchi)
+    autotune_parameters = staticmethod(autotune_parameters)
+    risk_velocity = staticmethod(risk_velocity)
+    risk_acceleration = staticmethod(risk_acceleration)
+    cumulative_exposure = staticmethod(cumulative_exposure)
+    boundary_matrix = staticmethod(boundary_matrix)
+    matrix_multiply = staticmethod(matrix_multiply)
+
+
+__all__ = [
+    "MumoEngine",
+    "MumoParameters",
+    "__version__",
+    "autotune_parameters",
+    "boundary_matrix",
+    "calculate_gma_k",
+    "calculate_ma",
+    "calculate_maei",
+    "calculate_mbv",
+    "calculate_mbts",
+    "calculate_mchi",
+    "calculate_mpd",
+    "calculate_mpd_k",
+    "calculate_mpu",
+    "calculate_mpu_k",
+    "calculate_p_gma",
+    "calculate_p_gmcsi",
+    "calculate_p_mbts",
+    "calculate_p_mpd",
+    "calculate_p_mpu",
+    "cumulative_exposure",
+    "matrix_multiply",
+    "risk_acceleration",
+    "risk_velocity",
+    "main",
+]
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mumo_gui.py

@@ -0,0 +1,365 @@
+"""Interactive desktop calculator for the Mumo framework."""
+
+from __future__ import annotations
+
+import math
+import tkinter as tk
+from tkinter import ttk
+from typing import Dict, List
+
+from mumo_framework import (
+    calculate_ma,
+    calculate_maei,
+    calculate_mbts,
+    calculate_mbv,
+    calculate_mchi,
+    calculate_mpd,
+    calculate_mpd_k,
+    calculate_mpu,
+    calculate_mpu_k,
+    calculate_p_gma,
+    calculate_p_gmcsi,
+    calculate_p_mbts,
+    calculate_p_mpd,
+    calculate_p_mpu,
+)
+
+
+_SAMPLE_DATA = "10, 12.5, 14, 15.5, 18, 21, 25, 28.5, 32, 36"
+
+
+def _parse_dataset(text: str) -> List[float]:
+    """Parse comma- or whitespace-separated finite numbers."""
+    tokens = text.replace(",", " ").split()
+    if not tokens:
+        raise ValueError("Enter at least three data values.")
+
+    values = []
+    for token in tokens:
+        try:
+            value = float(token)
+        except ValueError as exc:
+            raise ValueError("Could not read {!r} as a number.".format(token)) from exc
+        if not math.isfinite(value):
+            raise ValueError("All data values must be finite numbers.")
+        values.append(value)
+    if len(values) < 3:
+        raise ValueError("Enter at least three data values.")
+    return values
+
+
+def _calculate_results(
+    data: List[float], k: int, alpha: float, beta: float, gamma: float
+) -> Dict[str, float]:
+    """Calculate the displayed metrics for the current inputs."""
+    return {
+        "MPU": calculate_mpu(data),
+        "MPD": calculate_mpd(data),
+        "MA": calculate_ma(data),
+        "MBTS": calculate_mbts(data),
+        "MPU-k": calculate_mpu_k(data, k),
+        "MPD-k": calculate_mpd_k(data, k),
+        "P-MPU": calculate_p_mpu(data, k, alpha),
+        "P-MPD": calculate_p_mpd(data, k, alpha),
+        "P-GMA": calculate_p_gma(data, k, alpha, beta),
+        "MBV": calculate_mbv(data, k, alpha),
+        "P-MBTS": calculate_p_mbts(data, k, alpha),
+        "P-GMCSI": calculate_p_gmcsi(data, k, alpha),
+        "MAEI": calculate_maei(data, k, alpha, beta, gamma),
+        "MCHI": calculate_mchi(data, k, alpha, gamma),
+    }
+
+
+class MumoCalculator:
+    """Tkinter interface with live dataset and parameter updates."""
+
+    def __init__(self, root: tk.Tk) -> None:
+        self.root = root
+        self.root.title("Mumo Framework | Interactive Calculator")
+        self.root.minsize(760, 650)
+        self.root.geometry("940x800")
+        self.root.configure(background="#f3f6fb")
+        self._pending_update: str | None = None
+
+        self.k = tk.IntVar(value=2)
+        self.alpha = tk.DoubleVar(value=0.6)
+        self.beta = tk.DoubleVar(value=0.5)
+        self.gamma = tk.DoubleVar(value=0.5)
+        self.status = tk.StringVar(value="Edit the data or adjust a parameter to recalculate.")
+        self.count = tk.StringVar(value="0 values")
+        self._metric_values: Dict[str, tk.StringVar] = {}
+
+        self._style()
+        self._build()
+        self._set_sample()
+
+    def _style(self) -> None:
+        style = ttk.Style(self.root)
+        style.configure("TFrame", background="#f3f6fb")
+        style.configure("Panel.TFrame", background="#ffffff")
+        style.configure(
+            "Title.TLabel",
+            background="#f3f6fb",
+            foreground="#14213d",
+            font=("Segoe UI", 22, "bold"),
+        )
+        style.configure(
+            "Subtitle.TLabel",
+            background="#f3f6fb",
+            foreground="#65748b",
+            font=("Segoe UI", 10),
+        )
+        style.configure(
+            "PanelTitle.TLabel",
+            background="#ffffff",
+            foreground="#14213d",
+            font=("Segoe UI", 11, "bold"),
+        )
+        style.configure(
+            "MetricName.TLabel",
+            background="#ffffff",
+            foreground="#65748b",
+            font=("Segoe UI", 9),
+        )
+        style.configure(
+            "MetricValue.TLabel",
+            background="#ffffff",
+            foreground="#14213d",
+            font=("Segoe UI", 16, "bold"),
+        )
+        style.configure(
+            "HighlightValue.TLabel",
+            background="#ffffff",
+            foreground="#3157d5",
+            font=("Segoe UI", 18, "bold"),
+        )
+        style.configure("TButton", font=("Segoe UI", 9), padding=(10, 6))
+        style.configure("TScale", background="#ffffff")
+
+    def _build(self) -> None:
+        outer = ttk.Frame(self.root, padding=(24, 20))
+        outer.pack(fill="both", expand=True)
+        ttk.Label(outer, text="Mumo Interactive Calculator", style="Title.TLabel").pack(
+            anchor="w"
+        )
+        ttk.Label(
+            outer,
+            text="Explore how your dataset and model parameters shape each index.",
+            style="Subtitle.TLabel",
+        ).pack(anchor="w", pady=(4, 18))
+
+        columns = ttk.Frame(outer)
+        columns.pack(fill="x")
+        columns.columnconfigure(0, weight=3)
+        columns.columnconfigure(1, weight=2)
+
+        data_panel = ttk.Frame(columns, style="Panel.TFrame", padding=16)
+        data_panel.grid(row=0, column=0, sticky="nsew", padx=(0, 10))
+        ttk.Label(data_panel, text="Dataset", style="PanelTitle.TLabel").pack(
+            anchor="w"
+        )
+        ttk.Label(
+            data_panel,
+            text="Paste or type numbers, separated by commas, spaces, or new lines.",
+            style="MetricName.TLabel",
+        ).pack(anchor="w", pady=(3, 10))
+        text_frame = ttk.Frame(data_panel, style="Panel.TFrame")
+        text_frame.pack(fill="both", expand=True)
+        self.dataset = tk.Text(
+            text_frame,
+            height=5,
+            wrap="word",
+            undo=True,
+            font=("Consolas", 10),
+            relief="solid",
+            borderwidth=1,
+            padx=9,
+            pady=8,
+        )
+        scrollbar = ttk.Scrollbar(
+            text_frame, orient="vertical", command=self.dataset.yview
+        )
+        self.dataset.configure(yscrollcommand=scrollbar.set)
+        self.dataset.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+        self.dataset.bind("<<Modified>>", self._on_dataset_change)
+
+        data_actions = ttk.Frame(data_panel, style="Panel.TFrame")
+        data_actions.pack(fill="x", pady=(9, 0))
+        ttk.Button(data_actions, text="Load sample", command=self._set_sample).pack(
+            side="left"
+        )
+        ttk.Button(data_actions, text="Clear", command=self._clear_dataset).pack(
+            side="left", padx=(7, 0)
+        )
+        ttk.Label(data_actions, textvariable=self.count, style="MetricName.TLabel").pack(
+            side="right", pady=6
+        )
+
+        parameters = ttk.Frame(columns, style="Panel.TFrame", padding=16)
+        parameters.grid(row=0, column=1, sticky="nsew")
+        ttk.Label(parameters, text="Parameters", style="PanelTitle.TLabel").pack(
+            anchor="w", pady=(0, 5)
+        )
+        self._add_parameter(
+            parameters, "Core / boundary size (k)", self.k, 1, 4, "{:d}",
+            integer=True,
+        )
+        self._add_parameter(parameters, "Alpha", self.alpha, 0, 1, "{:.2f}")
+        self._add_parameter(parameters, "Beta", self.beta, 0, 1, "{:.2f}")
+        self._add_parameter(parameters, "Gamma", self.gamma, 0, 1, "{:.2f}")
+
+        results_panel = ttk.Frame(outer, style="Panel.TFrame", padding=16)
+        results_panel.pack(fill="both", expand=True, pady=(16, 0))
+        ttk.Label(results_panel, text="Calculated indices", style="PanelTitle.TLabel").pack(
+            anchor="w", pady=(0, 12)
+        )
+        metrics = ttk.Frame(results_panel, style="Panel.TFrame")
+        metrics.pack(fill="both", expand=True)
+        metric_names = [
+            "MPU", "MPD", "MA", "MBTS", "MPU-k", "MPD-k", "P-MPU",
+            "P-MPD", "P-GMA", "MBV", "P-MBTS", "P-GMCSI", "MAEI", "MCHI",
+        ]
+        for column in range(3):
+            metrics.columnconfigure(column, weight=1)
+        for index, name in enumerate(metric_names):
+            row, column = divmod(index, 3)
+            card = ttk.Frame(metrics, style="Panel.TFrame", padding=(8, 7))
+            card.grid(row=row, column=column, sticky="nsew", padx=4, pady=3)
+            ttk.Label(card, text=name, style="MetricName.TLabel").pack(anchor="w")
+            value = tk.StringVar(value="—")
+            self._metric_values[name] = value
+            value_style = (
+                "HighlightValue.TLabel" if name in ("MAEI", "MCHI") else "MetricValue.TLabel"
+            )
+            ttk.Label(card, textvariable=value, style=value_style).pack(anchor="w")
+
+        self.status_label = ttk.Label(
+            outer,
+            textvariable=self.status,
+            style="Subtitle.TLabel",
+            wraplength=880,
+        )
+        self.status_label.pack(anchor="w", pady=(11, 0))
+
+    def _add_parameter(
+        self,
+        parent: ttk.Frame,
+        label: str,
+        variable: tk.Variable,
+        minimum: int,
+        maximum: int,
+        number_format: str,
+        integer: bool = False,
+    ) -> None:
+        row = ttk.Frame(parent, style="Panel.TFrame")
+        row.pack(fill="x", pady=5)
+        heading = ttk.Frame(row, style="Panel.TFrame")
+        heading.pack(fill="x")
+        ttk.Label(heading, text=label, style="MetricName.TLabel").pack(side="left")
+        value_label = ttk.Label(heading, style="PanelTitle.TLabel")
+        value_label.pack(side="right")
+
+        def update_label(*_args: object) -> None:
+            value_label.configure(text=number_format.format(variable.get()))
+
+        variable.trace_add("write", update_label)
+        update_label()
+        if integer:
+            scale = tk.Scale(
+                row,
+                from_=minimum,
+                to=maximum,
+                resolution=1,
+                showvalue=False,
+                variable=variable,
+                command=self._on_parameter_change,
+                orient="horizontal",
+                highlightthickness=0,
+                borderwidth=0,
+                background="#ffffff",
+                troughcolor="#e8edf5",
+                activebackground="#3157d5",
+            )
+        else:
+            scale = ttk.Scale(
+                row,
+                from_=minimum,
+                to=maximum,
+                variable=variable,
+                command=self._on_parameter_change,
+            )
+        scale.pack(fill="x", pady=(2, 0))
+        if integer:
+            self.k_scale = scale
+
+    def _on_dataset_change(self, _event: tk.Event) -> None:
+        if not self.dataset.edit_modified():
+            return
+        self.dataset.edit_modified(False)
+        if self._pending_update is not None:
+            self.root.after_cancel(self._pending_update)
+        self._pending_update = self.root.after(250, self._recalculate)
+
+    def _on_parameter_change(self, _value: str) -> None:
+        self._recalculate()
+
+    def _set_sample(self) -> None:
+        self.dataset.delete("1.0", "end")
+        self.dataset.insert("1.0", _SAMPLE_DATA)
+        self.dataset.edit_modified(False)
+        self._recalculate()
+
+    def _clear_dataset(self) -> None:
+        self.dataset.delete("1.0", "end")
+        self.dataset.edit_modified(False)
+        self._recalculate()
+
+    def _recalculate(self) -> None:
+        self._pending_update = None
+        try:
+            data = _parse_dataset(self.dataset.get("1.0", "end-1c"))
+        except ValueError as exc:
+            self.count.set("— values")
+            self.status.set(str(exc))
+            self.status_label.configure(foreground="#b42318")
+            for value in self._metric_values.values():
+                value.set("—")
+            return
+
+        maximum_k = (len(data) - 1) // 2
+        self.k_scale.configure(from_=1, to=maximum_k)
+        if self.k.get() < 1 or self.k.get() > maximum_k:
+            self.k.set(min(maximum_k, max(1, self.k.get())))
+        self.count.set("{} values".format(len(data)))
+
+        try:
+            results = _calculate_results(
+                data, self.k.get(), self.alpha.get(), self.beta.get(), self.gamma.get()
+            )
+        except (TypeError, ValueError) as exc:
+            self.status.set("Could not calculate indices: {}".format(exc))
+            self.status_label.configure(foreground="#b42318")
+            for value in self._metric_values.values():
+                value.set("—")
+            return
+
+        for name, result in results.items():
+            self._metric_values[name].set("{:.6g}".format(result))
+        self.status.set(
+            "Sorted values are used for boundary calculations. "
+            "P-MBTS uses the mean after removing the lowest k and highest k values."
+        )
+        self.status_label.configure(foreground="#65748b")
+
+
+def main() -> int:
+    """Launch the interactive desktop calculator."""
+    root = tk.Tk()
+    MumoCalculator(root)
+    root.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())