Make the _C(), _A(), and _b() methods for games public.

[dunshire.git] / dunshire / games.py

diff --git a/dunshire/games.py b/dunshire/games.py
index 6480d7d31153afcc419d331e0cd416a64253a188..672810de8094df7c37005cd5106fe5b8175888c4 100644 (file)
--- a/dunshire/games.py
+++ b/dunshire/games.py
@@ -8,7 +8,8 @@ knows how to solve a linear game.
 from cvxopt import matrix, printing, solvers
 from .cones import CartesianProduct
 from .errors import GameUnsolvableException, PoorScalingException
 from cvxopt import matrix, printing, solvers
 from .cones import CartesianProduct
 from .errors import GameUnsolvableException, PoorScalingException

-from .matrices import append_col, append_row, condition_number, identity
+from .matrices import (append_col, append_row, condition_number, identity,
+                       inner_product)

 from . import options
 
 printing.options['dformat'] = options.FLOAT_FORMAT
 from . import options
 
 printing.options['dformat'] = options.FLOAT_FORMAT


@@ -334,17 +335,216 @@ class SymmetricLinearGame:
               '  e1 = {:s},\n' \
               '  e2 = {:s},\n' \
               '  Condition((L, K, e1, e2)) = {:f}.'
               '  e1 = {:s},\n' \
               '  e2 = {:s},\n' \
               '  Condition((L, K, e1, e2)) = {:f}.'

-        indented_L = '\n      '.join(str(self._L).splitlines())
-        indented_e1 = '\n       '.join(str(self._e1).splitlines())
-        indented_e2 = '\n       '.join(str(self._e2).splitlines())
+        indented_L = '\n      '.join(str(self.L()).splitlines())
+        indented_e1 = '\n       '.join(str(self.e1()).splitlines())
+        indented_e2 = '\n       '.join(str(self.e2()).splitlines())

 
         return tpl.format(indented_L,
 
         return tpl.format(indented_L,

-                          str(self._K),
+                          str(self.K()),

                           indented_e1,
                           indented_e2,
                           self.condition())
 
 
                           indented_e1,
                           indented_e2,
                           self.condition())
 
 

+    def L(self):
+        """
+        Return the matrix ``L`` passed to the constructor.
+
+        Returns
+        -------
+
+        matrix
+            The matrix that defines this game's :meth:`payoff` operator.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]]
+            >>> e1 = [1,1,1]
+            >>> e2 = [1,2,3]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.L())
+            [  1  -5 -15]
+            [ -1   2  -3]
+            [-12 -15   1]
+            <BLANKLINE>
+
+        """
+        return self._L
+
+
+    def K(self):
+        """
+        Return the cone over which this game is played.
+
+        Returns
+        -------
+
+        SymmetricCone
+            The :class:`SymmetricCone` over which this game is played.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]]
+            >>> e1 = [1,1,1]
+            >>> e2 = [1,2,3]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.K())
+            Nonnegative orthant in the real 3-space
+
+        """
+        return self._K
+
+
+    def e1(self):
+        """
+        Return player one's interior point.
+
+        Returns
+        -------
+
+        matrix
+            The point interior to :meth:`K` affiliated with player one.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]]
+            >>> e1 = [1,1,1]
+            >>> e2 = [1,2,3]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.e1())
+            [ 1]
+            [ 1]
+            [ 1]
+            <BLANKLINE>
+
+        """
+        return self._e1
+
+
+    def e2(self):
+        """
+        Return player two's interior point.
+
+        Returns
+        -------
+
+        matrix
+            The point interior to :meth:`K` affiliated with player one.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]]
+            >>> e1 = [1,1,1]
+            >>> e2 = [1,2,3]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.e2())
+            [ 1]
+            [ 2]
+            [ 3]
+            <BLANKLINE>
+
+        """
+        return self._e2
+
+
+    def payoff(self, strategy1, strategy2):
+        r"""
+        Return the payoff associated with ``strategy1`` and ``strategy2``.
+
+        The payoff operator takes pairs of strategies to a real
+        number. For example, if player one's strategy is :math:`x` and
+        player two's strategy is :math:`y`, then the associated payoff
+        is :math:`\left\langle L\left(x\right),y \right\rangle` \in
+        \mathbb{R}. Here, :math:`L` denotes the same linear operator as
+        :meth:`L`. This method computes the payoff given the two
+        players' strategies.
+
+        Parameters
+        ----------
+
+        strategy1 : matrix
+            Player one's strategy.
+
+        strategy2 : matrix
+            Player two's strategy.
+
+        Returns
+        -------
+
+        float
+            The payoff for the game when player one plays ``strategy1``
+            and player two plays ``strategy2``.
+
+        Examples
+        --------
+
+        The value of the game should be the payoff at the optimal
+        strategies::
+
+            >>> from dunshire import *
+            >>> from dunshire.options import ABS_TOL
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]]
+            >>> e1 = [1,1,1]
+            >>> e2 = [1,1,1]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> soln = SLG.solution()
+            >>> x_bar = soln.player1_optimal()
+            >>> y_bar = soln.player2_optimal()
+            >>> abs(SLG.payoff(x_bar, y_bar) - soln.game_value()) < ABS_TOL
+            True
+
+        """
+        return inner_product(self.L()*strategy1, strategy2)
+
+
+    def dimension(self):
+        """
+        Return the dimension of this game.
+
+        The dimension of a game is not needed for the theory, but it is
+        useful for the implementation. We define the dimension of a game
+        to be the dimension of its underlying cone. Or what is the same,
+        the dimension of the space from which the strategies are chosen.
+
+        Returns
+        -------
+
+        int
+            The dimension of the cone :meth:`K`, or of the space where
+            this game is played.
+
+        Examples
+        --------
+
+        The dimension of a game over the nonnegative quadrant in the
+        plane should be two (the dimension of the plane)::
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(2)
+            >>> L = [[1,-5],[-1,2]]
+            >>> e1 = [1,1]
+            >>> e2 = [1,4]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> SLG.dimension()
+            2
+
+        """
+        return self.K().dimension()
+
+

     def _zero(self):
         """
         Return a column of zeros that fits ``K``.
     def _zero(self):
         """
         Return a column of zeros that fits ``K``.


