Something we deliberately haven't mentioned in the description above is the fact that the solver will halt whenever it is unable to separate some pieces from each other. In other words, the solver will attempt to separate all the pieces from each other and reports that no solution exists when it fails to do so. This is just what is required for most puzzles as you need to have single pieces as a starting point.
But there are a few puzzles for which you have groups of pieces that are movable but not separable. Here the piece groups come in handy. Probably some of you know how frustrating is is to not be able to analyse a puzzle just because there are 2 pieces that are supposed to not go apart. Not so with BURRTOOLS, as piece groups allow you to tell the disassembler that it is OK when it cannot separate a few pieces from one another.
Another usage of this function is if you have 2 pieces that require a rotation to come apart. BURRTOOLS will not be able to separate them, so you tell it that those pieces may stay together.
When the disassembler finds two or more pieces that cannot be taken apart it checks whether all of the pieces involved are in the same group. If that's the case it rests assured and continues. If the pieces are not in the same group, the disassembler aborts its work and reports that the assembly cannot be disassembled. This is the basic idea, but there is a bit more to it.
A special case is 'Group-0'. All pieces in this group need to be separated from each other. This group is included so that it is not necessary to place all the pieces into their own group when you want the puzzle to completely disassemble. Pieces automatically go into Group-0, so you don't need to take care of that. As a matter of fact you won't even find any reference to that Group-0 in the GUI.
On the other hand, when dealing with puzzles of which it is known that certain pieces (say Sa and Sb) can't be separated from each other, grouping these pieces will cause the solver to report a valid disassembly in which the grouped pieces are treated as a single piece. But it is not a rigid piece since the parts can freely (within certain boundaries) move with respect to each other.
{Sa, Sb}
Group-1 → Sa+Sb
This technique can also be used for pieces that may be entangled, in case one is searching for possible designs. If these pieces are indeed inseparable the solver will report so, but if they can be separated the solver may report the complete disassembly as well:
{Sa, Sb} ?
Group-1 → Sa+Sb
Result: {Sa, Sb} and/or Sa, Sb
Now for the hard part: pieces can be in more than one group . If you have e.g. a puzzle for which you know that piece Sa either interlocks with piece Sb or piece Sc and cannot be separated from it, but you don't know which of those (Sb or Sc) piece Sa is attached to, you can assign Group-1 to Sa+Sb and Group-2 to Sa+Sc :
{Sa, Sb} or {Sa, Sc}
Group-1 → Sa+Sb
Group-2 → Sa+Sc
This way the disassembler detects that both pieces are in Group-1 when Sa and Sb are inseparable and it finds that both pieces are in Group-2 when Sa and Sc cannot let go from each other. In both cases the solver will report a valid disassembly. However, if Sb and Sc are entangled the solver is not able to find a valid disassembly.
All instances of a multipiece need to have the same group assignment, but you can specify how many of these may be in a group maximally. That means you can make statements like 'not more than 3 pieces of Sn may be in Group-1':
Sa_1, Sa_2, ... Sa_n
Group-1 → Sa_1+Sa_2+Sa_3
Now how does it all come together? The disassembler starts to do its work. For each subproblem (a subproblem is a few pieces that it somehow has to get apart) it first checks if there is a unique group assignment for all pieces involved — i.e. all pieces have exactly one group assigned and that group is the same for all of them — it doesn't even attempt to disassemble that subproblem.
If this is not the case it tries to disassemble. In case of a failure it adds the pieces that are in this subproblem to a table of lists of pieces. Once done with the disassembler, the program comes back to this table and tries to assign a group to each of the lists of pieces. It just checks all possibilities by comparing the entries of the table with the group assignments made by the user. Whenever the sum of pieces (of a certain shape Sx) in such a 'problematic' table entry is bigger than the value the user designated to that particular piece, no valid group assignment can be made. If the program can find a valid assignment the puzzle is disassembled; if it cannot, the puzzle is assumed to be not disassemblable.
Assume we have a puzzle that contains (among others) 5 pieces of shape Sa. Three of them might go into Group-1 and another 2 into Group-2. There is also a piece Sb that might go into Group-1:
Group-1 → Sa_1+Sa_2+Sa_3+Sb
Group-2 → Sa_1+Sa_2
After the disassembler has run we have the following lists of pieces in the table:
Now the program has to assign Group-2 to the first set of pieces and Group-1 to the second set of pieces. Because otherwise piece Sb would be in the wrong group, it can only be in Group-1. If there would be another piece Sa in the first set it would not be possible to assign groups because we can only have two pieces Sa in Group-2. But it would be possible to have another piece Sa in the second set.
We have no idea how useful this might be in practice as most of the currently available puzzles require a complete disassembly. But who knows, maybe this feature will help in the design of lots of puzzles new and crazy ideas.