automata.py

# Copyright 2020 The HuggingFace Datasets Authors.
# Copyright 2023 Bingbin Liu, Jordan Ash, Surbhi Goel, Akshay Krishnamurthy, and Cyril Zhang.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import csv
import json
import os
import itertools
import math
from sympy.combinatorics.permutations import Permutation

import datasets
import numpy as np
from copy import copy

# check python version
import sys
major, minor = sys.version_info[:2]
version = major + 0.1*minor
OLD_PY_VERSION = 1 if version < 3.8 else 0

_CITATION = """\
@article{liu2022transformers,
  title={Transformers learn shortcuts to automata},
  author={Liu, Bingbin and Ash, Jordan T and Goel, Surbhi and Krishnamurthy, Akshay and Zhang, Cyril},
  journal={arXiv preprint arXiv:2210.10749},
  year={2022}
}
"""

_DESCRIPTION = """\
Non-autoregressive automaton simulation datasets.
"""

_HOMEPAGE = ""

_LICENSE = ""

_URLS = {}

class AutomatonDataset(datasets.GeneratorBasedBuilder):
    """TODO: Short description of my dataset."""

    VERSION = datasets.Version("0.0.0")
    BUILDER_CONFIGS = []
    
    def __init__(self, config={}, **kwargs):
        super().__init__(**kwargs)
        
        """
        Set default configs
        """
        if 'name' not in config:
            config['name'] = 'parity'
        # if 'length' not in config: # sequence length
        #     config['length'] = 20
        if 'size' not in config: # number of sequences
            config['size'] = -1

        self.data_config = config
        self.automaton = dataset_map[config['name']](config)

    def _info(self):
        features = datasets.Features(
            {
                "input_ids": datasets.Sequence(datasets.Value("int32"), length=-1),
                "label_ids": datasets.Sequence(datasets.Value("int32"), length=-1)
            }
        )

        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "split": "train",
                },
            )
        ]

    def _generate_examples(self, split):
        for i in itertools.count(start=0):
            if i == self.data_config['size']:
                break
            x, y = self.automaton.sample()
            yield i, {
                "input_ids": x,
                "label_ids": y
            }

class Automaton:
    """
    This is a parent class that must be inherited.
    """
    def __init__(self, data_config):
        self.data_config = data_config

        if 'seed' in self.data_config:
            self.np_rng = np.random.default_rng(self.data_config['seed'])
        else:
            self.np_rng = np.random.default_rng()

        if 'length' not in data_config: # sequence length
            data_config['length'] = 20
        self.T = self.data_config['length']

        if 'random_length' not in data_config:
            data_config['random_length'] = 0
        self.random_length = data_config['random_length']

        self.__info__ = \
                "  - T (int): sequence length.\n" \
            + "  - random_length (int in {0, 1}): whether to randomly sample a length per sample.\n"

    def f(self, x):
        """
        Get output sequence given an input seq
        """
        raise NotImplementedError()

    def sample(self):
        raise NotImplementedError()

    def sample_length(self):
        if self.random_length:
            return self.np_rng.choice(range(1, self.T+1))
        return self.T

    def help(self):
            print(self.__info__)

class BinaryInputAutomaton(Automaton):
    """
    This is a parent class that must be inherited.
    Subclasses: ParityAutomaton, GridworldAutomaton, ABABAutomaton

    TODO: sample sequences with a given number of 1s
    """
    def __init__(self, data_config):
        super().__init__(data_config)

        if 'prob1' not in data_config:
            data_config['prob1'] = 0.5
        self.prob1 = data_config['prob1']
        self.__info__ = "  - prob1 (float in [0,1]): probability of token 1\n" \
            + self.__info__

    def f(self, x):
        raise NotImplementedError()

    def sample(self):
        T = self.sample_length()
        x = self.np_rng.binomial(1, self.prob1, size=T)
        return x, self.f(x)

class ParityAutomaton(BinaryInputAutomaton):
    def __init__(self, data_config):
        super().__init__(data_config)
        self.name = 'parity'

        self.__info__ = "Parity machine with 2 states: \n" \
            + "- Inputs: binary strings\n" \
            + "- Labels: binary strings of the partial parity\n" \
            + "- Config: \n" \
            + self.__info__

    def f(self, x):
        return np.cumsum(x) % 2