@@ -360,7 +560,7 @@ class SymmetricLinearGame:
         -------
 
         matrix
         -------
 
         matrix

-            A ``K.dimension()``-by-``1`` column vector of zeros.
+            A ``self.dimension()``-by-``1`` column vector of zeros.

 
         Examples
         --------
 
         Examples
         --------


@@ -378,10 +578,10 @@ class SymmetricLinearGame:
             <BLANKLINE>
 
         """
             <BLANKLINE>
 
         """

-        return matrix(0, (self._K.dimension(), 1), tc='d')
+        return matrix(0, (self.dimension(), 1), tc='d')

 
 
 
 

-    def _A(self):
+    def A(self):

         """
         Return the matrix ``A`` used in our CVXOPT construction.
 
         """
         Return the matrix ``A`` used in our CVXOPT construction.
 


@@ -397,7 +597,7 @@ class SymmetricLinearGame:
         -------
 
         matrix
         -------
 
         matrix

-            A ``1``-by-``(1 + K.dimension())`` row vector. Its first
+            A ``1``-by-``(1 + self.dimension())`` row vector. Its first

             entry is zero, and the rest are the entries of ``e2``.
 
         Examples
             entry is zero, and the rest are the entries of ``e2``.
 
         Examples


@@ -409,12 +609,12 @@ class SymmetricLinearGame:
             >>> e1 = [1,1,1]
             >>> e2 = [1,2,3]
             >>> SLG = SymmetricLinearGame(L, K, e1, e2)
             >>> e1 = [1,1,1]
             >>> e2 = [1,2,3]
             >>> SLG = SymmetricLinearGame(L, K, e1, e2)

-            >>> print(SLG._A())
+            >>> print(SLG.A())

             [0.0000000 1.0000000 2.0000000 3.0000000]
             <BLANKLINE>
 
         """
             [0.0000000 1.0000000 2.0000000 3.0000000]
             <BLANKLINE>
 
         """

-        return matrix([0, self._e2], (1, self._K.dimension() + 1), 'd')
+        return matrix([0, self.e2()], (1, self.dimension() + 1), 'd')

 
 
 
 
 
 


@@ -422,7 +622,7 @@ class SymmetricLinearGame:
         r"""
         Return the matrix ``G`` used in our CVXOPT construction.
 
         r"""
         Return the matrix ``G`` used in our CVXOPT construction.
 

-        Thus matrix ``G``that appears on the left-hand side of ``Gx + s = h``
+        Thus matrix ``G`` appears on the left-hand side of ``Gx + s = h``

         in the statement of the CVXOPT conelp program.
 
         .. warning::
         in the statement of the CVXOPT conelp program.
 
         .. warning::


@@ -434,7 +634,7 @@ class SymmetricLinearGame:
         -------
 
         matrix
         -------
 
         matrix

-            A ``2*K.dimension()``-by-``1 + K.dimension()`` matrix.
+            A ``2*self.dimension()``-by-``(1 + self.dimension())`` matrix.

 
         Examples
         --------
 
         Examples
         --------


