Here's the key step in my program. Given the current MachineState I want to find the best Move.

getStateMachine.getNextStates(state, getRole)

getNextStates returns a Map from Moves to a list of MachineStates:  Map[Move, List[MachineState]]

[I've listed the types as Java rather than Scala. I convert the result to Scala. But this is what I start with. It's essentially the same either way.] 

My algorithm looks at the list of States for each Move. It finds the worst one, and assigns that value to the Move. (That's the minimizing step.) Then it picks the best Move assuming those worst values. (That's the maximizing step.) This works no matter how many players are in the game. if there is only one player, the list of states to which each Move maps has only one element. So it's the worst State. But the code works the same way.

Adding alphaBeta to this has nothing to do with the number of players. It just cuts off the minimizing and maximizing steps early before all the Moves are examined (if maximizing) and before all the States in the StateList are examined (if minimizing). Of course, if there's only one State in the StateList, Alpha-cutoff never gets a chance to do anything.

This is different from the way Bryan's code seemed to work. We only looked at it briefly, but it looked like he did things a bit differently.

Right. In Tic-Tac-Toe each move leads to only one state. A problem with the general approach (the one sketched above) is that it takes two minimax cycles for each one cycle of a known two-player minimax. The first one is the maximizer's move. The associated minimizer looks at the single state that move leads to. Then the maximizer maximizes its noop move (obviously no choice). But that move leads to all the states the opponent can make. So instead of a maximizer move and a minimizer move, there's a maximizer move, a minimizer step on a single state, a maximizer step on a single (noop) move, and a minimizer move on a list of states. 

You are right that in deterministic (no dice) turn-based multi-player games each move leads to exactly one state. But that's not how GGP is organized. It assumes that there are no turns, that on each round every player makes a move -- even though the move may be noop. So at every round, my move can lead to any of a number of states depending on what the other players do. You are right that if this is essentially a turn-based game, then all the other players (whether there is one other or more than one other) play noop. So each move leads to exactly one state. But that's not the general case.

In Bidding Tic-Tac-Toe the players place bids at the same time.

Here's the game: http://www.ggp.org/view/all/games/base/biddingTicTacToe/v0/