add Dihedral groups

automata.py

@@ -512,11 +512,102 @@ class CyclicSampler(AutomatonSampler):
     return x, self.f(x)
 
 
+class DihedralSampler(AutomatonSampler):
+  def __init__(self, data_config):
+    super().__init__(data_config)
+
+    if 'n' not in data_config:
+      data_config['n'] = 5
+    self.n = data_config['n']
+
+    if 'label_type' not in data_config:
+      # Options: 'state', 'toggle', 'position'
+      data_config['label_type'] = 'state'
+    self.label_type = data_config['label_type']
+
+    """
+    2 actions: toggle, or shift by 1 position (direction determined by the toggle).
+    """
+    self.n_actions = 2
+    self.actions = {}
+    # shift all elements to the left (counter-clockwise) by 1
+    shift_idx = list(range(1, self.n)) + [0]
+    self.actions[0] = np.eye(self.n)[shift_idx]
+    # shift all elements to the right (closewise) by 1
+    shift_idx = [self.n-1] + list(range(self.n-1))
+    self.actions[1] = np.eye(self.n)[shift_idx]
+
+    self.__info__ = 'Dihedral group of order 2n, where n={self.n}:\n' \
+        +f"- Inputs: binary tokens:\n" \
+        + "      0 for toggle, i.e. change direction in the n-cycle;\n" \
+        + "      1 for drive,  i.e. move forward 1 step on the n-cycle.\n" \
+        + "- Labels: depending on the label_type.\n" \
+        + "- Config:\n" \
+        + "  - n (int): size of the 'cycle'; i.e. there are 2n states considering also the toggle bit.\n" \
+        + "  - label_type (str): choosing from the following options: \n" \
+        + "    - 'state': the state id, i.e. considering both toggle and position. \n" \
+        + "    - 'toggle': the toggle bit (in {0, 1}). \n" \
+        + "    - 'position': the position on the n-cycle (in [n]).\n" \
+        + self.__info__
+
+  def f_sequential(self, x):
+    # sanity check: sequential solution
+    position = np.arange(self.n)
+    states = []
+    toggle = 0 # i.e. parity
+    for action in x:
+      if action == 0:
+        # toggle direction
+        toggle = 1 - toggle
+      else:
+        # drive by 1
+        position = self.actions[toggle].dot(position)
+      states += (toggle, position[0]),
+    return states
+
+  def f(self, x):
+    # Parallel solution
+
+    # Get toggles: a parity task on the toggle bit
+    toggles = (x == 0).astype(np.int64)
+    toggle_status = np.cumsum(toggles) % 2
+
+    # Get positions: a directed modular counter
+    directions = (-1)**toggle_status
+    directed_drives = (x != 0).astype(np.int64) * directions
+    positions = np.cumsum(directed_drives) % self.n
+
+    if self.label_type == 'state':
+      labels = [self.get_state_label(each) for each in zip(toggle_status, positions)]
+      return np.array(labels).astype(np.int64)
+    elif self.label_type == 'toggle':
+      return toggle_status
+    elif self.label_type == 'positions':
+      return positions
+
+  def get_state_label(self, state):
+    """
+    toggle in {0,1}
+    position in [k]
+    """
+    toggle, position = state
+    label = self.n*toggle + position
+    return label
+
+  def sample(self):
+    T = self.sample_length()
+    x = self.np_rng.choice(range(self.n_actions), replace=True, size=T)
+
+    return x, self.f(x)
+
+
+
 
 dataset_map = {
   'abab': ABABSampler,
   'alternating': AlternatingSampler,
   'cyclic': CyclicSampler,
+  'dihedral': DihedralSampler,
   'flipflop': FlipFlopSampler,
   'gridworld': GridworldSampler,
   'parity': ParitySampler,