@@ -455,66 +655,159 @@ class SymmetricLinearGame:
             <BLANKLINE>
 
         """
             <BLANKLINE>
 
         """

-        I = identity(self._K.dimension())
-        return append_row(append_col(self._zero(), -I),
-                          append_col(self._e1, -self._L))
+        identity_matrix = identity(self.dimension())
+        return append_row(append_col(self._zero(), -identity_matrix),
+                          append_col(self.e1(), -self.L()))

 
 
 
 

-    def _try_solution(self, c, h, C, b, tolerance):
-        # Actually solve the thing and obtain a dictionary describing
-        # what happened.
-        try:
-            solvers.options['show_progress'] = options.VERBOSE
-            solvers.options['abs_tol'] = tolerance
-            soln_dict = solvers.conelp(c,self._G(),h,C,self._A(),b)
-        except ValueError as e:
-            if str(e) == 'math domain error':
-                # Oops, CVXOPT tried to take the square root of a
-                # negative number. Report some details about the game
-                # rather than just the underlying CVXOPT crash.
-                raise PoorScalingException(self)
-            else:
-                raise e
+    def _c(self):
+        """
+        Return the vector ``c`` used in our CVXOPT construction.

 
 

-        # The optimal strategies are named ``p`` and ``q`` in the
-        # background documentation, and we need to extract them from
-        # the CVXOPT ``x`` and ``z`` variables. The objective values
-        # :math:`nu` and :math:`omega` can also be found in the CVXOPT
-        # ``x`` and ``y`` variables; however, they're stored
-        # conveniently as separate entries in the solution dictionary.
-        p1_value = -soln_dict['primal objective']
-        p2_value = -soln_dict['dual objective']
-        p1_optimal = soln_dict['x'][1:]
-        p2_optimal = soln_dict['z'][self._K.dimension():]
+        The column vector ``c``  appears in the objective function
+        value ``<c,x>`` in the statement of the CVXOPT conelp program.
+
+        .. warning::
+
+            It is not safe to cache any of the matrices passed to
+            CVXOPT, because it can clobber them.
+
+        Returns
+        -------
+
+        matrix
+            A ``self.dimension()``-by-``1`` column vector.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[4,5,6],[7,8,9],[10,11,12]]
+            >>> e1 = [1,2,3]
+            >>> e2 = [1,1,1]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG._c())
+            [-1.0000000]
+            [ 0.0000000]
+            [ 0.0000000]
+            [ 0.0000000]
+            <BLANKLINE>
+
+        """
+        return matrix([-1, self._zero()])
+
+
+    def C(self):
+        """
+        Return the cone ``C`` used in our CVXOPT construction.
+
+        The cone ``C`` is the cone over which the conelp program takes
+        place.
+
+        Returns
+        -------
+
+        CartesianProduct
+            The cartesian product of ``K`` with itself.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[4,5,6],[7,8,9],[10,11,12]]
+            >>> e1 = [1,2,3]
+            >>> e2 = [1,1,1]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.C())
+            Cartesian product of dimension 6 with 2 factors:
+              * Nonnegative orthant in the real 3-space
+              * Nonnegative orthant in the real 3-space
+
+        """
+        return CartesianProduct(self._K, self._K)
+
+    def _h(self):
+        """
+        Return the ``h`` vector used in our CVXOPT construction.
+
+        The ``h`` vector appears on the right-hand side of :math:`Gx + s
+        = h` in the statement of the CVXOPT conelp program.
+
+        .. warning::
+
+            It is not safe to cache any of the matrices passed to
+            CVXOPT, because it can clobber them.
+
+        Returns
+        -------
+
+        matrix
+            A ``2*self.dimension()``-by-``1`` column vector of zeros.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[4,5,6],[7,8,9],[10,11,12]]
+            >>> e1 = [1,2,3]
+            >>> e2 = [1,1,1]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG._h())
+            [0.0000000]
+            [0.0000000]
+            [0.0000000]
+            [0.0000000]
+            [0.0000000]
+            [0.0000000]
+            <BLANKLINE>
+
+        """
+
+        return matrix([self._zero(), self._zero()])
+
+
+    @staticmethod
+    def b():
+        """
+        Return the ``b`` vector used in our CVXOPT construction.
+
+        The vector ``b`` appears on the right-hand side of :math:`Ax =
+        b` in the statement of the CVXOPT conelp program.
+
+        This method is static because the dimensions and entries of
+        ``b`` are known beforehand, and don't depend on any other
+        properties of the game.
+
+        .. warning::
+
+            It is not safe to cache any of the matrices passed to
+            CVXOPT, because it can clobber them.
+
+        Returns
+        -------
+
+        matrix
+            A ``1``-by-``1`` matrix containing a single entry ``1``.
+
+        Examples
+        --------
+
+            >>> from dunshire import *
+            >>> K = NonnegativeOrthant(3)
+            >>> L = [[4,5,6],[7,8,9],[10,11,12]]
+            >>> e1 = [1,2,3]
+            >>> e2 = [1,1,1]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.b())
+            [1.0000000]
+            <BLANKLINE>
+
+        """
+        return matrix([1], tc='d')

 
 