class GridworldAutomaton(BinaryInputAutomaton):
    """
    Note: gridworld currently doesn't include a no-op.
    """
    def __init__(self, data_config):
        super().__init__(data_config)

        if 'n' not in data_config:
            data_config['n'] = 9
        """
        NOTE: n is the number of states, and S is the id (0-indexing) of the rightmost state.
            i.e. the states are 0,1,2,...,S, where S=n-1.
        """
        self.n = data_config['n'] 
        self.S = self.n - 1

        if 'label_type' not in data_config:
            # Options: state, parity, boundary
            data_config['label_type'] = 'state'
        self.label_type = data_config['label_type']

        self.name = f'Grid{self.n}'

        self.__info__ = f"1d Gridworld of n={self.n} states:\n" \
            + "- Inputs: binary strings, i.e. move left(0) or right(1)\n" \
            + "- Labels: depending on 'label_type'. \n" \
            + "- Config: \n" \
            + "  - n (int): number of states; i.e. the states are 0,1,2,...,n-1.\n" \
            + "  - label_type (str): choosing from the following options:\n" \
            + "    - 'state' (default): the state id, i.e. 0 to n-1.\n" \
            + "    - 'parity': the state id mod 2.\n" \
            + "    - 'boundary': whether the current state is in {0, n-1} or not.\n" \
            + self.__info__

    def f(self, x):
        x = copy(x)
        x[x == 0] = -1
        if OLD_PY_VERSION:
            # NOTE: for Python 3.7 or below, accumulate doesn't have the 'initial' argument.
            x = np.concatenate([np.array([0]), x]).astype(np.int64)
            states = list(itertools.accumulate(x, lambda a,b: max(min(a+b, self.S), 0)))
            states = states[1:]
        else:
            states = list(itertools.accumulate(x, lambda a,b: max(min(a+b, self.S), 0), initial=0))
            states = states[1:] # remove the 1st entry with is the (meaningless) initial value 0
        return np.array(states).astype(np.int64)


