Question: Is there a direct way to represent a remainder type in Alloy, rather than having to subtract the union all subtypes explicitly? For instance, in:

```
sig Test {}
one sig A, B extends Test {}    

```

I'd like to be able to refer to the expression `Test-(A+B)` via shorthand that doesn't need to change every time `Test` gets extended by a new sig. Although this would only be syntactic sugar, it could help me avoid mistakes when refactoring models.

Answer: 
You could introduce a set that represents the remainder as follows:

```
abstract sig Test {}
sig Remainder extends Test {}
one sig A, B extends Test {}

```

This will partition the set of `Test` atoms into three subsets, with `Remainder` being equivalent to `Test - (A + B)`. If you later decide to extend `Test` by adding `one sig C`, for example, `Remainder` will still give you the remainder set.
If you want the definition to hold whatever the new sigs extending `Test` are introduced, you can use Alloy's little known [meta capabilities](http://alloy.mit.edu/alloy/documentation/quickguide/meta.html), that allow you to iterate through sigs through a special set `sig$`.

E.g., you can do something like:

```
fun Remainder [] : set Test {
  {t : Test | all sig : sig$ | sig = Test$ || t not in sig.value}
}

```