Nashpy

0.0.43 · active · verified Mon Apr 13

Nashpy is a Python library providing algorithms for computing Nash equilibria and analyzing 2-player games, including matrix games and repeated games. It is built on top of NumPy and SciPy for efficient numerical computation. Currently at version 0.0.43, the library maintains a frequent release cadence, typically with minor updates and bug fixes.

Warnings

gotcha Payoff matrices for `nashpy.Game` must be `numpy.ndarray` objects. Passing plain Python lists directly will result in a `TypeError` or unexpected behavior.
Fix: Convert lists to `numpy.array()` before passing them to the `Game` constructor, e.g., `A = np.array([[1, 2], [3, 4]])`.
breaking As a `0.0.x` version library, Nashpy's API is subject to change without strict adherence to semantic versioning. Minor version updates (e.g., 0.0.42 to 0.0.43) may introduce breaking changes.
Fix: Pin your `nashpy` version in `requirements.txt` or `pyproject.toml` to a specific patch version (e.g., `nashpy==0.0.43`) and review changelogs for updates before upgrading.
gotcha Some algorithms, particularly `lemke_howson` and `lemke_howson_lex`, may struggle or fail to converge on degenerate games or games with specific numerical properties. The library's focus is on general case solution.
Fix: Consult the documentation for specific algorithm limitations. If issues arise, consider slightly perturbing game matrices (if appropriate for your problem domain) or exploring alternative algorithms provided by Nashpy.

Install

pip install nashpy Install stable version

Imports

Game

import nashpy as nash
game = nash.Game(A, B)

VertexEnum
```
from nashpy.algorithms import support_enumeration
```
Main algorithms like support_enumeration are often accessed directly or via the Game object.

Quickstart

This example demonstrates how to define a 2-player, 2-strategy game using NumPy arrays for payoff matrices and find its Nash equilibria using the `support_enumeration` algorithm.

import nashpy as nash
import numpy as np

# Define payoff matrices for player 1 (A) and player 2 (B)
A = np.array([[3, 0], [5, 1]])
B = np.array([[3, 5], [0, 1]])

# Create a Nash game object
game = nash.Game(A, B)

# Compute Nash equilibria using support enumeration
equilibria = game.support_enumeration()

# Print the equilibria (mixed strategies for each player)
print("Nash Equilibria:")
for eq in equilibria:
    print(eq)

view raw JSON →