PyDiffGame 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

PyDiffGame/__init__.py

@@ -33,8 +33,11 @@ from PyDiffGame.continuous import ContinuousPyDiffGame
 from PyDiffGame.discrete import DiscretePyDiffGame
 from PyDiffGame.lqr import ContinuousLQR, DiscreteLQR
 from PyDiffGame.objective import GameObjective, LQRObjective, Objective
+from PyDiffGame.robust import ContinuousHInfinityControl
 
-__version__ = "2.0.2"
+__version__ = "2.0.4"
+__author__ = "Joshua Shay Kricheli"
+__url__ = "https://github.com/krichelj/PyDiffGame"
 
 __all__ = [
     "PyDiffGame",
@@ -42,9 +45,12 @@ __all__ = [
     "DiscretePyDiffGame",
     "ContinuousLQR",
     "DiscreteLQR",
+    "ContinuousHInfinityControl",
     "Objective",
     "LQRObjective",
     "GameObjective",
     "PyDiffGameLQRComparison",
     "__version__",
+    "__author__",
+    "__url__",
 ]

PyDiffGame/robust.py

@@ -0,0 +1,287 @@
+r"""Robust (:math:`H_\infty`) state feedback as a controller-vs-disturbance game.
+
+This completes the differential-games family in :mod:`PyDiffGame`: alongside the
+single-objective :class:`~PyDiffGame.lqr.ContinuousLQR` and the :math:`N`-player
+Nash :class:`~PyDiffGame.continuous.ContinuousPyDiffGame`, the *robust* design is
+the two-player **zero-sum** differential game in which the controller minimises
+and an adversarial disturbance maximises
+
+.. math::
+    J = \int_0^\infty x^\top Q x + u^\top R u - \gamma^2 w^\top w \; dt ,
+    \qquad \dot x = A x + B u + B_w w .
+
+Its saddle point is the :math:`H_\infty` state-feedback controller
+:math:`u = -K x`, :math:`K = R^{-1} B^\top P`, where :math:`P` solves the game
+algebraic Riccati equation
+
+.. math::
+    A^\top P + P A + Q - P\,(B R^{-1} B^\top - \gamma^{-2} B_w B_w^\top)\,P = 0 .
+
+The quadratic term is *indefinite* (the disturbance subtracts), which is exactly
+why an ordinary LQR Riccati solver cannot produce it and the game formulation is
+required. The controller minimises the worst-case :math:`L_2` gain from the
+disturbance to the weighted performance output — the robustness an LQR does not
+optimise.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.linalg import schur
+
+from PyDiffGame._typing import ArrayLike, FloatArray
+
+
+def _as_matrix(value: ArrayLike) -> FloatArray:
+    arr = np.asarray(value, dtype=np.float64)
+    return arr.reshape(1, 1) if arr.ndim == 0 else arr
+
+
+def _symmetric_sqrt(matrix: FloatArray) -> FloatArray:
+    """Symmetric positive-semidefinite square root of ``matrix``."""
+    eigenvalues, eigenvectors = np.linalg.eigh(0.5 * (matrix + matrix.T))
+    return (eigenvectors * np.sqrt(np.clip(eigenvalues, 0.0, None))) @ eigenvectors.T
+
+
+class ContinuousHInfinityControl:
+    r"""Continuous-time :math:`H_\infty` state feedback via the disturbance game.
+
+    Parameters
+    ----------
+    A, B : array_like
+        State and control matrices of :math:`\dot x = A x + B u + B_w w`.
+    B_w : array_like
+        Disturbance input matrix :math:`B_w`.
+    Q, R : array_like
+        Symmetric weights of the performance output (``Q`` PSD, ``R`` PD).
+    gamma : float, optional
+        Robustness level. Smaller is more robust but harder; it must exceed the
+        optimal :math:`\gamma^\star`. If omitted, :math:`\gamma^\star` is found by
+        bisection and ``gamma = gamma_margin * gamma_star`` is used.
+    gamma_margin : float, default ``1.3``
+        Multiplier applied to :math:`\gamma^\star` when ``gamma`` is not given.
+    """
+
+    def __init__(
+        self,
+        A: ArrayLike,
+        B: ArrayLike,
+        B_w: ArrayLike,
+        Q: ArrayLike,
+        R: ArrayLike,
+        *,
+        gamma: float | None = None,
+        gamma_margin: float = 1.3,
+    ) -> None:
+        self._A = _as_matrix(A)
+        self._B = _as_matrix(B)
+        self._B_w = _as_matrix(B_w)
+        self._Q = _as_matrix(Q)
+        self._R = _as_matrix(R)
+        self._n = self._A.shape[0]
+        if self._A.shape != (self._n, self._n):
+            raise ValueError("A must be square")
+        for name, mat, rows in (
+            ("B", self._B, self._n),
+            ("B_w", self._B_w, self._n),
+            ("Q", self._Q, self._n),
+        ):
+            if mat.shape[0] != rows:
+                raise ValueError(f"{name} must have {rows} rows")
+        if gamma_margin <= 1.0:
+            raise ValueError("gamma_margin must be > 1")
+
+        self._gamma_margin = float(gamma_margin)
+        self._gamma_star: float | None = None
+        self._gamma = None if gamma is None else float(gamma)
+        self._P: FloatArray | None = None
+        self._K: FloatArray | None = None
+
+    # ------------------------------------------------------------------ #
+    # GARE solve (Hamiltonian / ordered Schur)
+    # ------------------------------------------------------------------ #
+    def _solve_gare(self, gamma: float) -> FloatArray:
+        R_inv = np.linalg.inv(self._R)
+        S = self._B @ R_inv @ self._B.T - (1.0 / gamma**2) * (self._B_w @ self._B_w.T)
+        hamiltonian = np.block([[self._A, -S], [-self._Q, -self._A.T]])
+        _, vectors, stable_dim = schur(hamiltonian, sort="lhp")
+        if stable_dim != self._n:
+            raise ValueError(
+                f"no stabilising H-infinity solution at gamma={gamma:.4g} "
+                f"(stable subspace dimension {stable_dim} != {self._n}); gamma is below gamma*"
+            )
+        basis = vectors[:, : self._n]
+        upper, lower = basis[: self._n, :], basis[self._n :, :]
+        if abs(np.linalg.det(upper)) < 1e-12:
+            raise ValueError(f"degenerate Schur basis at gamma={gamma:.4g}")
+        P = np.real(lower @ np.linalg.inv(upper))
+        return 0.5 * (P + P.T)
+
+    def _stabilizing_solution(self, gamma: float) -> tuple[FloatArray | None, bool]:
+        """Solve the GARE at ``gamma`` and validate a stabilising PSD solution.
+
+        Robust admissibility predicate: rather than trust the (boundary-brittle)
+        stable-subspace dimension count alone, ``gamma`` is admissible only if the
+        recovered ``P`` is symmetric PSD *and* the closed loop ``A - B K`` is
+        strictly Hurwitz with a small margin. This makes admissibility monotone
+        through :math:`\\gamma^\\star` and immune to the imaginary-axis eigenvalue
+        jitter of the Hamiltonian at the boundary.
+        """
+        try:
+            P = self._solve_gare(gamma)
+        except ValueError:
+            return None, False
+        if float(np.min(np.linalg.eigvalsh(P))) < -1e-7:
+            return P, False
+        K = np.linalg.inv(self._R) @ self._B.T @ P
+        spectral_abscissa = float(np.max(np.linalg.eigvals(self._A - self._B @ K).real))
+        return P, spectral_abscissa < -1e-7
+
+    def _is_admissible(self, gamma: float) -> bool:
+        return self._stabilizing_solution(gamma)[1]
+
+    def optimal_gamma(self, *, iterations: int = 100) -> float:
+        r"""Smallest :math:`\gamma` admitting a stabilising solution (:math:`\gamma^\star`).
+
+        Brackets :math:`\gamma^\star` from *both* sides adaptively — doubling the
+        upper bound up until admissible and halving the lower bound down until
+        inadmissible — so it never silently floors out on systems whose
+        :math:`\gamma^\star` is tiny, then bisects on the validated admissibility
+        predicate (:meth:`_stabilizing_solution`), which is monotone through the
+        boundary.
+        """
+        if self._gamma_star is not None:
+            return self._gamma_star
+        upper = 1.0
+        for _ in range(60):
+            if self._is_admissible(upper):
+                break
+            upper *= 2.0
+        else:
+            raise RuntimeError("could not bracket a feasible upper gamma")
+        lower = upper
+        for _ in range(60):
+            lower *= 0.5
+            if not self._is_admissible(lower):
+                break
+        else:
+            # admissible all the way down: gamma* is effectively zero
+            self._gamma_star = float(lower)
+            return self._gamma_star
+        for _ in range(iterations):
+            mid = np.sqrt(lower * upper)
+            if self._is_admissible(mid):
+                upper = mid
+            else:
+                lower = mid
+            if upper / lower < 1.0 + 1e-6:
+                break
+        self._gamma_star = float(upper)
+        return self._gamma_star
+
+    def solve(self) -> ContinuousHInfinityControl:
+        """Solve the disturbance game and store the controller. Returns ``self``."""
+        gamma = self._gamma if self._gamma is not None else self.optimal_gamma() * self._gamma_margin
+        self._gamma = float(gamma)
+        self._P = self._solve_gare(gamma)
+        self._K = np.linalg.inv(self._R) @ self._B.T @ self._P
+        return self
+
+    # ------------------------------------------------------------------ #
+    # Results
+    # ------------------------------------------------------------------ #
+    def _require_solved(self) -> None:
+        if self._K is None:
+            raise RuntimeError("call solve() first")
+
+    @property
+    def K(self) -> FloatArray:
+        self._require_solved()
+        assert self._K is not None
+        return self._K
+
+    @property
+    def P(self) -> FloatArray:
+        self._require_solved()
+        assert self._P is not None
+        return self._P
+
+    @property
+    def gamma(self) -> float:
+        self._require_solved()
+        assert self._gamma is not None
+        return self._gamma
+
+    @property
+    def A_cl(self) -> FloatArray:
+        return self._A - self._B @ self.K
+
+    def is_closed_loop_stable(self, tolerance: float = 1e-9) -> bool:
+        return bool(np.all(np.linalg.eigvals(self.A_cl).real < tolerance))
+
+    def gare_residual(self) -> float:
+        """Max-abs residual of the game algebraic Riccati equation (should be ~0)."""
+        self._require_solved()
+        P, R_inv = self.P, np.linalg.inv(self._R)
+        S = self._B @ R_inv @ self._B.T - (1.0 / self.gamma**2) * (self._B_w @ self._B_w.T)
+        res = self._A.T @ P + P @ self._A + self._Q - P @ S @ P
+        return float(np.max(np.abs(res)))
+
+    def worst_case_gain(self, *, n_grid: int = 6000) -> tuple[float, float]:
+        r"""Closed-loop worst-case :math:`L_2` gain of this :math:`H_\infty` design.
+
+        See :func:`worst_case_l2_gain`. Returns ``(peak_gain, peak_frequency)``.
+        """
+        self._require_solved()
+        return worst_case_l2_gain(self._A, self._B, self.K, self._Q, self._R, self._B_w, n_grid=n_grid)
+
+
+def worst_case_l2_gain(
+    A: ArrayLike,
+    B: ArrayLike,
+    K: ArrayLike,
+    Q: ArrayLike,
+    R: ArrayLike,
+    B_w: ArrayLike,
+    *,
+    n_grid: int = 6000,
+) -> tuple[float, float]:
+    r"""Worst-case :math:`L_2` gain :math:`\lVert G_{zw}\rVert_\infty` of any state-feedback gain.
+
+    The induced gain from disturbance ``w`` to the weighted performance output
+    :math:`z = [Q^{1/2} x;\, R^{1/2} u]` for the closed loop ``A - B K``, i.e.
+    :math:`\max_\omega \sigma_{\max}(C (j\omega I - (A-BK))^{-1} B_w)`, by a
+    log-spaced frequency sweep refined around the peak (no slycot needed). Lower
+    is more robust; this is the formal robustness metric used to compare an
+    :math:`H_\infty` design against, say, an LQR. Returns ``inf`` if unstable.
+    """
+    A, B, K = _as_matrix(A), _as_matrix(B), _as_matrix(K)
+    Q, R, B_w = _as_matrix(Q), _as_matrix(R), _as_matrix(B_w)
+    A_cl = A - B @ K
+    eigenvalues = np.linalg.eigvals(A_cl)
+    if np.max(eigenvalues.real) >= 0:
+        return float("inf"), float("nan")
+    C = np.vstack([_symmetric_sqrt(Q), -_symmetric_sqrt(R) @ K])
+    eye = np.eye(A_cl.shape[0])
+
+    def sigma_max(omega: float) -> float:
+        transfer = C @ np.linalg.solve(1j * omega * eye - A_cl, B_w)
+        return float(np.linalg.svd(transfer, compute_uv=False)[0])
+
+    # Upper frequency derived from the fastest closed-loop mode so the sweep can
+    # never miss a high-frequency peak (with a generous safety factor and floor).
+    top = max(1.0e5, 50.0 * float(np.max(np.abs(eigenvalues))))
+    grid = np.concatenate([[0.0], np.logspace(-4, np.log10(top), n_grid)])
+    values = np.array([sigma_max(w) for w in grid])
+    peak = int(np.argmax(values))
+    lo = grid[max(peak - 1, 0)]
+    hi = grid[min(peak + 1, len(grid) - 1)]
+    fine = np.linspace(lo, hi, n_grid // 2)
+    fine_values = np.array([sigma_max(w) for w in fine])
+    best = int(np.argmax(fine_values))
+    if fine_values[best] >= values[peak]:
+        return float(fine_values[best]), float(fine[best])
+    return float(values[peak]), float(grid[peak])
+
+
+__all__ = ["ContinuousHInfinityControl", "worst_case_l2_gain"]

{pydiffgame-2.0.2.dist-info → pydiffgame-2.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyDiffGame
-Version: 2.0.2
+Version: 2.0.4
 Summary: Nash-equilibrium solutions to linear-quadratic differential games, via a reduction of the Game Hamilton-Jacobi-Bellman equations to coupled algebraic and differential Riccati equations for multi-objective dynamical control systems.
 Project-URL: Homepage, https://krichelj.github.io/PyDiffGame/
 Project-URL: Repository, https://github.com/krichelj/PyDiffGame
@@ -58,7 +58,7 @@ Requires-Dist: control>=0.10; extra == 'examples'
 Description-Content-Type: text/markdown
 
 <p align="center">
-    <img alt="PyDiffGame logo" src="https://raw.githubusercontent.com/krichelj/PyDiffGame/master/images/logo.png" width="420"/>
+    <img alt="PyDiffGame logo" src="https://raw.githubusercontent.com/krichelj/PyDiffGame/master/images/logo.gif" width="420"/>
 </p>
 
 <p align="center">
@@ -83,7 +83,8 @@ Description-Content-Type: text/markdown
 * [Quick start](#quick-start)
 * [Input parameters](#input-parameters)
 * [Tutorial: masses on springs](#tutorial-masses-on-springs)
-* [More examples](#more-examples)
+* [Robust control: H∞ as a game](#robust-control-h-as-a-game)
+* [Examples — a walkthrough](#examples--a-walkthrough)
 * [Testing and development](#testing-and-development)
 * [Citing](#citing)
 * [Acknowledgments](#acknowledgments)
@@ -332,17 +333,73 @@ player, without re-tuning one monolithic cost matrix.
 > [`tools/generate_readme_figures.py`](https://github.com/krichelj/PyDiffGame/blob/master/tools/generate_readme_figures.py)
 > (`uv run python tools/generate_readme_figures.py`), so they always match the current code.
 
-# More examples
+# Robust control: H∞ as a game
 
-The [`src/PyDiffGame/examples`](https://github.com/krichelj/PyDiffGame/tree/master/src/PyDiffGame/examples)
-directory contains further worked comparisons:
+A game ties the centralized LQR on a shared cost — it cannot beat it. The place a
+differential game **provably wins** is *robustness*: classical **H∞** state feedback **is**
+the saddle point of a two-player zero-sum game in which the controller minimises and an
+adversarial disturbance maximises. PyDiffGame ships it as `ContinuousHInfinityControl`,
+completing the family next to the LQR and the N-player Nash game:
 
-| Example | System |
-| --- | --- |
-| [`MassesWithSpringsComparison.py`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/MassesWithSpringsComparison.py) | Chain of masses coupled by springs (the tutorial above) |
-| [`InvertedPendulumComparison.py`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/InvertedPendulumComparison.py) | Inverted pendulum on a cart |
-| [`PVTOL.py`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/PVTOL.py) · [`PVTOLComparison.py`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/PVTOLComparison.py) | Planar vertical take-off & landing aircraft |
-| [`QuadRotorControl.py`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/QuadRotorControl.py) | Quadrotor attitude / position control |
+```python
+import numpy as np
+from PyDiffGame import ContinuousHInfinityControl
+
+A   = np.array([[0.0, 1.0], [0.0, 0.0]])   # a cart: position, velocity
+B   = np.array([[0.0], [1.0]])             # control force
+B_w = np.array([[0.0], [1.0]])             # disturbance force
+Q, R = np.diag([1.0, 0.0]), np.array([[1.0]])
+
+robust = ContinuousHInfinityControl(A, B, B_w, Q, R).solve()   # picks gamma = 1.3 * gamma*
+print(robust.K)                      # robust feedback gain, u = -K x
+print(robust.worst_case_gain()[0])   # closed-loop ||G_zw||inf — provably below the LQR's
+```
+
+It solves the **game** algebraic Riccati equation whose quadratic term
+`B R⁻¹ Bᵀ − γ⁻² B_w B_wᵀ` is *indefinite* — exactly what an ordinary LQR Riccati solver
+cannot do — via the Hamiltonian/Schur method, auto-finds the optimal robustness level
+`γ*`, and reports the formal worst-case L2 gain. Across a
+[13-system benchmark](https://github.com/krichelj/PyDiffGame/tree/master/benchmarks)
+(carts, vehicles, aircraft, drones, flexible structures) it reduces the worst-case
+disturbance gain on every system, **practically significantly on 10/13** — most where the
+LQR leaves a sharp resonant peak — each at a documented nominal-cost price:
+
+<p align="center">
+    <img alt="H-infinity game vs LQR under worst-case disturbance (inverted pendulum)" src="https://raw.githubusercontent.com/krichelj/PyDiffGame/bbd010f15ee13adc2bba5e7b99e1a3ecc0238583/benchmarks/results/robust_inverted_pendulum.gif" width="860"/>
+</p>
+
+Left: the pendulum-angle response to the worst-case disturbance (H∞ roughly halves
+it). Right: the `σmax(ω)` curves whose peak *is* the worst-case gain — the LQR's
+resonant peak (≈1.92) flattened by the H∞ game to ≈1.25. The
+[**robustness showcase**](https://github.com/krichelj/PyDiffGame/blob/master/benchmarks/README.md)
+animates every system.
+
+# Examples — a walkthrough
+
+The package ships four worked **LQR-vs-game comparisons** under
+[`src/PyDiffGame/examples`](https://github.com/krichelj/PyDiffGame/tree/master/src/PyDiffGame/examples);
+each builds a system, designs an LQR and a decomposed game on it, runs both and reports the
+costs. Run any of them with `uv run python -m PyDiffGame.examples.<name>`:
+
+| Example | System | What it shows |
+| --- | --- | --- |
+| [`MassesWithSpringsComparison`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/MassesWithSpringsComparison.py) | Chain of masses coupled by springs | The **lossless** modal decomposition (the tutorial above): the game reproduces the monolithic LQR optimum |
+| [`InvertedPendulumComparison`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/InvertedPendulumComparison.py) | Inverted pendulum on a cart | An **unstable, underactuated** plant; the nonlinear closed loop can be simulated from the designed gains |
+| [`PVTOLComparison`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/PVTOLComparison.py) · [`PVTOL`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/PVTOL.py) | Planar vertical take-off & landing aircraft | A 6-state aircraft with input decomposition across players |
+| [`QuadRotorControl`](https://github.com/krichelj/PyDiffGame/blob/master/src/PyDiffGame/examples/QuadRotorControl.py) | Quadrotor attitude / position control | A larger nonlinear vehicle with a cascaded design |
+
+For the **full study** — PyDiffGame vs [python-control](https://python-control.readthedocs.io/)
+across 13 systems on both the *nominal* cost (lossless tie / price of anarchy) and the
+*robustness* metric, with rendered GIFs, a metrics report and an adversarial review of the
+methodology — see
+[`benchmarks/`](https://github.com/krichelj/PyDiffGame/tree/master/benchmarks) and its
+[README](https://github.com/krichelj/PyDiffGame/blob/master/benchmarks/README.md):
+
+```bash
+uv run --extra dev python -m benchmarks.run_masses          # nominal: game == LQR (lossless)
+uv run --extra dev python -m benchmarks.run_anarchy         # nominal: the price of anarchy
+uv run --extra dev python -m benchmarks.run_robust_suite    # the 13-system robustness suite + report
+```
 
 # Testing and development
 

{pydiffgame-2.0.2.dist-info → pydiffgame-2.0.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-PyDiffGame/__init__.py,sha256=66tL7W30LVRZoWD76n0TPtv0omIrE9hy2TUaqYTiEVw,1657
+PyDiffGame/__init__.py,sha256=3h1YwXc7Klt4KXljtH4ng9mYCeYqg5H6QtlaruYFvww,1868
 PyDiffGame/_typing.py,sha256=HErUHmfzvkWLPWT1YJl_gpFYZctjkPqsnw3TeHuuggs,912
 PyDiffGame/base.py,sha256=hurrmsjCRQ049rHQGDa78JUBkCbLs-ZufDF8eHW5oNk,17287
 PyDiffGame/comparison.py,sha256=lJVhceZE7FqaNUGu8q1mA6GS0dbBwYFF1mHn0hzKuwM,4145
@@ -7,6 +7,7 @@ PyDiffGame/discrete.py,sha256=s62Fhx6H4okfalsopOwW2kp9onnnArHK7tkLnAUd3Zc,8127
 PyDiffGame/lqr.py,sha256=tcmL2wY_PtNon0XxdWehPJRvLdc44UqzJY9fC-ZnaJ0,1057
 PyDiffGame/objective.py,sha256=mnUPEauTZJl5HE3PScXdzDX5W0pm4fU-Jfi7Lvzgz1o,3910
 PyDiffGame/plotting.py,sha256=gvcgd-T0Y5uTcq15lJX3V4l39YqjpA0jFJsP-RzWTR0,2777
+PyDiffGame/robust.py,sha256=OrwHOnc1TJ1SnBO5F6ASTePJJmQLDi1HjsibXkTFkiM,11665
 PyDiffGame/examples/InvertedPendulumComparison.py,sha256=6jhtrHariZAblaWxfnrvOwjuGKKfTVhTyxDI5k3jam8,8615
 PyDiffGame/examples/MassesWithSpringsComparison.py,sha256=JKUyaDfxKnK_N3DEUjWBIntijquZ59fEHLfmNPxSWPk,4626
 PyDiffGame/examples/PVTOL.py,sha256=AQz_CFYw6oi9Qc2SXNFx1OIdtQTSDhqNSK02nPCDwuk,6542
@@ -33,7 +34,7 @@ PyDiffGame/examples/figures/PVTOL/PVTOL1.png,sha256=FBgKQSal5ZNyBsGz4RaVye0HBBQU
 PyDiffGame/examples/figures/PVTOL/PVTOL10.png,sha256=XyoLMz5WKfg3ny2JxVxVd1Mxjz9WQQn7N87-8YDLisY,77894
 PyDiffGame/examples/figures/PVTOL/PVTOL100.png,sha256=wkMdqrn9hSsIdU-Yhiki3X2fQ7dRRkfLyvBCFx5cMWI,75698
 PyDiffGame/examples/figures/PVTOL/PVTOL1000.png,sha256=Hg_hsf9gnc1HqC4JVjATVay7uDlnIqBRkG8lzpcfiZ0,77630
-pydiffgame-2.0.2.dist-info/METADATA,sha256=p2IQEz1MJ-C4DXrRHENghBjc-lYIfo-kOnDUuj4iusQ,20580
-pydiffgame-2.0.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-pydiffgame-2.0.2.dist-info/licenses/LICENSE,sha256=IYfdsBdqL9SmCEWsXUBTYh303LOWQQRCOUOfZI7PWz8,1139
-pydiffgame-2.0.2.dist-info/RECORD,,
+pydiffgame-2.0.4.dist-info/METADATA,sha256=Q1Bd3uLy5PI_yxcLJxOUlZoC_2rrbL-Xja2c2484jVw,24273
+pydiffgame-2.0.4.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pydiffgame-2.0.4.dist-info/licenses/LICENSE,sha256=IYfdsBdqL9SmCEWsXUBTYh303LOWQQRCOUOfZI7PWz8,1139
+pydiffgame-2.0.4.dist-info/RECORD,,