class ABABAutomaton(BinaryInputAutomaton):
    def __init__(self, data_config):
        super().__init__(data_config)
        self.name = 'abab'

        if 'prob_abab_pos_sample' not in data_config:
            # The probability of having a positive sequence, i.e. 010101010101...
            data_config['prob_abab_pos_sample'] = 0.25
        if 'label_type' not in data_config:
            # Options: 'state', 'boundary'
            data_config['label_type'] = 'state'

        self.prob_abab_pos_sample = data_config['prob_abab_pos_sample']
        self.label_type = data_config['label_type']

        self.transition = np.array([
            [4, 1], # state 0
            [2, 4], # state 1
            [4, 3], # state 2
            [0, 4], # state 3
            [4, 4], # state 4
        ])

        self.__info__ = "abab: an automaton with 4 states + 1 absorbing state:\n" \
            + "- Inputs: binary strings\n" \
            + "- Labels: depending on 'label_type'.\n" \
            + "- Config:\n" \
            + "  - prob_abab_pos_sample (float in [0,1]): probability of having a 'positive' sequence, i.e. 01010101010...\n" \
            + "  - label_type (str): choosing from the following options:\n" \
            + "    - 'state' (default): the state id.\n" \
            + "    - 'boundary': whether the state is in state 3 (the states are 0,1,2,3).\n" \
            + self.__info__ 

    def f(self, x):
        labels = []
        curr_state = 3
        for each in x:
            curr_state = self.transition[curr_state, each]
            labels += curr_state,
        labels = np.array(labels).astype(np.int64)
        if self.label_type == 'boundary':
            labels = (labels == 3).astype(np.int64)
        return labels

    def sample(self):
        pos_sample = self.np_rng.random() < self.prob_abab_pos_sample
        if pos_sample:
            T = self.sample_length()
            x = [0,1,0,1] * (T//4)
            x += [0,1,0,1][:(T%4)]
            x = np.array(x)
            return x, self.f(x)
        else:
            return super().sample()


class AdderAutomaton(BinaryInputAutomaton):
    def __init__(self, data_config):
        super().__init__(data_config)
        self.name = 'addition'

        if 'n_addends' not in data_config:
            data_config['n_addends'] = 2
        self.n_addends = data_config['n_addends']
        self.addend_scales = np.array([2**i for i in range(self.n_addends)]).reshape(-1, 1)

        if 'label_type' not in data_config:
            data_config['label_type'] = 'state'
        self.label_type = data_config['label_type']

        self.__info__ = f'Adder of n={self.n_addends} binary numbers:\n' \
            +f"- Inputs: {self.n_addends} binary numbers, encoded as the int for the {self.n_addends}-bit binary number.\n" \
            + "- Labels: depending on the label_type.\n" \
            + "- Config:\n" \
            + "  - n_addends (int): number of binary numbers to be added; default as 2.\n" \
            + "  - label_type (str): choosing from the following options: \n" \
            +f"    - 'state': the state id, i.e. the int for the base-{self.n_addends} int corresponding to the number (carry, digit). \n" \
            +f"    - 'digit': the current output base-{self.n_addends} digit, without the carry. \n" \
            + "    - 'position': the current carry bit.\n" \
            + self.__info__

    def f(self, x):
        outputs, carries = [], []
        carry = 0
        T = x.shape[-1]
        for i in range(T):
            curr_sum = x[:, i].sum() + carry
            # NOTE: 'mod n_addends' makes sure the carry is binary
            output, carry = curr_sum % self.n_addends, curr_sum // self.n_addends
            outputs += output,
            carries += carry,
        outputs = np.array(outputs).astype(np.int64)
        carries = np.array(carries).astype(np.int64)

        if self.label_type == 'state':
            return outputs + self.n_addends*carries
        elif self.label_type ==  'digit':
            return outputs
        elif self.label_type == 'carry':
            return carries

    def sample_addend(self, T):
        a = self.np_rng.binomial(1, self.prob1, size=T)
        return a

    def sample(self):
        T = self.sample_length()
        x = np.stack([self.sample_addend(T) for _ in range(self.n_addends)])
        # Pad the most significant bit (rightmost position, i.e. we're reversing the number) with 0 to handle the potential carry
        pad = np.zeros((self.n_addends, 1))
        x = np.concatenate([x, pad], 1)

        x_encode = (self.addend_scales * x).sum(0)
        return x_encode, self.f(x)

class FlipFlopAutomaton(Automaton):
    def __init__(self, data_config):
        super().__init__(data_config)
        self.name = 'flipflop'

        if 'n' not in data_config:
            data_config['n'] = 2
        
        self.n_states = data_config['n'] 
        self.n_actions = self.n_states + 1
        self.transition = np.array([list(range(self.n_actions))] + [[i+1]*self.n_actions for i in range(self.n_states)]).T

        self.__info__ = f"Flipflop with n={self.n_states} states:\n" \
            +f"- Inputs: tokens are either 0 (read) or 1:{self.n} (write).\n" \
            + "- Labels: the state id.\n" \
            + "- Config:\n" \
            + "  - n (int): number of write states; i.e. the states are 1,2,...,n, plus a default start state 0.\n" \
            + self.__info__ 

    def f(self, x):
        state, states = 0, []
        for action_id in x:
            state = self.transition[state, action_id]
            states += state,
        return np.array(states)

    def sample(self):
        T = self.sample_length()
        rand = self.np_rng.uniform(size=T)
        nonzero_pos = (rand < 0.5).astype(np.int64)
        writes = self.np_rng.choice(range(1, self.n_states+1), size=T)
        x = writes * nonzero_pos
        return x, self.f(x)


class PermutationAutomaton(Automaton):
    """
    This is a parent class that must be inherited.
    Subclasses: SymmetricAutomaton, AlternatingAutomaton
    """
    def __init__(self, data_config):
        super().__init__(data_config)

        if 'n' not in data_config:
            data_config['n'] = 5
        if 'label_type' not in data_config:
            # Options: 'state', 'first_chair'
            data_config['label_type'] = 'state'
        
        self.n = data_config['n'] # the symmetric group Sn
        self.label_type = data_config['label_type']

        self.__info__ = \
            "  - label_type (str): choosing from the following options:\n" \
            + "    - 'state' (default): the state id.\n" \
            + "    - 'first_chair': the element in the first position of the permutation.\n" \
            + "          e.g. if the current permutation is [2,1,4,3], then 'first_chair' is 2.\n" \
            + self.__info__

    def get_state_label(self, state):
        enc = self.state_encode(state)
        return self.state_label_map[enc]

    def f(self, x):
        curr_state = np.arange(self.n)
        labels = []
        for action_id in x:
            curr_state = self.actions[action_id].dot(curr_state)

            if self.label_type == 'state':
                    labels += self.get_state_label(curr_state),
            elif self.label_type == 'first_chair':
                    labels += curr_state[0],
        return np.array(labels)

    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)