-        # The "status" field contains "optimal" if everything went
-        # according to plan. Other possible values are "primal
-        # infeasible", "dual infeasible", "unknown", all of which mean
-        # we didn't get a solution. The "infeasible" ones are the
-        # worst, since they indicate that CVXOPT is convinced the
-        # problem is infeasible (and that cannot happen).
-        if soln_dict['status'] in ['primal infeasible', 'dual infeasible']:
-            raise GameUnsolvableException(self, soln_dict)
-        elif soln_dict['status'] == 'unknown':
-            # When we get a status of "unknown", we may still be able
-            # to salvage a solution out of the returned
-            # dictionary. Often this is the result of numerical
-            # difficulty and we can simply check that the primal/dual
-            # objectives match (within a tolerance) and that the
-            # primal/dual optimal solutions are within the cone (to a
-            # tolerance as well).
-            #
-            # The fudge factor of two is basically unjustified, but
-            # makes intuitive sense when you imagine that the primal
-            # value could be under the true optimal by ``ABS_TOL``
-            # and the dual value could be over by the same amount.
-            #
-            if abs(p1_value - p2_value) > tolerance:
-                raise GameUnsolvableException(self, soln_dict)
-            if (p1_optimal not in self._K) or (p2_optimal not in self._K):
-                raise GameUnsolvableException(self, soln_dict)
-
-        return Solution(p1_value, p1_optimal, p2_optimal)

 
 
     def solution(self):
 
 
     def solution(self):


@@ -581,32 +874,132 @@ class SymmetricLinearGame:
               [0.156...]
               [0.187...]
 
               [0.156...]
               [0.187...]
 

-        """
-        # The cone "C" that appears in the statement of the CVXOPT
-        # conelp program.
-        C = CartesianProduct(self._K, self._K)
+        This is another Gowda/Ravindran example that is supposed to have
+        a negative game value::

 
 

-        # The column vector "b" that appears on the right-hand side of
-        # Ax = b in the statement of the CVXOPT conelp program.
-        b = matrix([1], tc='d')
+            >>> from dunshire import *
+            >>> from dunshire.options import ABS_TOL
+            >>> L = [[1, -2], [-2, 1]]
+            >>> K = NonnegativeOrthant(2)
+            >>> e1 = [1, 1]
+            >>> e2 = e1
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> SLG.solution().game_value() < -ABS_TOL
+            True

 
 

-        # The column vector "h" that appears on the right-hand side of
-        # Gx + s = h in the statement of the CVXOPT conelp program.
-        h = matrix([self._zero(), self._zero()])
+        The following two games are problematic numerically, but we
+        should be able to solve them::

 
 

-        # The column vector "c" that appears in the objective function
-        # value <c,x> in the statement of the CVXOPT conelp program.
-        c = matrix([-1, self._zero()])
+            >>> from dunshire import *
+            >>> L = [[-0.95237953890954685221, 1.83474556206462535712],
+            ...      [ 1.30481749924621448500, 1.65278664543326403447]]
+            >>> K = NonnegativeOrthant(2)
+            >>> e1 = [0.95477167524644313001, 0.63270781756540095397]
+            >>> e2 = [0.39633793037154141370, 0.10239281495640320530]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.solution())
+            Game value: 18.767...
+            Player 1 optimal:
+              [-0.000...]
+              [ 9.766...]
+            Player 2 optimal:
+              [1.047...]
+              [0.000...]
+
+        ::

 
 

+            >>> from dunshire import *
+            >>> L = [[1.54159395026049472754, 2.21344728574316684799],
+            ...      [1.33147433507846657541, 1.17913616272988108769]]
+            >>> K = NonnegativeOrthant(2)
+            >>> e1 = [0.39903040089404784307, 0.12377403622479113410]
+            >>> e2 = [0.15695181142215544612, 0.85527381344651265405]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.solution())
+            Game value: 24.614...
+            Player 1 optimal:
+              [ 6.371...]
+              [-0.000...]
+            Player 2 optimal:
+              [2.506...]
+              [0.000...]
+
+        """

         try:
         try:

