minigame 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWY0MTkxZDc2ZTg1NWExMTgwODMyMDAwNjEwNmQ3YzZiODJmYTM1Zg==
+  data.tar.gz: !binary |-
+    NGYzYTBiYTQ0ODFkNDg5OWVlYWRiZDJmYTJjNDIyNzZlY2VmNzk3Yw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    OTM4MDgzZGY3MWNlNWUwOWY0ZGE0ZmM2ZDg4NWQ0NmQxNzU0YTc2Y2JiNWQy
+    MWMzMTA3MmY5MDk1Mjk0ZjVjMGNkODNlYTU0OGU2ZjJlMGYzYTdjYTBmOWE3
+    NTA2OWMzMDhhNGU2OGFmYjFhNzA5ZGJiNjVjZGMyODg2MThiYTg=
+  data.tar.gz: !binary |-
+    YjhlN2JiMzQzMjRmZDBmOGFjODQyMjA5Nzk5ZjRkZDAwZGYyN2Y4NGM3YjQ4
+    ZjZhM2NjMWI4YmNlNWQwZjc3OTVkMDk3ZDQwODhiNGJjNmVhMzc4YWUxNjI1
+    ZWJhZjk5YTNmMzUyMWMyMzUwYWNkY2ZiYTNjMzgzNzk1Y2RjNzA=

data/.gitignore