class SymmetricAutomaton(PermutationAutomaton):
    """
    TODO: add options for labels as functions of states
    - parity (whether a state is even): this may need packages (e.g. Permutation from sympy)
    - position / toggle: for S3 ~ D6, we can add labels for substructures as in Dihedral groups.
    """
    def __init__(self, data_config):
        super().__init__(data_config)

        self.name = f'S{self.n}'

        """
        Get states
        """
        self.state_encode = lambda state: ''.join([str(int(each)) for each in state])
        self.state_label_map = {}
        for si, state in enumerate(itertools.permutations(range(self.n))):
            enc = self.state_encode(state)
            self.state_label_map[enc] = si

        """
        Get actions (3 defaults: id, shift-by-1, swap-first-two)
        """
        if 'n_actions' not in data_config:
            data_config['n_actions'] = 3
        self.n_actions = data_config['n_actions']
        self.actions = {0: np.eye(self.n)}
        # shift all elements to the right by 1
        shift_idx = list(range(1, self.n)) + [0]
        self.actions[1] = np.eye(self.n)[shift_idx]
        # swap the first 2 elements
        shift_idx = [1, 0] + list(range(2, self.n))
        self.actions[2] = np.eye(self.n)[shift_idx]

        if self.n_actions > 3:
            # add permutations in the order given by itertools.permutations
            self.all_permutations = list(itertools.permutations(range(self.n)))[1:]
            cnt = 2
            for each in self.all_permutations:
                action = np.eye(self.n)[list(each)]
                if np.linalg.norm(action - self.actions[0]) == 0:
                    continue
                elif np.linalg.norm(action - self.actions[1]) == 0:
                    continue
                self.actions[cnt] = action
                cnt += 1
                if cnt == self.n_actions: break

        self.__info__ = f"Symmetric group on n={self.n} objects:\n" \
            +f"- Inputs: tokens are either 0 (no-op), or 1:{self.n_actions} (corresponding to {self.n_actions} permutations).\n" \
            + "- Labels: depending on 'label_type'.\n" \
            + "- Config:\n" \
            + "  - n (int): number of objects, i.e. there are n! states.\n" \
            + "  - n_actions (int): number of permutations to include in the generator set;\n" \
            + "        the ordering is given by itertools.permutations, and the first 'n_actions' permutations will be included.\n" \
            + self.__info__ 


class AlternatingAutomaton(PermutationAutomaton):
    """
    TODO: other choices of generators (currently using (12x))?
    """
    def __init__(self, data_config):
        super().__init__(data_config)

        self.name = f'A{self.n}'

        """
        Get states
        """
        self.state_label_map = {}
        self.state_encode = lambda state: ''.join([str(int(each)) for each in state])
        cnt = 0
        for si, state in enumerate(itertools.permutations(range(self.n))):
            if not Permutation(state).is_even:
                    continue
            enc = self.state_encode(state)
            self.state_label_map[enc] = cnt
            cnt += 1

        """
        Get actions: all 3 cycles of the form (12x)
        """
        self.actions = {0: np.eye(self.n)}
        for idx in range(2, self.n):
            # (1, 2, idx) 
            shift_idx = list(range(self.n))
            shift_idx[0],shift_idx[1], shift_idx[idx] = shift_idx[1], shift_idx[idx], shift_idx[0]
            self.actions[idx-1] = np.eye(self.n)[shift_idx]
        self.n_actions = len(self.actions)

        self.__info__ = f"Alternating group on n={self.n} objects:\n" \
            +f"- Inputs: tokens from 0 to n-3, corresponding to all 3-cycles of the form (12x).\n" \
            + "- Labels: depending on 'label_type'.\n" \
            + "- Config:\n" \
            + "  - n (int): number of objects, i.e. there are n!/2 states.\n" \
            + self.__info__ 


