anchor.diff:          int const *b, size_t const *parts, size_t nparts, int *box,
           inform_error *err);
   ----
  +Black-box `l` time series (each of length `n`) with bases `b` into `nparts` time series
  +according to the partitioning scheme `parts`. The resulting time series and their bases are
  +stored in `box` and returned. The `box` must have enough space to store the black-boxed time
  +series AND the base of each of the resulting time series. That is `length(box) >= nparts * n
  ++ nparts`. If `box == NULL`, then exactly enough space is allocated for result.
  +
  +See <<partitioning-time-series>> for more information about partitioning schemes.
  +
  +*Examples:*
  +
  +_Example 1_: Black-box 4 time series (each of length 8) into a single time series
  +[source,c]
  +----
  +inform_error err = INFORM_SUCCESS;
  +int const series[32] = {
  +    0,1,1,0,1,0,0,1,
  +    1,0,0,1,1,0,1,0,
  +    0,0,0,1,1,1,0,0,
  +    1,0,1,0,1,1,1,0,
  +};
  +int b[4] = {2,2,2,2};
  +
  +size_t parts[4] = {0,0,0,0};
  +size_t nparts = 1; // max(parts) + 1
  +int *box = inform_black_box_parts(series, 4, 8, b, parts, nparts, NULL, &err);
  +assert(!err);
  +// box ~ {
  +//   5 8 9 6 15 3 5 8   # the time series for the 0st (and only) partition
  +//   16                 # the base of the time series
  +// }
  +free(box);
  +----
  +This could have been more simply using <<inform_black_box>>, but it is illustrative.
  +
  +_Example 2_: Black-box 4 time series (of length 8) into two time series using the
  +partitioning scheme `(0,1,1,0)`. That is, combine the 0th and 4th, and the 1st and 2nd.
  +[source,c]
  +----
  +inform_error err = INFORM_SUCCESS;
  +int const series[32] = {
  +    0,1,1,0,1,0,0,1,
  +    1,0,0,1,1,0,1,0,
  +    0,0,0,1,1,1,0,0,
  +    1,0,1,0,1,1,1,0,
  +};
  +int b[4] = {2,2,2,2};
  +
  +size_t parts[4] = {0,1,1,0};
  +size_t nparts = 2; // max(parts) + 1
  +int *box = inform_black_box_parts(series, 4, 8, b, parts, nparts, NULL, &err);
  +assert(!err);
  +// box ~ {
  +//   1 2 3 0 3 1 1 2    # the time series for the 0th partition
  +//   2 0 0 3 3 1 2 0    # the time series for the 1st partition
  +//   4 4                # the bases for the time series (in order)
  +// }
  +----
  +Note that the two time series each have a base of 4, and the bases are returned as the last
  +two elements of `box`.
  +
  +_Example 3_: Multivariate Mutual Information of Partitions
  +In this example, we compute the multivariate mutual information between 4 time series (each
  +of length 8) for all partitionings of the system (except the very first since that only
  +yields a single time series). That is, each partition is treated as a seperate variable and
  +the mutual information is computed between the partitioned variables.
  +[source,c]
  +----
  +#include <assert.h>
  +#include <inform/utilities.h>
  +#include <inform/mutual_info.h>
  +#include <stdio.h>
  +
  +int main()
  +{
  +        #define L 4
  +        #define N 8
  +
  +        inform_error err = INFORM_SUCCESS;
  +        int const series[L*N] = {
  +            0,1,1,0,1,0,0,1,
  +            1,0,0,1,1,0,1,0,
  +            0,0,0,1,1,1,0,0,
  +            1,0,1,0,1,1,1,0,
  +        };
  +        int b[L] = {2,2,2,2};
  +
  +        int box[L + L*N]; // make sure there's enough space for the finest partitioning
  +
  +        size_t *parts = inform_first_partitioning(L);
  +        size_t nparts = 1;
  +        while((nparts = inform_next_partitioning(parts, L)))
  +        {
  +            inform_black_box_parts(series, L, N, b, parts, nparts, box, &err);
  +            assert(!err);
  +
  +            int *bases = box + N*nparts;
  +            double mi = inform_mutual_info(box, nparts, N, bases, &err);
  +            assert(!err);
  +            printf("%0.3lf ", mi);
  +        }
  +        printf("\n");
  +}
  +----
  +prints
  +[source,plain]
  +----
  +0.610 0.954 1.217 1.220 1.000 1.311 1.360 1.311 1.000 1.360 1.360 1.360 1.406 1.409 
  +----
  +This example is tantalizingly close to an implementation of <<evidence-of-integration>>.
  +
   [horizontal]
   Headers::
       `inform/utilities.h`,
  
positive.code:         int const *b, size_t const *r, size_t const *s, int *box,
          inform_error *err);
  ----
  [horizontal]
  Headers::
      `inform/utilities.h`,
  
negative.code: 
  [[black-boxing-time-series]]
  == Black-Boxing Time Series
  It is often useful when analyzing complex systems to black-box components of the system.
  This process amounts to grouping components of the system and treating them as a single
  entity, without regard for its small-scale structure. As an example, consider you have two
  Boolean random variables stem:[X] and stem:[Y], and you observe time series of each
  simultaneously:
  [stem]
  ++++
  X:\ \{0,1,1,0,1,0,0,1\}\\
  Y:\ \{1,0,0,1,1,0,1,0\}
  ++++
  It may be worthwhile to consider these observations as observations of the joint
  variable stem:[(X,Y)]:
  [stem]
  ++++
  (X,Y):\ \{(0,1),(1,0),(1,0),(0,1),(1,1),(0,0),(0,1),(1,0)\}.
  ++++
  The joint observations can then be naturally encoded, for example, as base-4 states
  [stem]
  ++++
  (X,Y):\ \{1,2,2,1,3,0,1,2\}.
  ++++
  We refer this process of mapping the observations of stem:[X] and stem:[Y] to the encoded
  observations of stem:[(X,Y)] as black boxing. In this case, the black boxing procedure is
  performed in "space" (you might think of stem:[X] and stem:[Y] having locations in space).
  We may also black box in time. The canonical example of this is considering the
  stem:[k]-history of a random variable:
  [stem]
  ++++
  X:\       \{0,1,1,0,1,0,0,1\}\\
  X^{(2)}:\ \{((0,1),(1,1),(1,0),(0,1),(1,0),(0,0),(0,1)\},
  ++++
  and the observations of stem:[X^{(2)}] can be encoded as base-4 states:
  [stem]
  ++++
  X^{(2)}:\ \{(1,3,2,1,2,0,1\}.
  ++++
  
  We provide a basic black-boxing function that allows the user to black-box in both space and
  into the future and past of a collection of random variable <<inform_black_box>>. The
  <<inform_black_box_parts>> allows the user to black-box time series based on a
  <<partitioning-time-series,partitioning scheme>> (useful in the implementation of
  integration measures such as <<evidence-of-integration>>).
  
  ****
  [[inform_black_box]]
  