@@ -0,0 +1,99 @@
+#----------------------------------------------------------------------------
+# Ignore these files when commiting to a git repository.
+#
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# The original version of this file is found here:
+# https://github.com/RailsApps/rails3-application-templates/raw/master/files/gitignore.txt
+#
+# Corrections? Improvements? Create a GitHub issue: 
+# http://github.com/RailsApps/rails3-application-templates/issues
+#----------------------------------------------------------------------------
+
+# bundler state
+/.bundle
+/vendor/bundle/
+
+# minimal Rails specific artifacts
+db/*.sqlite3
+/log/*.log
+/tmp
+
+# various artifacts
+**.war
+*.rbc
+*.sassc
+.rspec
+.redcar/
+.sass-cache
+/config/config.yml
+/config/database.yml
+/coverage.data
+/coverage/
+/db/*.javadb/
+/db/*.sqlite3-journal
+/doc/api/
+/doc/app/
+/doc/features.html
+/doc/specs.html
+/public/cache
+/public/stylesheets/compiled
+/public/system
+/spec/tmp/*
+/cache
+/capybara*
+/capybara-*.html
+/gems
+/rerun.txt
+/spec/requests
+/spec/routing
+/spec/views
+/specifications
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+#
+# Here are some files you may want to ignore globally:
+
+# scm revert files
+**.orig
+
+# Mac finder artifacts
+.DS_Store
+*~
+
+# Netbeans project directory
+/nbproject/
+
+# RubyMine project files
+.idea
+
+# Textmate project files
+/*.tmproj
+
+# vim artifacts
+**.swp
+**.swo
+
+# Windows artifacts
+Thumbs.db
+
+# ctags artifact
+/tags
+
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp/*
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p327@minitest-dm --create

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in minigame.gemspec
+gemspec
+gem 'debugger'

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    minigame (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    columnize (0.3.6)
+    debugger (1.6.1)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.3)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.3)
+    minitest (5.0.6)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  debugger
+  minigame!
+  minitest
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Wavell Watson
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,85 @@
+# MiniGame
+## Simplistic Game Theory Library in Ruby
+
+Usage:
+
+To create new players:
+```
+employer = Player.new name: "IBM"
+employee = Player.new name: "John Smith
+```
+
+To create a new list of strategies for all players in a game:
+```
+strategies = Strategy.new [{name: "Accept Training"}, 
+                           {name: "Generic Training"},
+                           {name: "Task Specific Training"},
+                           {name: "Deny Training"}]
+```
+
+To create new StrategyProfiles:
+```
+
+# Regular training game -- generic strictly dominated
+# 
+#      Employer:            | Task Specific       |    Generic
+# Employee:  ---------------|---------------------|------------------
+#                           |                     |
+#   Deny Training           |  (-2, 0)            |     (-2, -1)
+#   ------------------------|---------------------|------------------
+#   Accept Training         |  (1, 4)             |     (5, -2)
+#   ------------------------|---------------------|------------------
+strategy_profile = StrategyProfile.new
+strategy_profile << {id: 1, strategy: generic, payoff: -2, player: employer}
+strategy_profile << {id: 1, strategy: accept, payoff: 5, player: employee}
+
+strategy_profile << {id: 2, strategy: generic, payoff: -1, player: employer}
+strategy_profile << {id: 2, strategy: deny, payoff: -2, player: employee}
+
+strategy_profile << {id: 3, strategy: task, payoff: 0, player: employer}
+strategy_profile << {id: 3, strategy: deny, payoff: -2, player: employee}
+
+strategy_profile << {id: 4, strategy: task, payoff: 4, player: employer}
+strategy_profile << {id: 4, strategy: accept, payoff: 1, player: employee}
+```
+
+To create a new game:
+```
+gs = Game.new
+gs.strategy_profiles = strategy_profile
+```
+
+To get the list of strictly dominated strategies:
+```
+gs.strictly_dominated_list
+
+  [{:name=>"Generic Training"}, {:name=>"Deny Training"}]
+
+```
+
+To get the list a weakly dominated strategies:
+```
+# training game -- generic weakly dominated (not realistic)
+# 
+#      Employer:            | Task Specific       |    Generic
+# Employer: ----------------|---------------------|------------------
+#                           |                     |
+#   Deny Training           |  (-2, -1)           |     (-2, -1)
+#   ------------------------|---------------------|------------------
+#   Accept Training         |  (1, 4)             |     (5, -2)
+#   ------------------------|---------------------|------------------
+gs.weakly_dominated_list
+
+  [{:name=>"Generic Training"}, {:name=>"Deny Training"}]
+
+```
+
+To get the list strategy profiles that are nash equilibria:
+```
+gs.nash 
+
+  [["Accept Training", "Task Specific Training"]]
+
+```
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/minigame/array_of_hashes.rb

@@ -0,0 +1,68 @@
+module ArrayOfHashes
+  include Enumerable
+
+  def initialize(*array_of_hashes)
+    array_of_hashes = [array_of_hashes].flatten
+    @keys ||=[]
+    # checks to see if required_keys was called 
+    # as a singleton method on the included class
+    @keys = self.class.keys if self.class.keys
+    check_array(array_of_hashes)
+    @array_of_hashes=array_of_hashes
+  end
+
+  def each(&block)
+    @array_of_hashes.each do |matchup|
+      block.call(matchup)
+    end
+  end
+
+  # creates a singleton method on the included class
+  # which avoids having to put 'required_keys' into the 
+  # included classes initialize method
+  def self.included(klass)
+    class << klass
+      attr_accessor :keys
+      def required_keys(*keys)
+        # force single keys to be an array
+        keys = [keys].flatten
+        keys.each do |x|
+          raise 'Not a symbol' if !keys[0].is_a? Symbol
+        end
+        @keys=keys
+      end
+    end
+  end
+
+  # required keys available on the instance 
+  def required_keys(*keys)
+    # force single keys to be an array
+    keys = [keys].flatten
+    keys.each do |x|
+      raise 'Not a symbol' if !keys[0].is_a? Symbol
+    end
+    @keys = keys
+  end
+
+  def required_keys=(keys)
+    required_keys(keys)
+  end
+
+  def check_array(array_of_hashes)
+    raise 'Not an array' if !array_of_hashes.is_a? Array
+    array_of_hashes.each{|x|check_keys(x)}
+  end
+  
+  def check_keys(val)
+    raise "Not a Hash" if val.class != Hash 
+    @keys.each do |x|
+      raise "#{x.to_s.capitalize} required" if !val.keys.include?(x)
+    end
+  end
+
+  def <<(val)
+    check_keys(val)
+    @array_of_hashes << val
+  end
+
+end

data/lib/minigame/game.rb

@@ -0,0 +1,3 @@
+class Game 
+  include Gameable
+end

data/lib/minigame/gameable.rb

@@ -0,0 +1,273 @@
+module Gameable
+  attr_accessor :strategy_profiles
+
+  # any set of strategies that are best responses for each other are nash equilibriums
+  def nash
+    # assume the same number of strategies for each side for now
+    # get one player
+    firstp = player_enum.first
+    # get opposing player
+    opp_p = player_enum[1]
+    # get strategies for the player
+    pstrats = player_strategy_profiles(firstp)
+    oppstrats = player_strategy_profiles(opp_p)
+    # loop through first strategies and get best responses
+    nash ||=[]
+    nash = pstrats.inject([]) do |acc, strat|
+      #loop through opposing strategies
+      oppstrats.map do |opp_strat|
+        br = best_response_against(strat)[:strategy][:name]
+        br_opposing = best_response_against(opp_strat)[:strategy][:name]
+        # best response for both sides that match each other are nash equilibriums
+        if br == opp_strat[:strategy][:name] && br_opposing == strat[:strategy][:name]
+          acc << [br,br_opposing]
+        end
+      end
+      acc
+    end
+    nash.uniq
+  end
+
+  def best_response_against(opponent_strategy)
+    best_resp=[]
+    # get opponent player from strategy
+    opp_player = player_from_strategy(opponent_strategy[:strategy]).first
+    # get player from strategy
+    player = players.detect{|x| x[:name] != opp_player[:name]}
+    strat_payoff_list ||=[]
+    # only collect possible payoffs that are opposed to the passed in opponent's strategy
+    strat_payoff_list = player_strategy_profiles(player).inject([]) do |acc, str|
+      if opposing_player_strategy_profile(str)[:strategy][:name]==opponent_strategy[:strategy][:name]
+        acc << str
+      end
+      acc
+    end
+    best_resp = strat_payoff_list.sort{|x| x[:payoff]}.reverse
+    # return top performer, later need to return all strategies that are equal in payoff
+    best_resp.first
+  end
+
+  def strictly_dominated_list
+    dominated_list ||=[]
+    players.each do |player|
+      dominated_list << player_strategy_profiles(player).inject([]) do |acc, strat|
+        # if count of total strategies for opposing player = count of better payoffs, then current strategy is strictly dominated
+        dev = deviating_strategies(strat)
+        new_strat_list =[]
+        dev.each do |dev_strat|
+          if compare_deviating_strategy(strat[:strategy], dev_strat) == :strictly_dominated  
+            new_strat_list << strat[:strategy] 
+          end
+        end
+        acc << new_strat_list
+      end
+    end
+    dominated_list.flatten.uniq
+  end
+
+  def weakly_dominated_list
+    dominated_list ||=[]
+    players.each do |player|
+      dominated_list << player_strategy_profiles(player).inject([]) do |acc, strat|
+        dev = deviating_strategies(strat)
+        dev.each do |dev_strat|
+          if compare_deviating_strategy(strat[:strategy], dev_strat) == :weakly_dominated          
+            acc << strat[:strategy] 
+          else
+            acc
+          end
+        end
+      end
+    end
+    dominated_list.flatten.uniq
+  end
+
+  def strategies_by_player(player)
+    strats = strategy_profiles.inject([]) do |acc, strat| 
+      if strat[:player] == player
+        acc << strat[:strategy]
+      else
+        acc
+      end
+    end
+    strats.uniq
+  end
+
+  # retrieve a player assigned to the strategy
+  def player_from_strategy(strategy)
+    stratp = strategy_profiles.detect{|x| x[:strategy][:name] == strategy[:name]}
+    stratp[:player] 
+  end
+  
+  # valid deviations must belong to the same player
+  def deviating_strategies(strategy_payoff)
+    strategies(strategy_payoff[:player].first).select{|x| x[:name] != strategy_payoff[:strategy][:name]}
+  end
+
+  # valid deviations must belong to the same player
+  def valid_deviation?(strategy, deviation)
+    selected_profile_list = self.strategy_profiles.detect{|x| x[:strategy][:name] == strategy[:name]}
+    matching_strategy_deviation = self.strategy_profiles.detect{|x| x[:strategy][:name] == deviation[:name] && x[:player] == selected_profile_list[:player] }
+  end
+
+  # for a strategy, take each strategy profile and match it against 
+  # it's corresonding but deviating strategy profile 
+  def compare_deviating_strategy(strategy, deviation)
+    raise "invalid deviation for submitted strategy" if !valid_deviation?(strategy, deviation)
+
+    one_equal = false
+    one_better = false
+    selected_profile_list = self.strategy_profiles.select{|x| x[:strategy][:name] == strategy[:name]}
+    # loop through strategy profiles from the strategy
+    selected_profile_list.each do |strat|
+      # store strat payoff e.g. -2
+      strat_payoff = strat[:payoff]
+      opposing_strategy = opposing_player_strategy_profile(strat)
+      # get deviating profile's payoff that corresponds to opposing strategy
+      deviating_profile = self.strategy_profiles.select do |x| 
+        x[:strategy][:name] == deviation[:name]  && opposing_player_strategy_profile(x)[:strategy][:name] == opposing_strategy[:strategy][:name]
+      end
+      # compare payoffs
+      # if strategy payoff is better than even just one deviating 
+      # payoff, the strategy is not dominated
+      if strat_payoff > deviating_profile[0][:payoff]
+        return :not_dominated
+      # if payoff for deviating strategy is better, remember that fact
+      elsif strat_payoff < deviating_profile[0][:payoff]
+        one_better = true
+      # if payoff for deviating strategy is equal, remember that fact
+      elsif strat_payoff == deviating_profile[0][:payoff]
+        one_equal = true
+      end
+    end
+    # if made it here, the deviating profile has either all better, or some better and some equal payoffs
+    # if all deviation profiles are equal or better, strategy is weakly dominated by the deviation
+    return :weakly_dominated if one_equal
+    # if all deviating profiles are better, strategy is dominated by the deviation
+    return :strictly_dominated if one_better
+
+    raise "nothing better, equal, or worse"
+  end
+
+
+  def equal_moves(strat)
+    complementary_moves(strat).select{|x|x["payoff"]==strat["payoff"]}
+  end
+
+  def payoff(strategy, player)
+    strategy_profile = [@strategy_profiles.select{|x| x[:strategy]==strategy && x[:player]==player}].flatten.first
+    strategy_profile[:payoff] if strategy_profile
+  end
+
+  def player_names
+    players.inject([]) do |acc, x|
+      acc << x[:name]
+    end 
+  end 
+
+  def players
+    # need inject to remove duplicates
+    @strategy_profiles.inject([]) do |acc, x| 
+      if acc.nil? || acc.empty?
+        # should be only one player per strategy_profile
+        acc << x[:player].first 
+      elsif !acc.include?(x[:player].first)
+        acc << x[:player].first 
+      else
+        acc
+      end
+    end
+  end 
+  
+  def player_enum
+    # need inject to remove duplicates
+    player_enums = @strategy_profiles.inject([]) do |acc, x| 
+        acc << x[:player] 
+    end
+    player_enums.uniq
+  end 
+
+  def opposing_players(strategy_profile)
+    players - [strategy_profile[:player].first]
+  end
+
+  def player_strategy_profiles(player)
+    # find some way to standardize what a player is ...
+    # possibly plural is enumerable, singular is a hash
+    # same problem with other classes
+    if player.class == Player
+      @strategy_profiles.select{|x| x[:player] == player}
+    else
+      @strategy_profiles.select{|x| x[:player].first == player}
+    end
+  end
+
+  def strategies(player)
+    player_strategy_profiles(player).reduce([]){|acc,strat| acc << strat[:strategy]}.uniq 
+  end  
+
+  # returns the strategy associated with the passed in profile
+  # belonging to the opposing player
+  def opposing_player_strategy_profile(strategy_profile)
+    # list of players
+    # get all strategies profiles for the first player that does not equal
+    # the passed in player
+    opposing_player = opposing_players(strategy_profile).first
+    # return the first strategy with the strategy profile id equal
+    # to the passed in strategy profile id
+    opposing_strategies = player_strategy_profiles(opposing_player)
+    opposing_strategies.select{|x| x[:id]==strategy_profile[:id]}.first
+  end
+ 
+  # all other moves other than the passed in strategy (for the player) 
+  def complementary_moves(strategy_profile)
+    psp = player_strategy_profiles(strategy_profile[:player])
+    psp.select do |x| 
+      # not the current strategy
+      if x[:strategy] != strategy_profile[:strategy] && 
+        # only return profiles matched vs original opposing strategy
+        opposing_player_strategy_profile(strategy_profile)[:strategy] == 
+          opposing_player_strategy_profile(x)[:strategy]
+        true
+      else
+        false 
+      end
+    end
+  end
+
+  # all other payoffs other than the passed in strategy (for the player) 
+  def deviating_payoffs(strategy_profile)
+    psp = player_strategy_profiles(strategy_profile[:player])
+    dev_pay = psp.select do |x| 
+      # not the current strategy
+      if x[:strategy] != strategy_profile[:strategy] && 
+        # only payoffs matched with original opposing strategy are
+        # considered deviating payoffs
+        opposing_player_strategy_profile(strategy_profile)[:strategy] == 
+          opposing_player_strategy_profile(x)[:strategy]
+        true
+      else
+        false 
+      end
+    end
+    dev_pay.reduce([]){|acc,p| acc << p}
+  end
+
+  alias_method :other_moves, :complementary_moves
+  
+  # this should list all of the deviating payoffs for the opponent's strategy
+  # within the passed in strategy profile.  Only the payoffs corresponding
+  # to the opponent's strategy are considered deviating payoffs
+  def better_payoffs?(strategy_profile)
+    deviating_payoffs(strategy_profile).select{|x| x[:payoff] > strategy_profile[:payoff]}
+  end
+
+  def better_or_equal_payoffs?(strategy_profile)
+    deviating_payoffs(strategy_profile).select{|x| x[:payoff] >= strategy_profile[:payoff]}
+  end
+
+  def worse_payoffs?(strategy_profile)
+    deviating_payoffs(strategy_profile).select{|x| x[:payoff] < strategy_profile[:payoff]}
+  end
+
+end

data/lib/minigame/payoff.rb

@@ -0,0 +1,12 @@
+require 'data_mapper'
+#class Payoff < ActiveRecord::Base
+#  belongs_to :player
+#  belongs_to :matchup
+#  attr_accessible :payoff
+#end
+class Payoff 
+  include DataMapper::Resource
+  belongs_to :player
+  belongs_to :matchup
+  #attr_accessible :payoff
+end

data/lib/minigame/player.rb

@@ -0,0 +1,5 @@
+require 'minigame/array_of_hashes'
+class Player
+  include ArrayOfHashes
+  required_keys :name
+end

data/lib/minigame/strategy.rb

@@ -0,0 +1,4 @@
+class Strategy 
+  include ArrayOfHashes
+  required_keys :name
+end

data/lib/minigame/strategy_profile.rb

@@ -0,0 +1,4 @@
+class StrategyProfile
+  include ArrayOfHashes
+  required_keys :id, :strategy, :payoff, :player
+end

data/lib/minigame/version.rb

@@ -0,0 +1,3 @@
+module Minigame
+  VERSION = "0.0.1"
+end

data/lib/minigame.rb

@@ -0,0 +1,9 @@
+require "minigame/version"
+require 'minigame/array_of_hashes'
+require 'minigame/gameable'
+require 'minigame/strategy'
+require 'minigame/strategy_profile'
+
+module MiniGame
+  include Gameable
+end

data/minigame.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minigame/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "minigame"
+  spec.version       = Minigame::VERSION
+  spec.authors       = ["Wavell Watson"]
+  spec.email         = ["wavell.watson@gmail.com"]
+  spec.description   = %q{A game theory library}
+  spec.summary       = %q{A minimalistic game theory library that computes nash equilibrium}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  
+end

data/test/test_minigame.rb

@@ -0,0 +1,107 @@
+require 'minigame'
+require 'minigame/player'
+require 'debugger'
+require 'minitest/autorun'
+require 'minitest/unit'
+
+class MiniGameTest < Minitest::Test
+  class Game
+    include MiniGame
+  end
+
+  def new_players
+    employer = Player.new name: "IBM"
+    employee = Player.new name: "John Smith"
+    [employer, employee]
+  end
+  def new_strategies
+    strategies = Strategy.new [{name: "Accept Training"}, 
+                               {name: "Generic Training"},
+                               {name: "Task Specific Training"},
+                               {name: "Deny Training"}]
+    # send back an array of strategies
+    strategies.inject([]){|x,y| x << y}
+  end
+
+  def new_profiles
+    employer, employee = new_players
+    accept, generic, task, deny = new_strategies 
+    strategy_profile = StrategyProfile.new
+    strategy_profile << {id: 1, strategy: generic, payoff: -2, player: employer}
+    strategy_profile << {id: 1, strategy: accept, payoff: 5, player: employee}
+
+    strategy_profile << {id: 2, strategy: generic, payoff: -1, player: employer}
+    strategy_profile << {id: 2, strategy: deny, payoff: -2, player: employee}
+
+    strategy_profile << {id: 3, strategy: task, payoff: 0, player: employer}
+    strategy_profile << {id: 3, strategy: deny, payoff: -2, player: employee}
+
+    strategy_profile << {id: 4, strategy: task, payoff: 4, player: employer}
+    strategy_profile << {id: 4, strategy: accept, payoff: 1, player: employee}
+    strategy_profile
+  end
+
+  def new_weak_profiles
+    employer, employee = new_players
+    accept, generic, task, deny = new_strategies 
+    strategy_profile = StrategyProfile.new
+    strategy_profile << {id: 1, strategy: generic, payoff: -2, player: employer}
+    strategy_profile << {id: 1, strategy: accept, payoff: 5, player: employee}
+
+    strategy_profile << {id: 2, strategy: generic, payoff: -1, player: employer}
+    strategy_profile << {id: 2, strategy: deny, payoff: -2, player: employee}
+
+    # not realistic
+    strategy_profile << {id: 3, strategy: task, payoff: -1, player: employer}
+    strategy_profile << {id: 3, strategy: deny, payoff: -2, player: employee}
+
+    strategy_profile << {id: 4, strategy: task, payoff: 4, player: employer}
+    strategy_profile << {id: 4, strategy: accept, payoff: 1, player: employee}
+  end
+
+  def test_mixin_game
+    game = Game.new
+    assert_equal Game, game.class
+  end
+
+  def test_new_player
+    employer, employee = new_players
+    assert_equal "IBM", employer.first[:name]
+  end
+
+  def test_new_strategy
+    strategies = new_strategies
+    assert_equal 4, strategies.count
+
+  end
+
+  def test_new_profiles
+    profiles = new_profiles
+    assert_equal 8, profiles.count
+  end
+
+  def test_game_w_profile
+    game = Game.new
+    game.strategy_profiles = new_profiles
+    assert_equal 8, game.strategy_profiles.count
+  end
+
+  def test_strictly_dominated_list
+    game = Game.new
+    game.strategy_profiles = new_profiles
+    assert_equal [{:name=>"Generic Training"}, {:name=>"Deny Training"}], game.strictly_dominated_list
+  end
+
+  def test_weakly_dominated_list
+    game = Game.new
+    game.strategy_profiles = new_profiles
+    assert_equal [{:name=>"Generic Training"}, {:name=>"Deny Training"}], game.weakly_dominated_list
+  end
+
+  def test_nash
+    game = Game.new
+    game.strategy_profiles = new_profiles
+    assert_equal [["Accept Training", "Task Specific Training"]], game.nash
+  end
+    
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: minigame
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Wavell Watson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A game theory library
+email:
+- wavell.watson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minigame.rb
+- lib/minigame/array_of_hashes.rb
+- lib/minigame/game.rb
+- lib/minigame/gameable.rb
+- lib/minigame/payoff.rb
+- lib/minigame/player.rb
+- lib/minigame/strategy.rb
+- lib/minigame/strategy_profile.rb
+- lib/minigame/version.rb
+- minigame.gemspec
+- test/test_minigame.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A minimalistic game theory library that computes nash equilibrium
+test_files:
+- test/test_minigame.rb