class CyclicAutomaton(Automaton):
    def __init__(self, data_config):
        super().__init__(data_config)

        if 'n' not in data_config:
            data_config['n'] = 5
        self.n = data_config['n']

        """
        Get actions: shift by i positions, for i = 0 to n_actions-1
        """
        if 'n_actions' not in data_config:
            data_config['n_actions'] = 2
        self.n_actions = data_config['n_actions']
        shift_idx = list(range(1, self.n)) + [0]
        self.actions = {}
        for i in range(self.n_actions):
            shift_idx = list(range(i, self.n)) + list(range(0, i))
            self.actions[i] = np.eye(self.n)[shift_idx]

        self.__info__ = 'Cyclic group of n={self.n} states:\n' \
            +f"- Inputs: tokens from 0 to n_actions-1\n" \
            + "- Labels: the current state.\n" \
            + "- Config:\n" \
            + "  - n (int): number of states.\n" \
            + "  - n_actions (int): number of actions/generators, which are 0, 1, ..., n_actions-1.\n" \
            + self.__info__

    def f(self, x):
        return np.cumsum(x) % self.n

    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)


class DihedralAutomaton(Automaton):
    def __init__(self, data_config):
        super().__init__(data_config)

        if 'n' not in data_config:
            data_config['n'] = 4
        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)


class QuaternionAutomaton(Automaton):
    def __init__(self, data_config):
        super().__init__(data_config)

        self.n_states = 8 # {-1, 1} x {1, i, j, k}
        self.n_actions = 4  # {1, i, j, k}
        self.transition_pos = [
            0, 1, 2, 3,
            1, 4, 3, 6,
            2, 7, 4, 1,
            3, 2, 5, 4,
        ]
        self.transition_neg = [(each+4)%8 for each in self.transition_pos]
        self.transition = np.array(self.transition_pos + self.transition_neg)
        self.transition = self.transition.reshape(-1, 4)

        self.__info__ = "Quaternion group:\n" \
            + "- Inputs: tokens in {0,1,2,3}, corresponding to 1,i,j,k.\n" \
            + "- Labels: the state id; 8 states in total: 2 signs ({-1,1}) x 4 values ({1,i,j,k}).\n" \
            + "- Config:\n" \
            + self.__info__

    def f(self, x):
        curr_state = 0
        states = []
        for action_id in x:
            curr_state = self.transition[curr_state, action_id]
            states += curr_state,
        return np.array(states).astype(np.int64)

    def sample(self):
        T = self.sample_length()
        x = self.np_rng.choice(range(self.n_actions), size=T)
        return x, self.f(x)

class PermutationResetAutomaton(Automaton):
    def __init__(self, data_config):
        super().__init__(data_config)

        self.n = data_config['n']
        self.generators = data_config['generators']
        self.perm_probs = data_config['perm_probs']
        if type(self.generators[0]) is str:
            self.generators = [ np.array(list(map(int, list(g)))) for g in self.generators ]

        self.n_states = math.factorial(self.n) # states = permutations; maybe rename
        self.n_generators = len(self.generators) # actions = generators
        self.n_actions = self.n_states + self.n_generators # 1 reset symbol per state, 1 apply symbol per generator

        self.init_state = np.arange(self.n) # identity permutation
        
        # lookup tables
        self.int2perm = list(map(np.array, itertools.permutations(range(self.n))))
        self.perm2int = {tuple(p):i for i,p in enumerate(self.int2perm)}
        
        # interval lengths
        T = self.sample_length()
        self.lags = [1]
        while self.lags[-1]*2 < T:
            self.lags.append(self.lags[-1]*2)

    def f(self, x):
        curr_state = self.init_state
        states = []
        for action_id in x:
            if action_id >= self.n_states:
                curr_state = self.generators[action_id - self.n_states][curr_state]
            else:
                curr_state = self.int2perm[action_id]
            states.append(self.perm2int[tuple(curr_state)])
        return np.array(states, dtype=np.int64)

    def sample(self):
        T = self.sample_length()
        x = self.np_rng.choice(range(self.n_generators), p=self.perm_probs, size=T) + self.n_states
        
        i = 0
        while i < T:
            x[i] = self.np_rng.choice(range(self.n_states))
            i += self.np_rng.choice(self.lags)
        
        return x, self.f(x)



dataset_map = {
    'abab': ABABAutomaton,
    'add': AdderAutomaton,
    'alternating': AlternatingAutomaton,
    'cyclic': CyclicAutomaton,
    'dihedral': DihedralAutomaton,
    'flipflop': FlipFlopAutomaton,
    'gridworld': GridworldAutomaton,
    'parity': ParityAutomaton,
    'quaternion': QuaternionAutomaton,
    'symmetric': SymmetricAutomaton,
    'permutation_reset': PermutationResetAutomaton
    # TODO: add Dyck
}