nashopt 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

{nashopt-1.0.0.dist-info → nashopt-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nashopt
-Version: 1.0.0
+Version: 1.0.1
 Summary: NashOpt - A Python Library for Computing Generalized Nash Equilibria and Solving Game-Design and Game-Theoretic Control Problems.
 Author-email: Alberto Bemporad <alberto.bemporad@imtlucca.it>
 Project-URL: Homepage, https://github.com/bemporad/nashopt
@@ -26,6 +26,9 @@ Dynamic: license-file
 
 This repository includes a library for solving different classes of nonlinear **Generalized Nash Equilibrium Problems** (GNEPs). The decision variables and Lagrange multipliers that jointly satisfy the KKT conditions for all agents are determined by solving a nonlinear least-squares problem. If a zero residual is obtained, this corresponds to a potential generalized Nash equilibrium, a property that can be verified by evaluating the individual **best responses**. For the special case of **Linear-Quadratic Games**, one or more equilibria are obtained by solving mixed-integer linear programming problems. The package can also solve **game-design** problems by optimizing the parameters of a **multiparametric GNEP** by box-constrained nonlinear optimization, as well as **game-theoretic control** problems, such as **Linear Quadratic Regulation** and **Model Predictive Control** problems.
 
+For more details about the mathematical formulations implemented in the library, see the 
+<a href="https://arxiv.org/abs/2512.23636">arXiv preprint 2512.23636</a>.
+
 ---
 ## Installation
 
@@ -310,6 +313,7 @@ of finding a vector $p$ (if one exists) such that $x^\star\approx x_{\textrm des
 $$J(x^\star,p)=\|x^\star-x_{\rm des}\|_2^2.$$
 
 We solve the game-design problem as
+
 $$
 \begin{aligned}
     \min_{z,p}\quad & J(x,p) + \frac{\rho}{2}\|R(z,p)\|_2^2\\
@@ -435,13 +439,14 @@ You can retrieve extra information after solving the Nash equilibrium problem, s
 
 ### Game-Theoretic Model Predictive Control
 We now want to make the output vector $y(t)$ of the system track a given setpoint $r(t)$.
-Each agent optimizes a sequence of input increments $\{\Delta u_{i,k}\}_{k=0}^{T-1}$ over a prediction horizon of $T$ steps, where $\Delta u_k=u_k-u_{k-1}$, by solving:
+Each agent optimizes a sequence of input increments 
+$\Delta u_{i,k}$, $k=0,\ldots,T-1$,
+over a prediction horizon of $T$ steps, where $\Delta u_k=u_k-u_{k-1}$, by minimizing
 
 $$
-\Delta u_i,\epsilon_i \in\arg\min \sum_{k=0}^{T-1}
-\left( (y_{k+1}-r(t))^\top Q_i (y_{k+1}-r(t))
-      + \Delta u_{i,k}^\top Q_{\Delta u,i}\Delta u_{i,k}\right)
-+ q_{\epsilon,i}^\top \epsilon_i
+q_{\epsilon,i}^\top \epsilon_i + 
+\sum_{k=0}^{T-1} (y_{k+1}-r(t))^\top Q_i (y_{k+1}-r(t))
+      + \Delta u_{i,k}^\top Q_{\Delta u,i}\Delta u_{i,k}
 $$
 
 $$
@@ -455,6 +460,7 @@ $$
 & i=1,\ldots,N,\ k=0,\ldots,T-1. 
 \end{array}
 $$
+
 where $Q_i\succeq 0$, $Q_{\Delta u,i}\succeq 0$ and $\epsilon_i\geq 0$ is a slack variable
 used to soften shared output constraints (with linear penalty $q_{\epsilon,i}\geq 0$). Each agent's MPC problem can be simplified by imposing the constraints only on a shorter constraint horizon of $T_c<T$ steps.
 
@@ -509,10 +515,11 @@ sol = nash_mpc.solve(x0, u1, ref, ..., solver='gurobi')
 ## Citation
 
 ```
-@misc{nashopt,
+@article{NashOpt,
     author={A. Bemporad},
     title={{NashOpt}: A {Python} Library for Computing Generalized {Nash} Equilibria and Game Design},
-    howpublished = {\url{https://github.com/bemporad/nashopt}},
+    journal = {arXiv preprint 2512.23636},
+    note = {\url{https://github.com/bemporad/nashopt}},
     year=2025
 }
 ```

nashopt-1.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+nashopt.py,sha256=i0cBKaY7QUBKI2ENvJURB5Oc7h1UgCmSocw_ViChNKI,107366
+nashopt-1.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nashopt-1.0.1.dist-info/METADATA,sha256=pUZqIWvUwxg2UqfzQ2qr3SsQwJjDLkZFJF04rI3Y6CI,18333
+nashopt-1.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nashopt-1.0.1.dist-info/top_level.txt,sha256=NuR1yd9NPYwmiknuGNUFNSw8tKTzPpaspAD7VtTvaFk,8
+nashopt-1.0.1.dist-info/RECORD,,

{nashopt-1.0.0.dist-info → nashopt-1.0.1.dist-info}/WHEEL

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

nashopt.py

@@ -1935,8 +1935,8 @@ class NashLQR():
 
         subject to dynamics x(k+1) = (A -B_{-i}K_{-i})x(k) + B_i u_i(k).
 
-        The LQR cost is solved by approximating the infinite-horizon cost by a finite-horizon cost using "dare_iters" fixed-point iterations.
-
+        The Nash equilibrium is found by letting agent i minimize the difference between K_i and the LQR gain K_i for the dynamics (A -B_{-i}K_{-i}, B_i). The LQR gain is computed approximately by evaluating the LQ cost over "dare_iters" time steps. The method is initialized from the centralized LQR solution with matrix Q=sum(Q_i) and R=block_diag(R_1, ..., R_N), obtained by "dare_iters" Riccati iterations.
+        
         (C) 2025 Alberto Bemporad, December 20, 2025
         """
         self.sizes = sizes
@@ -1978,7 +1978,7 @@ class NashLQR():
             not_i.append(list(range(sum_i[i-1])) + list(range(sum_i[i], nu)))
         self.not_i = not_i
         self.ii = [list(range(sum_i[i]-sizes[i], sum_i[i])) for i in range(N)]
-
+        
     def solve(self, **kwargs):
         """Solve the Nash-LQR game.
 
@@ -1988,6 +1988,7 @@ class NashLQR():
         """
 
         dare_iters = self.dare_iters
+        sol = SimpleNamespace()
 
         @jax.jit
         def jax_dare(A, B, Q, R):
@@ -2027,6 +2028,22 @@ class NashLQR():
             K_final = get_K(X_final, A, B, R)
             return X_final, K_final
 
+        # Initial guess = centralized LQR
+        nu = self.nu
+        bigR = block_diag(*self.R)
+        bigQ = sum(self.Q[i] for i in range(self.N))
+        _, K_cen = jax_dare(self.A, self.B, bigQ, bigR)
+        # # Check for comparison using python control library
+        # from control import dare
+        # P1, _, K1 = dare(A, B, bigQ, bigR)
+        # print("Max difference between LQR gains: ", np.max(np.abs(K_cen - K1)))
+        # print("Max difference between Riccati matrices: ", np.max(np.abs(P - P1)))
+
+        sol.K_centralized = K_cen
+        self.jax_dare = jax_dare  # store for possible later use outside solve()
+
+        print("Solving Nash-LQR problem ... ", end='')
+
         @partial(jax.jit, static_argnums=(1,))  # i is static
         def lqr_fun(K_flat, i, A, B, Q, R):
             K = K_flat.reshape(self.nu, self.nx)
@@ -2039,37 +2056,19 @@ class NashLQR():
         f = []
         for i in range(self.N):
             f.append(partial(lqr_fun, i=i, A=self.A,
-                     B=self.B, Q=self.Q, R=self.R))
+                    B=self.B, Q=self.Q, R=self.R))
 
         # each agent's variable is K_i (size[i] x nx) flattened
         sizes = [self.sizes[i]*self.nx for i in range(self.N)]
         gnep = GNEP(sizes, f=f)
 
-        # Initial guess = centralized LQR
-        nu = self.nu
-        bigR = block_diag(*self.R)
-        bigQ = sum(self.Q[i] for i in range(self.N))
-        _, K_cen = jax_dare(self.A, self.B, bigQ, bigR)
-
-        # # Check for comparison using python control library
-        # from control import dare
-        # P1, _, K1 = dare(A, B, bigQ, bigR)
-        # print("Max difference between LQR gains: ", np.max(np.abs(K_cen - K1)))
-        # print("Max difference between Riccati matrices: ", np.max(np.abs(P - P1)))
-
-        print("Solving Nash-LQR problem ... ", end='')
-
         K0 = K_cen.flatten()
-        sol = gnep.solve(x0=K0, **kwargs)
-        K_Nash, residual, stats = sol.x, sol.res, sol.stats
+        sol_residual = gnep.solve(x0=K0, **kwargs)
+        K_Nash, residual, stats = sol_residual.x, sol_residual.res, sol_residual.stats
         print("done.")
-        K_Nash = K_Nash.reshape(nu, self.nx)
-
-        sol = SimpleNamespace()
-        sol.K_Nash = K_Nash
+        sol.K_Nash = K_Nash.reshape(nu, self.nx)
         sol.residual = residual
         sol.stats = stats
-        sol.K_centralized = K_cen
         return sol
 
 

nashopt-1.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-nashopt.py,sha256=-yiXFuMCJishfgpZS3CBCVwwhnEdobpmdNOr-xvt8XI,106990
-nashopt-1.0.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nashopt-1.0.0.dist-info/METADATA,sha256=5r73xvkjYGjK7GDhcWLMYTRv62Bs8C3-xoC11fe0q98,18169
-nashopt-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nashopt-1.0.0.dist-info/top_level.txt,sha256=NuR1yd9NPYwmiknuGNUFNSw8tKTzPpaspAD7VtTvaFk,8
-nashopt-1.0.0.dist-info/RECORD,,