-            # First try with a stricter tolerance. Who knows, it might work.
-            return self._try_solution(c, h, C.cvxopt_dims(), b,
-                                      tolerance = options.ABS_TOL / 10)
+            opts = {'show_progress': False}
+            soln_dict = solvers.conelp(self._c(),
+                                       self._G(),
+                                       self._h(),
+                                       self.C().cvxopt_dims(),
+                                       self.A(),
+                                       self.b(),
+                                       options=opts)
+        except ValueError as error:
+            if str(error) == 'math domain error':
+                # Oops, CVXOPT tried to take the square root of a
+                # negative number. Report some details about the game
+                # rather than just the underlying CVXOPT crash.
+                printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
+                raise PoorScalingException(self)
+            else:
+                raise error
+
+        # The optimal strategies are named ``p`` and ``q`` in the
+        # background documentation, and we need to extract them from
+        # the CVXOPT ``x`` and ``z`` variables. The objective values
+        # :math:`nu` and :math:`omega` can also be found in the CVXOPT
+        # ``x`` and ``y`` variables; however, they're stored
+        # conveniently as separate entries in the solution dictionary.
+        p1_value = -soln_dict['primal objective']
+        p2_value = -soln_dict['dual objective']
+        p1_optimal = soln_dict['x'][1:]
+        p2_optimal = soln_dict['z'][self.dimension():]
+
+        # The "status" field contains "optimal" if everything went
+        # according to plan. Other possible values are "primal
+        # infeasible", "dual infeasible", "unknown", all of which mean
+        # we didn't get a solution.
+        #
+        # The "infeasible" ones are the worst, since they indicate
+        # that CVXOPT is convinced the problem is infeasible (and that
+        # cannot happen).
+        if soln_dict['status'] in ['primal infeasible', 'dual infeasible']:
+            printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
+            raise GameUnsolvableException(self, soln_dict)
+
+        # The "optimal" and "unknown" results, we actually treat the
+        # same. Even if CVXOPT bails out due to numerical difficulty,
+        # it will have some candidate points in mind. If those
+        # candidates are good enough, we take them. We do the same
+        # check (perhaps pointlessly so) for "optimal" results.
+        #
+        # First we check that the primal/dual objective values are
+        # close enough (one could be low by ABS_TOL, the other high by
+        # it) because otherwise CVXOPT might return "unknown" and give
+        # us two points in the cone that are nowhere near optimal.
+        if abs(p1_value - p2_value) > 2*options.ABS_TOL:
+            printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
+            raise GameUnsolvableException(self, soln_dict)
+
+        # And we also check that the points it gave us belong to the
+        # cone, just in case...
+        if (p1_optimal not in self._K) or (p2_optimal not in self._K):
+            printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
+            raise GameUnsolvableException(self, soln_dict)

 
 

-        except (PoorScalingException, GameUnsolvableException):
-            # Ok, that didn't work. Let's try it with the default.
-            return self._try_solution(c, h, C.cvxopt_dims(), b,
-                                      tolerance = options.ABS_TOL)
+        # For the game value, we could use any of:
+        #
+        #   * p1_value
+        #   * p2_value
+        #   * (p1_value + p2_value)/2
+        #   * the game payoff
+        #
+        # We want the game value to be the payoff, however, so it
+        # makes the most sense to just use that, even if it means we
+        # can't test the fact that p1_value/p2_value are close to the
+        # payoff.
+        payoff = self.payoff(p1_optimal, p2_optimal)
+        return Solution(payoff, p1_optimal, p2_optimal)

 
 
     def condition(self):
 
 
     def condition(self):


@@ -643,7 +1036,7 @@ class SymmetricLinearGame:
         True
 
         """
         True
 
         """

-        return (condition_number(self._G()) + condition_number(self._A()))/2
+        return (condition_number(self._G()) + condition_number(self.A()))/2

 
 
     def dual(self):
 
 
     def dual(self):


@@ -679,10 +1072,10 @@ class SymmetricLinearGame:
               Condition((L, K, e1, e2)) = 44.476...
 
         """
               Condition((L, K, e1, e2)) = 44.476...
 
         """

-        # We pass ``self._L`` right back into the constructor, because
+        # We pass ``self.L()`` right back into the constructor, because

         # it will be transposed there. And keep in mind that ``self._K``
         # is its own dual.
         # it will be transposed there. And keep in mind that ``self._K``
         # is its own dual.

-        return SymmetricLinearGame(self._L,
-                                   self._K,
-                                   self._e2,
-                                   self._e1)
+        return SymmetricLinearGame(self.L(),
+                                   self.K(),
+                                   self.e2(),
+                                   self.e1())