Portfolio UNC Asheville — Computer Science
Supplementary Results · UNC Asheville Journal of Undergraduate Research · December 2022

Swarmbot: Experimental Results

Win rate, performance benchmarks, and game tree exploration maps comparing three swarm intelligence algorithms against a Monte Carlo baseline in Othello. This page accompanies the published journal article ↗.

Christopher Blaha Department of Computer Science, University of North Carolina Asheville Faculty Advisors: Dr. Marietta Cameron & Dr. Kenneth Bogert
Published Article Source Code

Win Rate Results

The following results reflect each algorithm's win percentage when competing against bots on eOthello. Monte Carlo Tree Search serves as the single-agent baseline — each of the three swarm methods (Ant Colony, Firefly, Cuckoo Bird) uses multiple agents in parallel to compare against it. Results are ordered by win percentage descending.

Figure 1 — Win percentage by algorithm against eOthello opponents
Ant Colony Optimization
61%
Cuckoo Bird Search
43%
Firefly Algorithm
41%
Monte Carlo Tree Search
36%
Interpretation

Ant Colony Optimization achieves the highest win rate (61%), with pheromone trails reinforcing the most successful paths across agents. The genetic algorithm-based swarms — Cuckoo Bird (43%) and Firefly (41%) — both outperform the Monte Carlo baseline (36%). This confirms the central thesis of the paper: multiple agents using swarm behaviors cover more of the game tree and converge on stronger strategies faster than a single Monte Carlo agent navigating at random. Monte Carlo's lower win rate is expected — it applies no coordination between agents and relies entirely on random playouts to estimate move quality.

Parallel Execution Performance

Performance was measured by timing how long each swarm takes to complete 3,000 dives in parallel across varying agent counts. Monte Carlo Tree Search operates as a single agent with no inter-agent coordination, so its performance is measured for one agent only. The three swarm methods — Ant Colony, Firefly, and Cuckoo Bird — rely on multiple agents working simultaneously, so performance is measured across a range of agent counts to show how they scale.

Important — unit difference: The Ant Colony performance chart (Figure 2b) is measured in hundredths of a second. All other algorithm charts are measured in tenths of a second. This order-of-magnitude difference reflects a substantial performance advantage for Ant Colony: even two Ant Colony agents outperform eight Monte Carlo agents in wall-clock time.
Figure 2a — Monte Carlo: avg. time (tenths/s) for 3,000 dives vs. agent count
Single-agent measurement only. Performance is bounded by independent random simulation overhead and does not benefit from inter-agent coordination.
Figure 2b — Ant Colony: avg. time (hundredths/s) for 3,000 dives vs. agent count
Note the unit difference from other charts. Pheromone-sharing reduces redundant exploration and yields dramatically faster convergence at scale.
Figure 2c — Firefly: avg. time (tenths/s) for 3,000 dives vs. agent count
Genetic mutation introduces coordination overhead but improves search quality over successive generations of agents.
Figure 2d — Cuckoo Bird: avg. time (tenths/s) for 3,000 dives vs. agent count
Similar profile to Firefly. Lévy-flight inspired position updates introduce slight step-size variance relative to standard genetic mutation.

Game Tree Exploration Maps

The following tree maps visualize how each algorithm explores the Othello game tree. Each node represents a distinct game state reached during search. Green nodes indicate paths leading toward higher win probability; red nodes indicate paths toward lower win probability. Color intensity reflects the degree of confidence the algorithm has assigned to that path based on its internal scoring mechanism.

Navigation: Left-click (or tap on mobile) a node to drill into its subtree. Right-click (or long-press) to return to the parent. The numeric prefix before each dash is an internal identifier required by the Google Charts API — only the value after the dash represents the Othello move being explored. Trees are displayed to approximately 10 levels, yielding 4,000–7,000 visible nodes from a total game-state space of approximately 1028. If a tree begins with a single root node, the agent played second and the first branch was determined by the opponent's opening move.

Monte Carlo Tree Search

The Monte Carlo tree map shows faded, diffuse coloring throughout early levels. This reflects the algorithm's use of random playouts to evaluate nodes — wins and losses are not differentiated until all simulations for a position are complete and a move is selected. Early-level nodes therefore appear roughly uniform in color intensity. Some definition emerges at deeper levels as a larger number of simulations converge on a particular move, but the pattern remains scattered compared to guided search algorithms.

Figure 3a — Monte Carlo Tree Search: game tree exploration map (~10 levels, 4,000–7,000 nodes)
Diffuse, approximately uniform coloring reflects random playout evaluation. Move quality is only resolved at the end of simulation, not during traversal.

Ant Colony Optimization

The Ant Colony tree map shows a markedly more targeted exploration pattern than Monte Carlo. Pheromone trails deposited on paths that lead to wins steer successive agents toward high-value subtrees from early in the search. This produces visibly stronger color definition at shallower depths. A residual probability of deviating from the pheromone trail prevents premature convergence and allows continued exploration of neighboring branches — observable as occasional outlier nodes diverging from the dominant color clusters.

Figure 3b — Ant Colony Optimization: game tree exploration map (~10 levels, 4,000–7,000 nodes)
Stronger color definition at shallow depths reflects pheromone-guided path selection. Outlier nodes indicate probabilistic off-trail exploration.

Firefly Algorithm

The Firefly tree map begins similarly to Monte Carlo — agents initialize with random positions in the search space, producing diffuse early-level coloring. Fireflies gravitate toward the brightest firefly in the swarm; brightness corresponds to a better position in the game tree. As agents converge on brighter (higher-fitness) neighbors, the search focuses on more promising subtrees. This fitness-based attraction accelerates color definition compared to Monte Carlo's purely random traversal, with the convergence signature becoming visible as the genetic algorithm progresses across generations.

Figure 3c — Firefly Algorithm: game tree exploration map (~10 levels, 4,000–7,000 nodes)
Initial random dispersal followed by fitness-driven convergence. Color definition sharpens faster than Monte Carlo as genetic attraction takes effect.

Cuckoo Bird Search

Cuckoo Bird exhibits a similar exploration profile to Firefly — random initial dispersal followed by genetic convergence toward winning strategies. The cuckoo bird mechanism works by laying "eggs" (candidate solutions) in other nests. Those that are discovered are either removed or the nest relocates; those that survive pass on a genetic algorithm toward the optimal path. This survival-and-inheritance mechanism produces a convergence pattern similar to Firefly but with additional variance introduced by the nest-relocation behavior, which can surface winning paths through wider jumps in the search space.

Figure 3d — Cuckoo Bird Search: game tree exploration map (~10 levels, 4,000–7,000 nodes)
Similar to Firefly but with Lévy-flight inspired step sizes. Occasional large jumps introduce additional exploration variance.

References & Links