some shit wip

Author: krukah

README.md

@@ -3,15 +3,12 @@ robopoker
 [![license](https://img.shields.io/github/license/krukah/robopoker)](LICENSE)
 [![build](https://github.com/krukah/robopoker/actions/workflows/rust.yml/badge.svg)](https://github.com/krukah/robopoker/actions/workflows/rust.yml)
 
+# Overview
+
 `robopoker` is a Rust library to play, learn, analyze, track, and solve No-Limit Texas Hold'em.
 
 The guiding philosophy of this package was to use very tangible abstractions to represent the rules, mechanics, and strategies of NLHE. Every module is modeled as closely as possible to its real-world analogue, while also utilizing clever representations and transformations to be as memory- and compute-efficient as possible. Focus on Rust idiomatics is also a goal, avoiding use of unsafe and exploiting strong typing.
 
-# System Requirements
-
-- Minimum 8GB RAM for shortdeck. 50GB+ recommended for full.
-- Multi-core CPU. Clustering and CFR scale embarassingly.
-
 # Modules
 
 ## `cards`
@@ -22,7 +19,8 @@ Core functionality for working with standard playing cards and Texas Hold'em rul
 - **Equity Calculation**: Fast equity calculations between ranges of hands, supporting both exact enumeration and Monte Carlo simulation
 - **Exhaustive Iteration**: Efficient iteration over cards, hands, decks, and private-public observations with lazy bitwise advancing
 - **Distribution Analysis**: Tools for analyzing equity distributions and range vs range scenarios
-- **Bijective Representations**: Multiple card representations (u8/u16/u32/u64) allowing for maximally efficient operations and transformations
+- **Short Deck Support**: Full support for 36-card short deck variant with adjusted hand rankings and iterators
+- **Bijective Representations**: Multiple card representations `(u8/u16/u32/u64)` allow for maximally efficient operations and transformations
 
 ## `gameplay`
 
@@ -48,7 +46,7 @@ Advanced clustering capabilities for poker hand analysis:
 
 Monte Carlo Counterfactual Regret Minimization solver:
 
-- **RPS Convergence**: Previously demonstrated convergence on Rock-Paper-Scissors as validation
+- **Blueprint Convergence**: Previously demonstrated convergence on Rock-Paper-Scissors as validation
 - **External Sampling**: Implementation of external sampling MCCFR variant
 - **Dynamic Tree Building**: On-the-fly game tree construction for memory efficiency
 - **Linear Strategy Weighting**: Efficient strategy updates using iterative weighting and discount schemes
@@ -58,7 +56,13 @@ Monte Carlo Counterfactual Regret Minimization solver:
 
 Coming soon. A distributed and scalable single-binary WebSocket-based HTTP server that allows players to play, learn, analyze, and track hands remotely.
 
-## References
+# System Requirements
+
+- 8GB RAM for shortdeck abstraction
+- 5GB disk space for stored blueprint, abstraction, and metric tables
+- Multi-core CPU. Clustering and CFR scale embarassingly.
+
+# References
 
 1. (2007). Regret Minimization in Games with Incomplete Information. [(NIPS)](https://papers.nips.cc/paper/3306-regret-minimization-in-games-with-incomplete-information)
 2. (2015). Discretization of Continuous Action Spaces in Extensive-Form Games. [(AAMAS)](http://www.cs.cmu.edu/~sandholm/discretization.aamas15.fromACM.pdf)

src/clustering/encoding.rs

@@ -89,6 +89,29 @@ impl Encoder {
  * methods for unraveling the Tree
  */
 impl Encoder {
+    /// laying groundwork for pseudo-harmonic support
+    /// using the n-bet-filtered set of actions that we can take
+    /// we generalize using the raise granularity abstraction algorithm
+    /// of pseudo-harmonic mapping. then we spawn the children as if
+    /// these were the only actions available to us.
+    /// Self::spawn may be pub on Game
+    /// Self::unfold only takes River -> [River]
+    fn futures(&self, node: &Node) -> Vec<(Data, Edge)> {
+        let edges = self.children(node).into_iter().map(|(_, e)| e).collect();
+        let edges = Self::unfold(node, edges);
+        let datum = node.data();
+        edges
+            .into_iter()
+            .map(|action| Self::spawn(datum, action))
+            .collect()
+    }
+    fn unfold(node: &Node, edges: Vec<Edge>) -> Vec<Edge> {
+        todo!()
+    }
+    fn spawn(data: &Data, edge: Edge) -> (Data, Edge) {
+        todo!()
+    }
+
     pub fn root(&self) -> Data {
         let game = Game::root();
         let info = self.chance_abstraction(&game);
@@ -138,29 +161,6 @@ impl Encoder {
         }
     }
 
-    /// laying groundwork for pseudo-harmonic support
-    /// using the n-bet-filtered set of actions that we can take
-    /// we generalize using the raise granularity abstraction algorithm
-    /// of pseudo-harmonic mapping. then we spawn the children as if
-    /// these were the only actions available to us.
-    /// Self::spawn may be pub on Game
-    /// Self::unfold only takes River -> [River]
-    fn futures(&self, node: &Node) -> Vec<(Data, Edge)> {
-        let edges = self.children(node).into_iter().map(|(_, e)| e).collect();
-        let edges = Self::unfold(edges);
-        let datum = node.data();
-        edges
-            .into_iter()
-            .map(|action| Self::spawn(datum, action))
-            .collect()
-    }
-    fn unfold(edges: Vec<Edge>) -> Vec<Edge> {
-        todo!()
-    }
-    fn spawn(data: &Data, edge: Edge) -> (Data, Edge) {
-        todo!()
-    }
-
     /// i like to think of this as "positional encoding"
     /// i like to think of this as "positional encoding"
     /// later in the same round where the stakes are higher

src/mccfr/profile.rs

@@ -248,15 +248,15 @@ impl Profile {
             .get_mut(bucket)
             .expect("bucket been witnessed");
         for (action, &regret) in regrets {
-            let strategy = strategy.get_mut(action).expect("action been witnessed");
+            let decision = strategy.get_mut(action).expect("action been witnessed");
             let discount = match phase {
                 Phase::Discount => discount.regret(t, regret),
                 Phase::Explore => 1.,
                 Phase::Prune => 1.,
             };
-            strategy.regret *= discount;
-            strategy.regret += regret;
-            log::trace!("{} : {}", action, strategy.regret);
+            decision.regret *= discount;
+            decision.regret += regret;
+            log::trace!("{} : {}", action, decision.regret);
         }
     }
     pub fn update_policy(&mut self, bucket: &Bucket, policys: &BTreeMap<Edge, Probability>) {
@@ -269,10 +269,10 @@ impl Profile {
             .expect("bucket been witnessed");
         for (action, &policy) in policys {
             let discount = discount.policy(t);
-            let strategy = strategy.get_mut(action).expect("action been witnessed");
-            strategy.policy *= discount;
-            strategy.policy += policy;
-            log::trace!("{} : {}", action, strategy.policy);
+            let decision = strategy.get_mut(action).expect("action been witnessed");
+            decision.policy *= discount;
+            decision.policy += policy;
+            log::trace!("{} : {}", action, decision.policy);
         }
     }