docs: def propagation_delay_network():
      """A version of the primary example from the IIT 3.0 paper with
      deterministic COPY gates on each connection. These copy gates essentially
      function as propagation delays on the signal between OR, AND and XOR gates
      from the original system.
  
      The current and previous states of the network are also selected to mimic
      the corresponding states from the IIT 3.0 paper.
  
      Diagram::
  
                                     +----------+
                  +------------------+ C (COPY) +<----------------+
                  v                  +----------+                 |
          +-------+-+                                           +-+-------+
          |         |                +----------+               |         |
          | A (OR)  +--------------->+ B (COPY) +-------------->+ D (XOR) |
          |         |                +----------+               |         |
          +-+-----+-+                                           +-+-----+-+
            |     ^                                               ^     |
            |     |                                               |     |
            |     |   +----------+                 +----------+   |     |
            |     +---+ H (COPY) +<----+     +---->+ F (COPY) +---+     |
            |         +----------+     |     |     +----------+         |
            |                          |     |                          |
            |                        +-+-----+-+                        |
            |         +----------+   |         |   +----------+         |
            +-------->+ I (COPY) +-->| G (AND) |<--+ E (COPY) +<--------+
                      +----------+   |         |   +----------+
                                     +---------+
  
      Connectivity matrix:
  
      +---+---+---+---+---+---+---+---+---+---+
      | . | A | B | C | D | E | F | G | H | I |
      +---+---+---+---+---+---+---+---+---+---+
      | A | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
      +---+---+---+---+---+---+---+---+---+---+
      | B | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | C | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | D | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | E | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | F | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | G | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | H | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
      | I | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
      +---+---+---+---+---+---+---+---+---+---+
  
      States:
  
      In the IIT 3.0 paper example, the previous state of the system has only the
      XOR gate ON. For the propagation delay network, this corresponds to a state
      of
      ``(0, 0, 0, 1, 0, 0, 0, 0, 0)``.
  
      The current state of the IIT 3.0 example has only the OR gate ON. By
      advancing the propagation delay system two time steps, the current state
      ``(1, 0, 0, 0, 0, 0, 0, 0, 0)`` is achieved, with corresponding previous
      state ``(0, 0, 1, 0, 1, 0, 0, 0, 0)``.
      """
      num_nodes = 9
      num_states = 2 ** num_nodes
  
      tpm = np.zeros((num_states, num_nodes))
  
      for previous_state_index, previous in enumerate(all_states(num_nodes)):
          current_state = [0 for i in range(num_nodes)]
          if previous[2] == 1 or previous[7] == 1:
              current_state[0] = 1
          if previous[0] == 1:
              current_state[1] = 1
              current_state[8] = 1
          if previous[3] == 1:
              current_state[2] = 1
              current_state[4] = 1
          if previous[1] == 1 ^ previous[5] == 1:
              current_state[3] = 1
          if previous[4] == 1 and previous[8] == 1:
              current_state[6] = 1
          if previous[6] == 1:
              current_state[5] = 1
              current_state[7] = 1
          tpm[previous_state_index, :] = current_state
  
      cm = np.array([[0, 1, 0, 0, 0, 0, 0, 0, 1],
                     [0, 0, 0, 1, 0, 0, 0, 0, 0],
                     [1, 0, 0, 0, 0, 0, 0, 0, 0],
                     [0, 0, 1, 0, 1, 0, 0, 0, 0],
                     [0, 0, 0, 0, 0, 0, 1, 0, 0],
                     [0, 0, 0, 1, 0, 0, 0, 0, 0],
                     [0, 0, 0, 0, 0, 1, 0, 1, 0],
                     [1, 0, 0, 0, 0, 0, 0, 0, 0],
                     [0, 0, 0, 0, 0, 0, 1, 0, 0]])
  
      return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])