├── CHANGELOG.md ├── test └── Main.hs ├── .gitignore ├── data ├── anbn_progs.json ├── an_bm_cnm_progs.json ├── an_b2n_progs.json ├── qa │ └── an_bn_cn_progs.json ├── wcwr_progs.json └── anbn_plus_progs.json ├── rules ├── anbn_plus.json ├── anbn.json ├── an_b2n.json ├── an_bm_cnm.json ├── qa │ └── an_bn_cn.json ├── wcwr.json ├── palindrome.json └── palindrome_2.json ├── src ├── Data │ └── List │ │ └── Extra.hs ├── FSM.hs ├── QA.hs ├── PDA.hs └── Automata.hs ├── haskell.cabal ├── python └── hf_palindrome.py ├── README.md └── app └── Main.hs /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Revision history for neurallambda-data 2 | -------------------------------------------------------------------------------- /test/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | main :: IO () 4 | main = putStrLn "Test suite not yet implemented." 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Python 2 | .env/ 3 | venv/ 4 | .pytest_cache/ 5 | __pycache__/ 6 | lib/ 7 | *.egg-info/ 8 | 9 | 10 | # Haskell 11 | dist-newstyle/ 12 | 13 | # Misc 14 | old/ 15 | doc/own_notes.md -------------------------------------------------------------------------------- /data/anbn_progs.json: -------------------------------------------------------------------------------- 1 | {"sentences":["^$","^aaaabbbb$","^aaabbb$","^aabb$","^aa|bb$","^ab$","^a|b$"],"spec":{"machine":"PDA","rules":[[["^","INITIAL",null],["Q1",["push","$"]]],[["$","Q1","$"],["ACCEPT","pop"]],[["a","Q1","$"],["Q1",["push","A"]]],[["a","Q1","A"],["Q1",["push","A"]]],[["|","Q1","A"],["Q2","nullop"]],[["b","Q1","A"],["Q2","pop"]],[["b","Q2","A"],["Q2","pop"]],[["$","Q2","$"],["ACCEPT","pop"]]],"symbols":["^","a","b","x","y","|","$"]}} -------------------------------------------------------------------------------- /rules/anbn_plus.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar (a^nb^n)+, where n >= 1", 4 | "symbols": ["^", "a", "b", "c", "d", "e", "$"], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | [["$", "Q3", "$"], ["ACCEPT", "pop"]], 8 | 9 | [["a", "Q1", "$"], ["Q2", ["push", "A"]]], 10 | [["a", "Q2", "A"], ["Q2", ["push", "A"]]], 11 | 12 | [["b", "Q2", "A"], ["Q3", "pop"]], 13 | [["b", "Q3", "A"], ["Q3", "pop"]], 14 | 15 | [["a", "Q3", "$"], ["Q2", ["push", "A"]]] 16 | ] 17 | } 18 | -------------------------------------------------------------------------------- /rules/anbn.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar `a^nb^n or a^n|b^n`", 4 | "symbols": ["^", "a", "b", "x", "y", "|", "$"], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | [["$", "Q1", "$"], ["ACCEPT", "pop"]], 8 | [["a", "Q1", "$"], ["Q1", ["push", "A"]]], 9 | [["a", "Q1", "A"], ["Q1", ["push", "A"]]], 10 | [["|", "Q1", "A"], ["Q2", "nullop"]], 11 | [["b", "Q1", "A"], ["Q2", "pop"]], 12 | [["b", "Q2", "A"], ["Q2", "pop"]], 13 | [["$", "Q2", "$"], ["ACCEPT", "pop"]] 14 | ] 15 | } 16 | -------------------------------------------------------------------------------- /rules/an_b2n.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar `a^nb^(2n)`. Demonstrates empty strings to offer something like 'dynamic time' computation - when an 'a' is seen, it needs to push twice.", 4 | "symbols": ["^", "a", "b", "x", "y", "$", ""], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | [["$", "Q3", "$"], ["ACCEPT", "pop"]], 8 | [["a", "Q1", "$"], ["Q2", ["push", "X"]]], 9 | [["a", "Q1", "X"], ["Q2", ["push", "X"]]], 10 | [["", "Q2", "X"], ["Q1", ["push", "X"]]], 11 | [["b", "Q1", "X"], ["Q3", "pop"]], 12 | [["b", "Q3", "X"], ["Q3", "pop"]] 13 | ] 14 | } 15 | -------------------------------------------------------------------------------- /rules/an_bm_cnm.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar `a^nb^mc^(n+m)`", 4 | "symbols": ["^", "a", "b", "c", "x", "y", "$"], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | [["$", "Q3", "$"], ["ACCEPT", "pop"]], 8 | [["a", "Q1", "$"], ["Q1", ["push", "A"]]], 9 | [["a", "Q1", "A"], ["Q1", ["push", "A"]]], 10 | [["b", "Q1", "A"], ["Q2", ["push", "B"]]], 11 | [["b", "Q2", "A"], ["Q2", ["push", "B"]]], 12 | [["b", "Q2", "B"], ["Q2", ["push", "B"]]], 13 | [["c", "Q2", "B"], ["Q3", "pop"]], 14 | [["c", "Q3", "A"], ["Q3", "pop"]], 15 | [["c", "Q3", "B"], ["Q3", "pop"]] 16 | ] 17 | } 18 | -------------------------------------------------------------------------------- /rules/qa/an_bn_cn.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "QA", 3 | "description": "Queue Automata recognizable grammar `a^nb^n", 4 | "symbols": ["^", "a", "b", "c", "$", ""], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", "NULLOP"]], 7 | 8 | [["a", "Q1", "ANY"], ["Q1", ["ENQR", "A"]]], 9 | 10 | [["b", "Q1", "A"], ["START_B", "DEQL"]], 11 | [["", "START_B", "ANY"], ["Q2", ["ENQR", "#"]]], 12 | [["b", "Q2", "A"], ["CONT_B", "DEQL"]], 13 | [["", "CONT_B", "ANY"], ["Q2", ["ENQR", "B"]]], 14 | 15 | [["c", "Q2", "#"], ["START_C", "DEQL"]], 16 | [["", "START_C", "ANY"], ["Q3", ["ENQR", "#"]]], 17 | [["c", "Q3", "B"], ["Q3", "DEQL"]], 18 | 19 | [["$", "Q3", "#"], ["ACCEPT", "NULLOP"]], 20 | [["$", "Q3", null], ["ACCEPT", "NULLOP"]] 21 | ] 22 | } 23 | -------------------------------------------------------------------------------- /rules/wcwr.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar `wcw^R`, where `w` is a string of a's and b's, and ^R means the reverse of that string.", 4 | "symbols": ["^", "a", "b", "c", "$"], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | [["a", "Q1", "$"], ["Q1", ["push", "a"]]], 8 | [["b", "Q1", "$"], ["Q1", ["push", "b"]]], 9 | [["a", "Q1", "a"], ["Q1", ["push", "a"]]], 10 | [["a", "Q1", "b"], ["Q1", ["push", "a"]]], 11 | [["b", "Q1", "a"], ["Q1", ["push", "b"]]], 12 | [["b", "Q1", "b"], ["Q1", ["push", "b"]]], 13 | [["c", "Q1", "a"], ["Q2", "nullop"]], 14 | [["c", "Q1", "b"], ["Q2", "nullop"]], 15 | [["a", "Q2", "a"], ["Q2", "pop"]], 16 | [["b", "Q2", "b"], ["Q2", "pop"]], 17 | [["$", "Q2", "$"], ["ACCEPT", "pop"]] 18 | ] 19 | } 20 | -------------------------------------------------------------------------------- /rules/palindrome.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar for palindromes separated by '|' using the entire lowercase alphabet", 4 | "symbols": ["^", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "|", "$"], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | 8 | [["$", "Q2", "$"], ["ACCEPT", "pop"]], 9 | 10 | [["a", "Q1", "ANY"], ["Q1", ["push", "a"]]], 11 | [["b", "Q1", "ANY"], ["Q1", ["push", "b"]]], 12 | [["c", "Q1", "ANY"], ["Q1", ["push", "c"]]], 13 | [["d", "Q1", "ANY"], ["Q1", ["push", "d"]]], 14 | [["e", "Q1", "ANY"], ["Q1", ["push", "e"]]], 15 | 16 | [["|", "Q1", "ANY"], ["Q2", "nullop"]], 17 | 18 | [["a", "Q2", "a"], ["Q2", "pop"]], 19 | [["b", "Q2", "b"], ["Q2", "pop"]], 20 | [["c", "Q2", "c"], ["Q2", "pop"]], 21 | [["d", "Q2", "d"], ["Q2", "pop"]], 22 | [["e", "Q2", "e"], ["Q2", "pop"]] 23 | 24 | 25 | 26 | ] 27 | } 28 | -------------------------------------------------------------------------------- /rules/palindrome_2.json: -------------------------------------------------------------------------------- 1 | { 2 | "machine": "PDA", 3 | "description": "PDA recognizable grammar for palindromes separated by '|' using the entire lowercase alphabet", 4 | "symbols": ["^", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "|", "$"], 5 | "rules": [ 6 | [["^", "INITIAL", null], ["Q1", ["push", "$"]]], 7 | 8 | [["$", "Q2", "$"], ["ACCEPT", "pop"]], 9 | 10 | [["f", "Q1", "ANY"], ["Q1", ["push", "f"]]], 11 | [["g", "Q1", "ANY"], ["Q1", ["push", "g"]]], 12 | [["h", "Q1", "ANY"], ["Q1", ["push", "h"]]], 13 | [["i", "Q1", "ANY"], ["Q1", ["push", "i"]]], 14 | [["j", "Q1", "ANY"], ["Q1", ["push", "j"]]], 15 | 16 | [["|", "Q1", "ANY"], ["Q2", "nullop"]], 17 | 18 | [["f", "Q2", "f"], ["Q2", "pop"]], 19 | [["g", "Q2", "g"], ["Q2", "pop"]], 20 | [["h", "Q2", "h"], ["Q2", "pop"]], 21 | [["i", "Q2", "i"], ["Q2", "pop"]], 22 | [["j", "Q2", "j"], ["Q2", "pop"]] 23 | 24 | 25 | 26 | ] 27 | } 28 | -------------------------------------------------------------------------------- /src/Data/List/Extra.hs: -------------------------------------------------------------------------------- 1 | -- {-# LANGUAGE FlexibleInstances #-} 2 | {-# LANGUAGE OverloadedStrings #-} 3 | 4 | module Data.List.Extra where 5 | 6 | import Data.Aeson (Value(..), FromJSON, parseJSON, ToJSON (..)) 7 | import Data.List (foldl') 8 | 9 | -------------------------------------------------- 10 | -- * MatchAny: a helper class to allow searching lists with wildcards 11 | 12 | -- | A "wildcard" match, useful for doing lookups in lists where the element might 13 | -- contain `Any a`. 14 | data Any a = A !a | Any 15 | deriving (Eq, Ord, Show) 16 | 17 | instance (FromJSON a) => FromJSON (Any a) where 18 | parseJSON (String "ANY") = pure Any 19 | parseJSON x = A <$> parseJSON x 20 | 21 | instance (ToJSON a) => ToJSON (Any a) where 22 | toJSON Any = String "ANY" 23 | toJSON (A x) = toJSON x 24 | 25 | -- | Search a list where elements can have wildcard values and stop after the first match 26 | lookupMatchAny :: MatchAny a => a -> [a] -> Maybe a 27 | lookupMatchAny key xs = foldl' go (const Nothing) xs key 28 | where 29 | -- fold w continuation allows early return 30 | go cont x k 31 | | matchAny k x = Just x 32 | | otherwise = cont k 33 | 34 | class MatchAny a where 35 | matchAny :: a -> a -> Bool 36 | 37 | instance Eq a => MatchAny (Any a) where 38 | matchAny (A x) (A y) = x == y 39 | matchAny Any _ = True 40 | matchAny _ Any = True 41 | 42 | instance (MatchAny a, MatchAny b) => MatchAny (a, b) where 43 | matchAny (a1, b1) (a2, b2) = matchAny a1 a2 && matchAny b1 b2 44 | 45 | instance (MatchAny a, MatchAny b, MatchAny c) => MatchAny (a, b, c) where 46 | matchAny (a1, b1, c1) (a2, b2, c2) = matchAny a1 a2 && matchAny b1 b2 && matchAny c1 c2 47 | 48 | instance (Eq a) => MatchAny (Maybe (Any a)) where 49 | matchAny _ (Just Any) = True 50 | matchAny (Just Any) _ = True 51 | matchAny (Just a) (Just b) = matchAny a b 52 | matchAny Nothing Nothing = True 53 | matchAny _ _ = False 54 | -------------------------------------------------------------------------------- /haskell.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 3.4 2 | name: automata 3 | 4 | -- The package version. 5 | -- See the Haskell package versioning policy (PVP) for standards 6 | -- guiding when and how versions should be incremented. 7 | -- https://pvp.haskell.org 8 | -- PVP summary: +-+------- breaking API changes 9 | -- | | +----- non-breaking API additions 10 | -- | | | +--- code changes with no API change 11 | version: 0.1.0.0 12 | homepage: https://github.com/neurallambda/automata 13 | license: NONE 14 | author: neurallambda 15 | maintainer: neurallambda@proton.me 16 | category: Data 17 | build-type: Simple 18 | extra-doc-files: CHANGELOG.md 19 | common warnings 20 | ghc-options: -Wall 21 | 22 | executable automata 23 | import: warnings 24 | main-is: Main.hs 25 | ghc-options: -O2 -threaded -rtsopts -with-rtsopts=-N 26 | build-depends: 27 | base ^>=4.17.2.1, 28 | mtl, 29 | containers, 30 | random, 31 | aeson, 32 | bytestring, 33 | vector, 34 | text, 35 | optparse-applicative, 36 | automata 37 | 38 | -- exe source files. 39 | hs-source-dirs: app 40 | default-language: GHC2021 41 | 42 | library 43 | import: warnings 44 | exposed-modules: 45 | Data.List.Extra, 46 | Automata, 47 | FSM, 48 | PDA, 49 | QA 50 | 51 | build-depends: 52 | base ^>=4.17.2.1, 53 | mtl, 54 | containers, 55 | random, 56 | bytestring, 57 | vector, 58 | text, 59 | pqueue, 60 | aeson 61 | 62 | hs-source-dirs: src 63 | default-language: GHC2021 64 | 65 | test-suite haskell-test 66 | -- Import common warning flags. 67 | import: warnings 68 | default-language: GHC2021 69 | type: exitcode-stdio-1.0 70 | 71 | -- test source files 72 | hs-source-dirs: test 73 | main-is: Main.hs 74 | build-depends: 75 | base ^>=4.17.2.1, 76 | automata 77 | -------------------------------------------------------------------------------- /data/an_bm_cnm_progs.json: -------------------------------------------------------------------------------- 1 | {"sentences":["^abcc$","^aabccc$","^abbccc$","^aaabcccc$","^aabbcccc$","^abbbcccc$","^aaaabccccc$","^aaabbccccc$","^aabbbccccc$","^abbbbccccc$","^aaaaabcccccc$","^aaaabbcccccc$","^aaabbbcccccc$","^aabbbbcccccc$","^abbbbbcccccc$","^aaaaaabccccccc$","^aaaaabbccccccc$","^aaaabbbccccccc$","^aaabbbbccccccc$","^aabbbbbccccccc$","^abbbbbbccccccc$","^aaaaaaabcccccccc$","^aaaaaabbcccccccc$","^aaaaabbbcccccccc$","^aaaabbbbcccccccc$","^aaabbbbbcccccccc$","^aabbbbbbcccccccc$","^abbbbbbbcccccccc$","^aaaaaaaabccccccccc$","^aaaaaaabbccccccccc$","^aaaaaabbbccccccccc$","^aaaaabbbbccccccccc$","^aaaabbbbbccccccccc$","^aaabbbbbbccccccccc$","^aabbbbbbbccccccccc$","^abbbbbbbbccccccccc$","^aaaaaaaaabcccccccccc$","^aaaaaaaabbcccccccccc$","^aaaaaaabbbcccccccccc$","^aaaaaabbbbcccccccccc$","^aaaaabbbbbcccccccccc$","^aaaabbbbbbcccccccccc$","^aaabbbbbbbcccccccccc$","^aabbbbbbbbcccccccccc$","^abbbbbbbbbcccccccccc$","^aaaaaaaaaabccccccccccc$","^aaaaaaaaabbccccccccccc$","^aaaaaaaabbbccccccccccc$","^aaaaaaabbbbccccccccccc$","^aaaaaabbbbbccccccccccc$","^aaaaabbbbbbccccccccccc$","^aaaabbbbbbbccccccccccc$","^aaabbbbbbbbccccccccccc$","^aabbbbbbbbbccccccccccc$","^abbbbbbbbbbccccccccccc$","^aaaaaaaaaaabcccccccccccc$","^aaaaaaaaaabbcccccccccccc$","^aaaaaaaaabbbcccccccccccc$","^aaaaaaaabbbbcccccccccccc$","^aaaaaaabbbbbcccccccccccc$","^aaaaaabbbbbbcccccccccccc$","^aaaaabbbbbbbcccccccccccc$","^aaaabbbbbbbbcccccccccccc$","^aaabbbbbbbbbcccccccccccc$","^aabbbbbbbbbbcccccccccccc$","^abbbbbbbbbbbcccccccccccc$","^aaaaaaaaaaaabccccccccccccc$","^aaaaaaaaaaabbccccccccccccc$","^aaaaaaaaaabbbccccccccccccc$","^aaaaaaaaabbbbccccccccccccc$","^aaaaaaaabbbbbccccccccccccc$","^aaaaaaabbbbbbccccccccccccc$","^aaaaaabbbbbbbccccccccccccc$","^aaaaabbbbbbbbccccccccccccc$","^aaaabbbbbbbbbccccccccccccc$","^aaabbbbbbbbbbccccccccccccc$","^aabbbbbbbbbbbccccccccccccc$","^abbbbbbbbbbbbccccccccccccc$","^aaaaaaaaaaaaabcccccccccccccc$","^aaaaaaaaaaaabbcccccccccccccc$","^aaaaaaaaaaabbbcccccccccccccc$","^aaaaaaaaaabbbbcccccccccccccc$","^aaaaaaaaabbbbbcccccccccccccc$","^aaaaaaaabbbbbbcccccccccccccc$","^aaaaaaabbbbbbbcccccccccccccc$","^aaaaaabbbbbbbbcccccccccccccc$","^aaaaabbbbbbbbbcccccccccccccc$","^aaaabbbbbbbbbbcccccccccccccc$","^aaabbbbbbbbbbbcccccccccccccc$","^aabbbbbbbbbbbbcccccccccccccc$","^abbbbbbbbbbbbbcccccccccccccc$","^aaaaaaaaaaaaaabccccccccccccccc$","^aaaaaaaaaaaaabbccccccccccccccc$","^aaaaaaaaaaaabbbccccccccccccccc$","^aaaaaaaaaaabbbbccccccccccccccc$","^aaaaaaaaaabbbbbccccccccccccccc$","^aaaaaaaaabbbbbbccccccccccccccc$","^aaaaaaaabbbbbbbccccccccccccccc$","^aaaaaaabbbbbbbbccccccccccccccc$","^aaaaaabbbbbbbbbccccccccccccccc$"],"spec":{"machine":"PDA","rules":[[["^","INITIAL",null],["Q1",["push","$"]]],[["$","Q3","$"],["ACCEPT","pop"]],[["a","Q1","$"],["Q1",["push","A"]]],[["a","Q1","A"],["Q1",["push","A"]]],[["b","Q1","A"],["Q2",["push","B"]]],[["b","Q2","A"],["Q2",["push","B"]]],[["b","Q2","B"],["Q2",["push","B"]]],[["c","Q2","B"],["Q3","pop"]],[["c","Q3","A"],["Q3","pop"]],[["c","Q3","B"],["Q3","pop"]]],"symbols":["^","a","b","c","x","y","$"]}} -------------------------------------------------------------------------------- /src/FSM.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeFamilies #-} 2 | {-# LANGUAGE OverloadedStrings #-} 3 | {-# LANGUAGE OverloadedLists #-} 4 | 5 | module FSM where 6 | 7 | import Automata (generateLsIDDFS, Machine(..), generateLsDFS, Exit, generateLsPQ, generateLsRandom, generateLsRandomizedID) 8 | import Data.List.Extra (Any(..), MatchAny(..)) 9 | import Data.Maybe (mapMaybe) 10 | import Data.Aeson 11 | ( Value(Array, String), 12 | ToJSON(toJSON), 13 | FromJSON(parseJSON), 14 | withArray ) 15 | import Data.Aeson.Types (Parser) 16 | import qualified Data.Vector as Vector 17 | import qualified Data.Text as T 18 | import Automata (Exit(..)) 19 | import qualified Data.Set as Set 20 | import Data.Text (Text) 21 | 22 | fsmscore :: [L FSM Symbol State] -> S FSM Symbol State -> Float 23 | fsmscore xs state = fromIntegral $ length xs 24 | 25 | fsmString :: 26 | Int -- max string length 27 | -> Int -- max steps to deepen before giving up 28 | -> Int -- number of strings to return 29 | -> [(L FSM Symbol State, R FSM Symbol State)] 30 | -> (S FSM Symbol State -> Exit) -- halting states 31 | -> [Symbol] -- input symbols (to possibly stand in for Any) 32 | -> S FSM Symbol State -- initial state 33 | -> IO [T.Text] 34 | fsmString maxLen maxDeepening nStrings transitions haltStates syms initState = do 35 | let f (FSML (A a) _) = Just a 36 | f (FSML Any _) = Nothing 37 | let randomFactor = 0.02 -- for randomizedID how many of possible branches to explore 38 | strs <- generateLsRandomizedID maxLen nStrings randomFactor transitions haltStates syms initState 39 | -- strs <- generateLsRandom maxLen nStrings transitions haltStates syms initState 40 | -- strs <- pure . take nStrings $ generateLsPQ maxLen fsmscore transitions haltStates syms initState 41 | -- strs <- pure . take nStrings $ generateLsIDDFS maxLen maxDeepening transitions haltStates syms initState 42 | -- strs <- pure . take nStrings $ generateLsDFS maxDeepening transitions haltStates syms initState 43 | pure . Set.toList . Set.fromList $ map T.concat $ mapMaybe (mapM f) strs 44 | 45 | data FSM 46 | 47 | instance (ToJSON a 48 | , FromJSON a 49 | , ToJSON state 50 | , FromJSON state 51 | ) 52 | => Machine FSM a state where 53 | data L FSM a state = FSML (Any a) (Any state) deriving (Show, Ord, Eq) 54 | data R FSM a state = FSMR state deriving (Show, Ord, Eq) 55 | data S FSM a state = FSMS state deriving (Show, Ord, Eq) 56 | 57 | action (FSMR newState) (FSMS _) = FSMS newState 58 | 59 | mkL a (FSMS st) = FSML (A a) (A st) 60 | 61 | instance (Eq state, Eq a) => MatchAny (L FSM a state) where 62 | matchAny (FSML x0 x1) (FSML y0 y1) = matchAny (x0, x1) (y0, y1) 63 | 64 | 65 | ---------- 66 | -- * JSON 67 | 68 | parseAt :: FromJSON a => Vector.Vector Value -> Int -> Parser a 69 | parseAt arr i = parseJSON (arr Vector.! i) 70 | 71 | instance (FromJSON a, FromJSON state) => FromJSON (L FSM a state) where 72 | parseJSON = withArray "(L FSM a state)" $ \arr -> do 73 | FSML 74 | <$> (arr `parseAt` 0) -- input 75 | <*> (arr `parseAt` 1) -- fromState 76 | 77 | instance (ToJSON a, ToJSON state) => ToJSON (L FSM a state) where 78 | toJSON (FSML input fromState) = Array $ Vector.fromList 79 | [ toJSON input 80 | , toJSON fromState 81 | ] 82 | 83 | instance (FromJSON state) => FromJSON (R FSM a state) where 84 | parseJSON = withArray "(R FSM a state)" $ \arr -> do 85 | FSMR 86 | <$> (arr `parseAt` 0) -- toState 87 | 88 | instance (ToJSON state) => ToJSON (R FSM a state) where 89 | toJSON (FSMR toState) = Array $ Vector.fromList [ toJSON toState ] 90 | 91 | type State = T.Text 92 | type Symbol = T.Text 93 | 94 | initialState :: S FSM Symbol State 95 | initialState = FSMS "INITIAL" 96 | 97 | halt :: S FSM a Text -> Exit 98 | halt (FSMS "REJECT") = Error 99 | halt (FSMS "ACCEPT") = Success 100 | halt _ = Running 101 | -------------------------------------------------------------------------------- /python/hf_palindrome.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Prepare the `palindrome` dataset as an HF dataset 4 | 5 | ''' 6 | 7 | import os 8 | import json 9 | from datasets import Dataset, DatasetDict, concatenate_datasets 10 | import random 11 | 12 | N_SWAPS = 2 13 | MAX_LENGTH = 25 # max sentence length (after each char has been separated with space) 14 | HF_TOKEN = os.getenv('HF_TOKEN') 15 | 16 | TRAIN_N = 5000 # truncate datasets 17 | TEST_N = 100 # truncate datasets 18 | 19 | train_path = os.path.expanduser("~/_/neurallambda-automata/data/palindrome_progs.json") 20 | test_path = os.path.expanduser("~/_/neurallambda-automata/data/palindrome_2_progs.json") 21 | 22 | 23 | ########## 24 | # Util 25 | 26 | # Make out-of-class versions of palindromes 27 | def swap_chars(x, n, give_up_after=10): 28 | '''Swap characters in x, n times. Ensure the result is different than the 29 | input, or else return None.''' 30 | for _ in range(give_up_after): # try 10 times before giving up 31 | cs = list(x) 32 | for _ in range(n): 33 | i, j = random.sample(range(len(x)), 2) 34 | cs[i], cs[j] = cs[j], cs[i] 35 | out = ''.join(cs) 36 | if not out == x: 37 | return out 38 | return None 39 | 40 | 41 | ########## 42 | # 43 | 44 | def load_data(path): 45 | # load data 46 | with open(path, 'r') as f: 47 | data = json.load(f) 48 | 49 | raw_sentences = data['sentences'] 50 | spec = data['spec'] # dict_keys(['machine', 'rules', 'symbols']) 51 | 52 | noised_sentences = map(lambda x: swap_chars(x, n=N_SWAPS), raw_sentences) 53 | 54 | data_list = ( 55 | [{'text': x, 'label': 'T'} for x in raw_sentences if x is not None] + 56 | [{'text': x, 'label': 'F'} for x in noised_sentences if x is not None] 57 | ) 58 | 59 | # separate chars with spaces (into separate tokens) 60 | for x in data_list: 61 | x['text'] = ' '.join(list(x['text'])) 62 | 63 | dataset = Dataset.from_list(data_list) 64 | 65 | # truncate long sentences 66 | dataset = dataset.filter(lambda x: len(x["text"]) <= MAX_LENGTH) 67 | return dataset 68 | 69 | dataset_dict = DatasetDict({ 70 | 'train': load_data(train_path), 71 | 'test': load_data(test_path), 72 | }) 73 | 74 | # truncate test set 75 | random_indices = random.sample( 76 | range(len(dataset_dict['test'])), 77 | min(TEST_N if TEST_N else float('inf'), len(dataset_dict['test']))) 78 | dataset_dict['test'] = dataset_dict['test'].select(random_indices) 79 | 80 | random_indices = random.sample( 81 | range(len(dataset_dict['train'])), 82 | min(TRAIN_N if TRAIN_N else float('inf'), len(dataset_dict['train']))) 83 | dataset_dict['train'] = dataset_dict['train'].select(random_indices) 84 | 85 | # randomize the order of examples in each split 86 | dataset_dict = dataset_dict.shuffle(seed=42) 87 | 88 | # sort by length 89 | dataset_dict = dataset_dict.map(lambda x: {'length': len(x['text'])}) 90 | dataset_dict = dataset_dict.sort('length') 91 | dataset_dict = dataset_dict.remove_columns('length') 92 | 93 | # Sample 94 | print(f"Examples from Training: {len(dataset_dict['train'])} total rows") 95 | for example in dataset_dict['train']['text'][:5] + dataset_dict['train']['text'][-5:]: 96 | print(example) 97 | 98 | print(f"Examples from Testing: {len(dataset_dict['test'])}") 99 | for example in dataset_dict['test']['text'][:5] + dataset_dict['test']['text'][-5:]: 100 | print(example) 101 | 102 | 103 | # save the dataset to disk 104 | dataset_dict.save_to_disk('palindrome_dataset') 105 | 106 | print('pushing to huggingface') 107 | if HF_TOKEN is not None: 108 | resp = input('pushing data up to huggingface, ok?') 109 | if resp == 'y' or resp == 'yes': 110 | dataset_dict.push_to_hub('neurallambda/automata_palindrome', token=HF_TOKEN) 111 | else: 112 | print('permission denied') 113 | else: 114 | print('HF_TOKEN not found in env, skipping pushing to hub') 115 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Automata 2 | 3 | Follow on X 4 | 5 |    6 | 7 | Join Discord 8 | 9 |

10 | 11 | A tool for generating synthetic data that results from grammars writen for various automata (eg Finite State Machines, Pushdown Automata and Turing Machines). Grammars are saved as `json`, and you can build 1000 valid strings that match this grammar with: 12 | 13 | ```sh 14 | $ automata -i my_grammar.json -o output.json -n 1000 15 | aXb 16 | aaXbb 17 | aaaXbbb 18 | aaaaXbbbb 19 | ... 20 | ``` 21 | 22 | This is intended to help train the [`neurallambda`](https://github.com/neurallambda/neurallambda) project and confer reasoning ability to LLMs. 23 | 24 | ## Layout 25 | 26 | ```sh 27 | rules/ # example grammars 28 | data/ # data generated from those rules 29 | app/ # the CLI tool 30 | src/ # the supporting library 31 | ``` 32 | 33 | ## PDA example 34 | 35 | There's a grammar that looks like `a^nXb^n`, which is any string like `aaXbb` and `aaaaaXbbbbb`, where the same number of `b`s follow the same number of `a`s (and in the middle is `X`). You cannot write a regex for this (try defining that `n`), but you can write a pushdown automata that recognizes it. A transition function involves the following mappings between states (slightly simplified, see [`rules/anbn.json`](rules/anbn.json)): 36 | 37 | ``` 38 | { 39 | "machine": "PDA", 40 | "symbols": ["a", "b", "X"], 41 | "rules": [ 42 | # input symbol 43 | | # current state # resulting state 44 | | | # top of stack | # stack operation 45 | | | | | | 46 | [["a", "INITIAL", "A"], ["Q1", ["push", "A"]]], 47 | [["X", "Q1", "A"], ["Q2", "nullop"]], 48 | [["b", "Q2", "A"], ["Q2", "pop"]], 49 | ] 50 | } 51 | ``` 52 | 53 | Notice there are exactly 5 items in each transition rule for a PDA, and they come as 3 on the Left and 2 on the Right. These represent the left and right hand side of the relation that defines a PDA. In english, the rules say: 54 | 55 | 1. given an input symbol 'a', if I'm in the state Q1, and the top of the stack is "A", let's transition by staying in state Q1, and push an "A" on the stack. 56 | 57 | 2. if the input symbol is 'X', we know we need to transition to 'Q2', which implies we're gonna start looking for 'b's. 58 | 59 | 3. each time we see a 'b', pop the stack. This is how we can ensure that the same number of pushes and pops happen, ie, same number of 'b's and 'a's. 60 | 61 | Again, see [`rules/anbn.json`](rules/anbn.json)) for the full implementation. 62 | 63 | 64 | ## About the tool 65 | 66 | 67 | Haskell was chosen because it produces trustworthy code, especially in this department of computer languages. When I next face a funky loss while training some NN, I want to minimize the risk that the data was improperly generated. 68 | 69 | A simple `typeclass` is offered to allow the easy (if you speak haskell) specification of new Automata: 70 | 71 | ```haskell 72 | class Machine m a (s :: Type) where 73 | data L m a s -- ^ the Left side of a delta function/relation 74 | data R m a s -- ^ the Right side of a delta function/relation 75 | data S m a s -- ^ the State of the Machine 76 | -- | update the state (ex apply stack ops) 77 | action :: R m a s -> S m a s -> S m a s 78 | -- | build an input (ex add a peek at the top of a stack) 79 | mkL :: a -> S m a s -> L m a s 80 | ``` 81 | 82 | There are probably infinite things that are Turing Complete formulations of Turing Machines, and I hope to represent some in this library: 83 | 84 | - The classic tape model 85 | - An FSM with 1 queue 86 | - An FSM with 2 stacks 87 | - An FSM with multiple queues 88 | - An FSM with multiple tapes 89 | - Something (i'm not sure what) with addressable memory 90 | 91 | 92 | ## "I just got here and have no clue what you're doing" 93 | 94 | That's because I'm bad at explaining things. 95 | 96 | I have a project called [`neurallambda`](https://github.com/neurallambda/neurallambda) where I hope to build architectures that augment traditional architectures with reasoning ability. Checkout the readme if you're skeptical, it explains why I don't think the current batch of AI has reasoning. 97 | 98 | So for experimenting on these architectures I need data. [Current datasets](https://github.com/neurallambda/awesome-reasoning) are largely around Natural Language, and probably GPT generated (therefore their reasoning is circumspect). It'll be easier to train on super simple perfectly trustworthy datasets, therefore why not generate them ourselves? That's where this lib comes in. 99 | -------------------------------------------------------------------------------- /src/QA.hs: -------------------------------------------------------------------------------- 1 | {- 2 | 3 | Queue Automaton(ish) 4 | 5 | Instead of a normal FIFO queue, this automata has access to both sides of the 6 | queue (IE, it's a Sequence). 7 | 8 | Also, a Queue Automaton usually treats its queue as its input, but this version 9 | works like the PDA where it separates Input, Frame, and, Queue 10 | 11 | -} 12 | 13 | {-# LANGUAGE TypeFamilies #-} 14 | {-# LANGUAGE OverloadedStrings #-} 15 | {-# LANGUAGE OverloadedLists #-} 16 | {-# OPTIONS_GHC -Wno-incomplete-patterns #-} 17 | 18 | module QA where 19 | 20 | import Automata (generateLsIDDFS, Machine(..), viewl, viewr, generateLsDFS, Exit, generateLsPQ, generateLsRandom, generateLsRandomizedID) 21 | import Data.Sequence ( Seq, (|>), Seq(..), (<|) ) 22 | import qualified Data.Sequence as Seq 23 | import Data.List.Extra (Any(..), MatchAny(..)) 24 | import Data.Maybe (mapMaybe) 25 | import Data.Aeson 26 | ( Value(Array, String), 27 | ToJSON(toJSON), 28 | FromJSON(parseJSON), 29 | withArray ) 30 | import Data.Aeson.Types (Parser) 31 | import qualified Data.Vector as Vector 32 | import qualified Data.Text as T 33 | import Automata (Exit(..)) 34 | import qualified Data.Set as Set 35 | import Data.Text (Text) 36 | 37 | dropRight :: Int -> Seq a -> Seq a 38 | dropRight n s = Seq.take (Seq.length s - n) s 39 | 40 | qascore :: Seq (L QA Symbol Frame) -> S QA Symbol Frame -> Float 41 | qascore xs frame = fromIntegral $ Seq.length xs 42 | 43 | qaString :: 44 | Int -- max string length 45 | -> Int -- max steps to deepen before giving up 46 | -> Int -- number of strings to return 47 | -> [(L QA Symbol Frame, R QA Symbol Frame)] 48 | 49 | -> (S QA Symbol Frame -> Exit) -- halting states 50 | -> [Symbol] -- input symbols (to possibly stand in for Any) 51 | -> S QA Symbol Frame -- initial state 52 | -> IO [T.Text] 53 | qaString maxLen maxDeepening nStrings transitions haltStates syms initState = do 54 | let f (QAL (A a) _ _) = Just a 55 | f (QAL Any _ _) = Nothing 56 | 57 | -- let randomFactor = 0.2 -- for randomizedID how many of possible branches to explore 58 | -- strs <- generateLsRandomizedID maxLen nStrings randomFactor transitions haltStates syms initState 59 | -- strs <- generateLsRandom maxLen nStrings transitions haltStates syms initState 60 | -- strs <- pure . take nStrings $ generateLsPQ maxLen qascore transitions haltStates syms initState 61 | strs <- pure . take nStrings $ generateLsIDDFS maxLen maxDeepening transitions haltStates syms initState 62 | -- strs <- pure . take nStrings $ generateLsDFS maxDeepening transitions haltStates syms initState 63 | pure . Set.toList . Set.fromList $ map T.concat $ mapMaybe (mapM f) strs 64 | 65 | data QA 66 | 67 | data QAOp a = 68 | EnqL !a 69 | | EnqR !a 70 | | DeqL 71 | | DeqR 72 | | Nullop 73 | deriving (Eq, Ord, Show) 74 | 75 | instance FromJSON a => FromJSON (QAOp a) where 76 | parseJSON (String "NULLOP") = return Nullop 77 | parseJSON (String "DEQL") = return DeqL 78 | parseJSON (String "DEQR") = return DeqR 79 | parseJSON (Array arr) = do 80 | op <- parseJSON (arr Vector.! 0) 81 | case op of 82 | "ENQL" -> EnqL <$> parseJSON (arr Vector.! 1) 83 | "ENQR" -> EnqR <$> parseJSON (arr Vector.! 1) 84 | _ -> fail $ "Invalid QAOp operation: " ++ T.unpack op 85 | parseJSON invalid = fail $ "Invalid QAOp JSON: " ++ show invalid 86 | 87 | instance ToJSON a => ToJSON (QAOp a) where 88 | toJSON DeqL = String "DEQL" 89 | toJSON Nullop = String "NULLOP" 90 | toJSON DeqR = String "DEQR" 91 | toJSON (EnqL a) = Array $ Vector.fromList [String "ENQL", toJSON a] 92 | toJSON (EnqR a) = Array $ Vector.fromList [String "ENQR", toJSON a] 93 | 94 | 95 | type Symbol = T.Text 96 | type State = T.Text 97 | type Queue = T.Text 98 | type Frame = (State, Queue) 99 | 100 | instance (ToJSON a 101 | , FromJSON a 102 | , ToJSON state 103 | , FromJSON state 104 | , ToJSON queue 105 | , FromJSON queue 106 | ) 107 | => Machine QA a (state, queue) where 108 | data L QA a (state, queue) = QAL (Any a) (Any state) (Maybe (Any queue)) deriving (Show, Ord, Eq) 109 | data R QA a (state, queue) = QAR state (QAOp queue) deriving (Show, Ord, Eq) 110 | data S QA a (state, queue) = QAS state (Data.Sequence.Seq queue) deriving (Show, Ord, Eq) 111 | 112 | action (QAR newState Nullop) (QAS _ q) = QAS newState q 113 | action (QAR newState DeqL) (QAS _ q) = QAS newState (Seq.drop 1 q) 114 | action (QAR newState DeqR) (QAS _ q) = QAS newState (dropRight 1 q) 115 | action (QAR newState (EnqL x)) (QAS _ q) = QAS newState (x <| q) 116 | action (QAR newState (EnqR x)) (QAS _ q) = QAS newState (q |> x) 117 | 118 | mkL a (QAS st q) = QAL (A a) (A st) (A <$> viewl q) 119 | 120 | instance (Eq state, Eq queue, Eq a) => MatchAny (L QA a (state, queue)) where 121 | matchAny (QAL x0 x1 x2) (QAL y0 y1 y2) = matchAny (x0, x1, x2) (y0, y1, y2) 122 | 123 | -- * JSON 124 | 125 | parseAt :: FromJSON a => Vector.Vector Value -> Int -> Parser a 126 | parseAt arr i = parseJSON (arr Vector.! i) 127 | 128 | instance (FromJSON a, FromJSON state, FromJSON queue) => FromJSON (L QA a (state, queue)) where 129 | parseJSON = withArray "(L QA a frame)" $ \arr -> do 130 | QAL 131 | <$> (arr `parseAt` 0) -- input 132 | <*> (arr `parseAt` 1) -- fromState 133 | <*> (arr `parseAt` 2) -- queueHead 134 | 135 | instance (ToJSON a, ToJSON state, ToJSON queue) => ToJSON (L QA a (state, queue)) where 136 | toJSON (QAL input fromState queueHead) = Array $ Vector.fromList 137 | [ toJSON input 138 | , toJSON fromState 139 | , toJSON queueHead 140 | ] 141 | 142 | instance (FromJSON state, FromJSON queue, FromJSON a) => FromJSON (R QA a (state, queue)) where 143 | parseJSON = withArray "(R QA a frame)" $ \arr -> do 144 | QAR 145 | <$> (arr `parseAt` 0) -- toState 146 | <*> (arr `parseAt` 1) -- action 147 | 148 | instance (ToJSON state, ToJSON queue, ToJSON a) => ToJSON (R QA a (state, queue)) where 149 | toJSON (QAR toState act) = Array $ Vector.fromList [ toJSON toState, toJSON act] 150 | 151 | 152 | initialState :: S QA Symbol Frame 153 | initialState = QAS "INITIAL" Seq.empty 154 | 155 | halt :: S QA a Frame -> Exit 156 | halt (QAS "REJECT" _) = Error 157 | halt (QAS "ACCEPT" _) = Success 158 | halt _ = Running 159 | -------------------------------------------------------------------------------- /src/PDA.hs: -------------------------------------------------------------------------------- 1 | {- 2 | 3 | Generate sentences in given grammars. 4 | 5 | PDA Special Symbols 6 | 7 | Left of relation: 8 | ANY to match any {symbol, state, stack} 9 | 10 | State: 11 | INITIAL 12 | ACCEPT 13 | REJECT 14 | 15 | 16 | Pushdown Automaton (PDA): 7-tuple (State, Σ, Γ, δ, q₀, Z₀, F), where: 17 | - State : states 18 | - Σ : input symbols 19 | - Γ : stack symbols (the stack alphabet) 20 | - δ : State × (Σ ∪ {ε}) × Γ → P(State × Γ*) is the transition function 21 | - q₀ ∈ State 22 | - Z₀ ∈ Γ is the initial stack symbol 23 | - F ⊆ State is the set of accepting/final states 24 | 25 | -} 26 | 27 | {-# LANGUAGE TypeFamilies #-} 28 | {-# LANGUAGE OverloadedStrings #-} 29 | {-# LANGUAGE OverloadedLists #-} 30 | 31 | module PDA where 32 | 33 | import Automata (generateLsIDDFS, Machine(..), viewl, generateLsDFS, Exit, generateLsPQ, generateLsRandom, generateLsRandomizedID) 34 | import Data.Sequence ( Seq, (<|), Seq(..) ) 35 | import qualified Data.Sequence as Seq 36 | import Data.List.Extra (Any(..), MatchAny(..)) 37 | import Data.Maybe (mapMaybe) 38 | import Data.Aeson 39 | ( Value(Array, String), 40 | ToJSON(toJSON), 41 | FromJSON(parseJSON), 42 | withArray ) 43 | import Data.Aeson.Types (Parser) 44 | import qualified Data.Vector as Vector 45 | import qualified Data.Text as T 46 | import Automata (Exit(..)) 47 | import qualified Data.Set as Set 48 | 49 | pqscore :: Seq (L PDA Symbol Frame) -> S PDA Symbol Frame -> Float 50 | pqscore xs state = fromIntegral $ Seq.length xs 51 | 52 | pdaString :: 53 | Int -- max string length 54 | -> Int -- max steps to deepen before giving up 55 | -> Int -- number of strings to return 56 | -> [(L PDA Symbol Frame, R PDA Symbol Frame)] 57 | -> (S PDA Symbol Frame -> Exit) -- halting states 58 | -> [Symbol] -- input symbols (to possibly stand in for Any) 59 | -> S PDA Symbol Frame -- initial state 60 | -> IO [T.Text] 61 | pdaString maxLen maxDeepening nStrings transitions haltStates syms initState = do 62 | let f (PDAL (A a) _ _) = Just a 63 | f (PDAL Any _ _) = Nothing 64 | -- let randomFactor = 0.02 -- for randomizedID how many of possible branches to explore 65 | -- strs <- generateLsRandomizedID maxLen nStrings randomFactor transitions haltStates syms initState 66 | strs <- generateLsRandom maxLen nStrings transitions haltStates syms initState 67 | -- strs <- pure . take nStrings $ generateLsPQ maxLen pqscore transitions haltStates syms initState 68 | -- strs <- pure . take nStrings $ generateLsIDDFS maxLen maxDeepening transitions haltStates syms initState 69 | -- strs <- pure . take nStrings $ generateLsDFS maxDeepening transitions haltStates syms initState 70 | pure . Set.toList . Set.fromList $ map T.concat $ mapMaybe (mapM f) strs 71 | 72 | 73 | data PDA 74 | 75 | data PDAOp stack = 76 | NullOp 77 | | Push !stack 78 | | Pop 79 | deriving (Eq, Ord, Show) 80 | 81 | instance FromJSON stack => FromJSON (PDAOp stack) where 82 | parseJSON (String "pop") = return Pop 83 | parseJSON (String "nullop") = return NullOp 84 | parseJSON (Array arr) = do 85 | op <- parseJSON (arr Vector.! 0) 86 | case op of 87 | "push" -> do 88 | stack <- parseJSON (arr Vector.! 1) 89 | return (Push stack) 90 | _ -> fail $ "Invalid PDAOp operation: " ++ T.unpack op 91 | parseJSON invalid = fail $ "Invalid PDAOp JSON: " ++ show invalid 92 | 93 | instance ToJSON stack => ToJSON (PDAOp stack) where 94 | toJSON NullOp = String "nullop" 95 | toJSON Pop = String "pop" 96 | toJSON (Push stack) = Array $ Vector.fromList [String "push", toJSON stack] 97 | 98 | instance (ToJSON a 99 | , FromJSON a 100 | , ToJSON state 101 | , FromJSON state 102 | , ToJSON stack 103 | , FromJSON stack 104 | ) 105 | => Machine PDA a (state, stack) where 106 | data L PDA a (state, stack) = PDAL (Any a) (Any state) (Maybe (Any stack)) deriving (Show, Ord, Eq) 107 | data R PDA a (state, stack) = PDAR state (PDAOp stack) deriving (Show, Ord, Eq) 108 | data S PDA a (state, stack) = PDAS state (Data.Sequence.Seq stack) deriving (Show, Ord, Eq) 109 | 110 | action (PDAR newState NullOp) (PDAS _ stack) = PDAS newState stack 111 | action (PDAR newState (Push x)) (PDAS _ stack) = PDAS newState (x Data.Sequence.<| stack) 112 | action (PDAR newState Pop) (PDAS _ stack) = PDAS newState (Seq.drop 1 stack) 113 | 114 | mkL a (PDAS st sk) = PDAL (A a) (A st) (A <$> viewl sk) 115 | 116 | instance (Eq state, Eq stack, Eq a) => MatchAny (L PDA a (state, stack)) where 117 | matchAny (PDAL x0 x1 x2) (PDAL y0 y1 y2) = matchAny (x0, x1, x2) (y0, y1, y2) 118 | 119 | 120 | ---------- 121 | -- * JSON 122 | 123 | parseAt :: FromJSON a => Vector.Vector Value -> Int -> Parser a 124 | parseAt arr i = parseJSON (arr Vector.! i) 125 | 126 | instance (FromJSON a, FromJSON state, FromJSON stack) => FromJSON (L PDA a (state, stack)) where 127 | parseJSON = withArray "(L PDA a (state, stack))" $ \arr -> do 128 | PDAL 129 | <$> (arr `parseAt` 0) -- input 130 | <*> (arr `parseAt` 1) -- fromState 131 | <*> (arr `parseAt` 2) -- stackTop 132 | 133 | instance (ToJSON a, ToJSON state, ToJSON stack) => ToJSON (L PDA a (state, stack)) where 134 | toJSON (PDAL input fromState stackTop) = Array $ Vector.fromList 135 | [ toJSON input 136 | , toJSON fromState 137 | , toJSON stackTop 138 | ] 139 | 140 | instance (FromJSON state, FromJSON stack) => FromJSON (R PDA a (state, stack)) where 141 | parseJSON = withArray "(R PDA a (state, stack))" $ \arr -> do 142 | PDAR 143 | <$> (arr `parseAt` 0) -- toState 144 | <*> (arr `parseAt` 1) -- action 145 | 146 | instance (ToJSON state, ToJSON stack) => ToJSON (R PDA a (state, stack)) where 147 | toJSON (PDAR toState act) = Array $ Vector.fromList [ toJSON toState, toJSON act] 148 | parseAction :: Value -> Parser (PDAOp Stack) 149 | parseAction (String "nullop") = return NullOp 150 | parseAction (String "pop") = return Pop 151 | parseAction v = pushParser v 152 | where 153 | pushParser :: Value -> Parser (PDAOp Stack) 154 | pushParser = withArray "Push" $ \arr -> do 155 | op <- arr `parseAt` 0 156 | case op of 157 | String "push" -> Push <$> arr `parseAt` 1 158 | _ -> fail "Invalid push action" 159 | 160 | type State = T.Text 161 | type Stack = T.Text 162 | type Symbol = T.Text 163 | type Frame = (State, Stack) 164 | 165 | initialState :: S PDA Symbol Frame 166 | initialState = PDAS "INITIAL" Seq.empty 167 | 168 | halt :: S PDA a (State, stack) -> Exit 169 | halt (PDAS "REJECT" _) = Error 170 | halt (PDAS "ACCEPT" _) = Success 171 | halt _ = Running 172 | -------------------------------------------------------------------------------- /app/Main.hs: -------------------------------------------------------------------------------- 1 | {- 2 | 3 | USAGE: 4 | 5 | cabal run automata -- --input rules/anbn.json --output data/anbn_progs.json --number 100 --max_length 100 6 | 7 | # or 8 | 9 | cabal build 10 | dist/build/automata/automata --input rules/anbn.json --output anbn_progs.json --number 1000 --max_length 100 11 | 12 | -} 13 | 14 | {-# LANGUAGE RecordWildCards #-} 15 | {-# LANGUAGE OverloadedStrings #-} 16 | {-# LANGUAGE DeriveAnyClass #-} 17 | 18 | module Main where 19 | 20 | import Options.Applicative 21 | 22 | import qualified Data.ByteString.Char8 as B8 23 | 24 | import Data.Aeson (FromJSON(..), ToJSON(..), encode, eitherDecodeStrict', withText, (.:)) 25 | import qualified Data.ByteString.Char8 as BC8 26 | import GHC.Generics (Generic) 27 | import Data.Text (Text) 28 | import qualified Data.Text as T 29 | import qualified Automata as A 30 | import qualified FSM 31 | import qualified PDA 32 | import qualified QA 33 | import qualified Data.Aeson.Types as Aeson 34 | 35 | 36 | data CLIOptions = CLIOptions 37 | { inputFile :: !FilePath 38 | , numGenerations :: !Int 39 | , outputFile :: !FilePath 40 | , maxStringLength :: !Int 41 | , maxDeepening :: !Int 42 | } 43 | 44 | cliOptions :: ParserInfo CLIOptions 45 | cliOptions = info (options <**> helper) 46 | ( fullDesc 47 | <> progDesc "Generate sentences from a given grammar" 48 | <> header "automata - a sentence generator for formal grammars" 49 | ) 50 | where 51 | options = CLIOptions 52 | <$> strOption 53 | ( long "input" 54 | <> short 'i' 55 | <> metavar "FILE" 56 | <> help "Input file containing transition table") 57 | <*> option auto 58 | ( long "number" 59 | <> short 'n' 60 | <> metavar "INT" 61 | <> value 20 62 | <> showDefault 63 | <> help "Number of generations to produce") 64 | <*> strOption 65 | ( long "output" 66 | <> short 'o' 67 | <> metavar "FILE" 68 | <> help "Output file to save the generated data") 69 | <*> option auto 70 | ( long "max_length" 71 | <> short 'l' 72 | <> metavar "INT" 73 | <> value 20 74 | <> showDefault 75 | <> help "Max string length.") 76 | <*> option auto 77 | ( long "max_deepening" 78 | <> short 'd' 79 | <> metavar "INT" 80 | <> value 20 81 | <> showDefault 82 | <> help "Max number of depths to explore if no new strings have been yielded for this span.") 83 | 84 | data MachineType = 85 | FSM -- Finite State Machine 86 | | PDA -- Pushdown Automaton 87 | | QA -- Queue Automaton 88 | deriving (Show, Eq, Generic, ToJSON) 89 | 90 | instance FromJSON MachineType where 91 | parseJSON = withText "MachineType" $ \t -> 92 | case T.toLower t of 93 | "fsm" -> return FSM 94 | "pda" -> return PDA 95 | "qa" -> return QA 96 | _ -> fail "Invalid machine value" 97 | 98 | -- First pass of parsing pulls out the machine type so we know how to parse the rest 99 | newtype PartialMachineSpec = PartialMachineSpec 100 | { pMachine :: MachineType 101 | } deriving (Generic) 102 | 103 | instance FromJSON PartialMachineSpec where 104 | parseJSON = Aeson.withObject "PartialMachineSpec" $ \v -> do 105 | machineType <- v .: "machine" 106 | return PartialMachineSpec 107 | { pMachine = machineType 108 | } 109 | 110 | data MachineSpec m a s = MachineSpec 111 | { machine :: !MachineType 112 | , symbols :: ![Text] 113 | , rules :: ![(A.L m a s, A.R m a s)] 114 | } deriving Generic 115 | 116 | 117 | instance FromJSON (MachineSpec FSM.FSM FSM.Symbol FSM.State) where 118 | instance ToJSON (MachineSpec FSM.FSM FSM.Symbol FSM.State) where 119 | 120 | instance FromJSON (MachineSpec PDA.PDA PDA.Symbol PDA.Frame) where 121 | instance ToJSON (MachineSpec PDA.PDA PDA.Symbol PDA.Frame) where 122 | 123 | instance FromJSON (MachineSpec QA.QA QA.Symbol QA.Frame) where 124 | instance ToJSON (MachineSpec QA.QA QA.Symbol QA.Frame) where 125 | 126 | 127 | data Output m a s = Output 128 | { spec :: !(MachineSpec m a s) 129 | , sentences :: ![Text] 130 | } deriving Generic 131 | 132 | instance ToJSON (Output FSM.FSM FSM.Symbol FSM.State) where 133 | instance ToJSON (Output PDA.PDA PDA.Symbol PDA.Frame) where 134 | instance ToJSON (Output QA.QA QA.Symbol QA.Frame) where 135 | 136 | main :: IO () 137 | main = do 138 | clio@CLIOptions{..} <- execParser cliOptions 139 | 140 | -- Read transition table from input file 141 | jsonInput <- B8.readFile inputFile 142 | case eitherDecodeStrict' @PartialMachineSpec jsonInput of 143 | Left err -> putStrLn $ "Error parsing `machine` key: " ++ err 144 | Right PartialMachineSpec{..} -> do 145 | case pMachine of 146 | FSM -> do 147 | case eitherDecodeStrict' jsonInput of 148 | Left err -> putStrLn $ "Error parsing FSM machine specification: " ++ err 149 | Right spec@MachineSpec{..} -> do 150 | strings <- FSM.fsmString maxStringLength maxDeepening numGenerations rules FSM.halt symbols FSM.initialState 151 | processOutput clio spec strings 152 | 153 | PDA -> do 154 | case eitherDecodeStrict' jsonInput of 155 | Left err -> putStrLn $ "Error parsing PDA machine specification: " ++ err 156 | Right spec@MachineSpec{..} -> do 157 | strings <- PDA.pdaString maxStringLength maxDeepening numGenerations rules PDA.halt symbols PDA.initialState 158 | processOutput clio spec strings 159 | 160 | QA -> case eitherDecodeStrict' jsonInput of 161 | Left err -> putStrLn $ "Error parsing QA machine specification: " ++ err 162 | Right spec@MachineSpec{..} -> do 163 | strings <- QA.qaString maxStringLength maxDeepening numGenerations rules QA.halt symbols QA.initialState 164 | processOutput clio spec strings 165 | 166 | processOutput :: ToJSON (Output m a s) => CLIOptions -> MachineSpec m a s -> [Text] -> IO () 167 | processOutput CLIOptions{..} spec strings = do 168 | let out = Output spec strings 169 | 170 | -- Save the generated data 171 | if null strings 172 | then 173 | putStrLn "WARNING: No programs generated, perhaps you have an error in your transition rules?" 174 | else do 175 | BC8.writeFile outputFile $ BC8.toStrict (encode out) 176 | putStrLn "sample:" 177 | let hd = take 5 strings 178 | tl = drop (length strings - 5) strings 179 | mapM_ print hd 180 | putStrLn "..." 181 | mapM_ print tl 182 | putStrLn $ "generated " <> show (length strings) <> " total programs" 183 | putStrLn $ "saved to: " ++ outputFile 184 | -------------------------------------------------------------------------------- /src/Automata.hs: -------------------------------------------------------------------------------- 1 | {- 2 | 3 | Automata class definition 4 | 5 | -------------------------------------------------- 6 | 7 | Mealy Machine (FSM): 6-tuple (Q, Σ, Δ, δ, λ, q₀), where: 8 | - Q : states 9 | - Σ : input symbols 10 | - Δ : output symbols 11 | - δ : Q × Σ → Q is the state transition function 12 | - λ : Q × Σ → Δ is the output function 13 | - q₀ ∈ Q is the initial state 14 | 15 | Moore Machine (FSM): 6-tuple (Q, Σ, Δ, δ, λ, q₀), where: 16 | - Q : states 17 | - Σ : input symbols 18 | - Δ : output symbols 19 | - δ : Q × Σ → Q is the state transition function 20 | - λ : Q → Δ is the output function 21 | - q₀ ∈ Q 22 | 23 | Turing Machine (TM) with Queue: 8-tuple (Q, Σ, Γ, δ, q₀, q_acc, q_rej, □), where: 24 | - Q : states 25 | - Σ : input symbols 26 | - Γ : queue symbols (the queue alphabet), where Σ ⊆ Γ and □ ∈ Γ \ Σ (□ is the blank symbol) 27 | - δ : Q × Γ → Q × (Γ ∪ {ε}) × {EnqL, EnqR, DeqL, DeqR} is the transition function 28 | - q₀ ∈ Q 29 | - q_acc ∈ Q is the accepting state 30 | - q_rej ∈ Q is the rejecting state 31 | - □ is the blank symbol 32 | 33 | Queue Automaton, Γ is head, Γ* is queue: 34 | δ : Q × Γ → Q × Γ* 35 | 36 | Multi-tape, with k tapes: 37 | δ : Q × Γ_k → Q × Γ_k × { L , R } 38 | 39 | -} 40 | 41 | {-# LANGUAGE TypeFamilies #-} 42 | {-# LANGUAGE OverloadedStrings #-} 43 | {-# LANGUAGE OverloadedLists #-} 44 | 45 | module Automata where 46 | 47 | import Data.Sequence ( Seq, ViewL(..), Seq(..), (|>) ) 48 | import qualified Data.Sequence as Seq 49 | import Data.Foldable ( toList, foldl' ) 50 | import Data.Kind (Type) 51 | import Data.List.Extra (lookupMatchAny, MatchAny(..), Any (..)) 52 | import Data.Aeson ( Value, ToJSON, FromJSON(parseJSON) ) 53 | import Data.Aeson.Types (Parser) 54 | import qualified Data.Vector as Vector 55 | import Control.Arrow (second) 56 | import qualified Data.PQueue.Min as Q 57 | import System.Random (randomRIO, randomRs, newStdGen) 58 | import Control.Monad (replicateM) 59 | import Data.List (nub) 60 | 61 | 62 | -------------------------------------------------- 63 | -- * Util 64 | 65 | viewl :: Data.Sequence.Seq a -> Maybe a 66 | viewl s = case Seq.viewl s of 67 | Data.Sequence.EmptyL -> Nothing 68 | (x Data.Sequence.:< _) -> Just x 69 | 70 | viewr :: Data.Sequence.Seq a -> Maybe a 71 | viewr s = case Seq.viewr s of 72 | Seq.EmptyR -> Nothing 73 | (_ Seq.:> x) -> Just x 74 | 75 | splitAtR :: Int -> Data.Sequence.Seq a -> (Data.Sequence.Seq a, Data.Sequence.Seq a) 76 | splitAtR i s = Seq.splitAt (length s - i) s 77 | 78 | taker :: Int -> Data.Sequence.Seq a -> Data.Sequence.Seq a 79 | taker i s = snd $ splitAtR i s 80 | 81 | dropr :: Int -> Data.Sequence.Seq a -> Data.Sequence.Seq a 82 | dropr i s = fst $ splitAtR i s 83 | 84 | 85 | -------------------------------------------------- 86 | -- * Machine Definition 87 | 88 | data Exit = 89 | Running 90 | | Error 91 | | Success 92 | deriving (Eq, Show) 93 | 94 | -- | Generate valid strings (DFS version). Deprecated? 95 | generateLsDFS :: forall m a s. (Machine m a s, Ord (L m a s), MatchAny (L m a s)) 96 | => Int -- depth limit 97 | -> [(L m a s, R m a s)] -- transition relation 98 | -> (S m a s -> Exit) -- halting function 99 | -> [a] -- input symbols 100 | -> S m a s -- initial state 101 | -> [[L m a s]] -- lazy list of valid strings up to the specified depth 102 | generateLsDFS maxDepth transitions hlt syms initState = dfs initState Empty 0 103 | where 104 | dfs :: S m a s -> Seq (L m a s) -> Int -> [[L m a s]] 105 | dfs state acc depth 106 | | depth > maxDepth = [] 107 | | hlt state == Success = [toList acc] 108 | | hlt state == Error = [] 109 | | otherwise = concatMap explore syms 110 | where 111 | explore a = 112 | let ls = filter (\(l, _) -> matchAny l (mkL a state)) transitions 113 | in concatMap (\(l, r) -> dfs (action r state) (acc |> l) (depth + 1)) ls 114 | 115 | -- | Generate valid strings (BFS version). Deprecated? 116 | generateLsBFS :: forall m a s. (Machine m a s, Ord (L m a s), MatchAny (L m a s)) 117 | => [(L m a s, R m a s)] -- transition relation 118 | -> (S m a s -> Exit) -- halting function 119 | -> [a] -- input symbols 120 | -> S m a s -- initial state 121 | -> [[L m a s]] -- lazy list of valid prefixes 122 | generateLsBFS transitions hlt syms initState = bfs [(initState, Empty)] 123 | where 124 | bfs :: [(S m a s, Seq (L m a s))] -> [[L m a s]] 125 | bfs [] = [] 126 | bfs ((state, acc) : queue) = let 127 | -- find all valid transitions for each input symbol 128 | validTransitions = concatMap (\a -> 129 | let ls = filter (\(l, _) -> matchAny l (mkL a state)) transitions 130 | in map (\(l, r) -> (action r state, acc |> l)) ls 131 | ) syms 132 | -- add new states and their accumulators to the queue 133 | newQueue = queue ++ validTransitions 134 | -- check if the current state is a halting state 135 | haltingAccs = [toList acc | hlt state == Success] 136 | in 137 | haltingAccs ++ bfs newQueue 138 | 139 | -- | Generate valid strings (Iterative Depth DFS). 140 | -- 141 | -- If no strings have been found for a span of `maxDeepening`, stop generating 142 | -- early (ie don't search ad infinitum) 143 | generateLsIDDFS :: forall m a s. (Machine m a s, Ord (L m a s), MatchAny (L m a s)) 144 | => Int -- maximum string length 145 | -> Int -- maximum deepening steps without finding new strings 146 | -> [(L m a s, R m a s)] -- transition relation 147 | -> (S m a s -> Exit) -- halting function 148 | -> [a] -- input symbols 149 | -> S m a s -- initial state 150 | -> [[L m a s]] -- lazy list of valid strings up to the specified depth 151 | generateLsIDDFS maxLength maxDeepening transitions hlt syms initState = idfs [(initState, Empty, 0)] 0 152 | where 153 | idfs :: [(S m a s, Seq (L m a s), Int)] -> Int -> [[L m a s]] 154 | idfs queue deepeningSteps 155 | | deepeningSteps > maxDeepening = [] 156 | | otherwise = 157 | let (haltingAccs, nonHaltingStates) = partitionHalting queue 158 | newQueue = concatMap exploreStates $ filter (\(_, _, len) -> len <= maxLength) nonHaltingStates 159 | validStrings = map (\(acc, _) -> toList acc) haltingAccs 160 | deepeningSteps' = if null validStrings then deepeningSteps + 1 else 0 161 | in validStrings ++ idfs newQueue deepeningSteps' 162 | 163 | partitionHalting :: [(S m a s, Seq (L m a s), Int)] -> ([(Seq (L m a s), Int)], [(S m a s, Seq (L m a s), Int)]) 164 | partitionHalting = foldr f ([], []) 165 | where 166 | f (state, acc, len) (halting, nonHalting) 167 | | hlt state == Success = ((acc, len) : halting, nonHalting) 168 | | hlt state == Error = (halting, nonHalting) 169 | | otherwise = (halting, (state, acc, len) : nonHalting) 170 | 171 | exploreStates :: (S m a s, Seq (L m a s), Int) -> [(S m a s, Seq (L m a s), Int)] 172 | exploreStates (state, acc, len) = concatMap explore syms 173 | where 174 | explore a = 175 | let ls = filter (\(l, _) -> matchAny l (mkL a state)) transitions 176 | in map (\(l, r) -> (action r state, acc |> l, len + 1)) ls 177 | 178 | 179 | 180 | data Scored a s = Scored !Float !a !s 181 | 182 | instance Eq (Scored a s) where 183 | (Scored x _ _) == (Scored y _ _) = x == y 184 | 185 | instance Ord (Scored a s) where 186 | (Scored x _ _) < (Scored y _ _) = x < y 187 | (Scored x _ _) <= (Scored y _ _) = x <= y 188 | (Scored x _ _) > (Scored y _ _) = x > y 189 | (Scored x _ _) >= (Scored y _ _) = x >= y 190 | 191 | -- | Generate valid strings (Priority Queue). 192 | generateLsPQ :: forall m a s. (Machine m a s, Ord (L m a s), MatchAny (L m a s)) 193 | => Int -- maximum string length 194 | -> (Seq (L m a s) -> S m a s -> Float) -- scoring function 195 | -> [(L m a s, R m a s)] -- transition relation 196 | -> (S m a s -> Exit) -- halting function 197 | -> [a] -- input symbols 198 | -> S m a s -- initial state 199 | -> [[L m a s]] -- lazy list of valid strings 200 | generateLsPQ maxLength score transitions hlt syms initState = pq initQueue 201 | where 202 | initQueue = Q.singleton (Scored (score Empty initState) Empty initState) 203 | 204 | pq :: Q.MinQueue (Scored (Seq (L m a s)) (S m a s)) -> [[L m a s]] 205 | pq queue = case Q.minView queue of 206 | Nothing -> [] 207 | Just (Scored _ acc state, queue') 208 | | length acc > maxLength -> pq queue' 209 | | hlt state == Success -> toList acc : pq queue' 210 | | hlt state == Error -> pq queue' 211 | | otherwise -> 212 | let newStates = concatMap (exploreState acc state) syms 213 | newQueue = foldl' (flip Q.insert) queue' newStates 214 | in pq newQueue 215 | 216 | exploreState :: Seq (L m a s) -> S m a s -> a -> [Scored (Seq (L m a s)) (S m a s)] 217 | exploreState acc state sym = 218 | let ls = filter (\(l, _) -> matchAny l (mkL sym state)) transitions 219 | in map (\(l, r) -> 220 | let newState = action r state 221 | newAcc = acc |> l 222 | in Scored (score newAcc newState) newAcc newState 223 | ) ls 224 | 225 | -- | Generate valid strings (Randomized). 226 | generateLsRandom :: forall m a s. (Machine m a s, Ord (L m a s), MatchAny (L m a s)) 227 | => Int -- maximum string length 228 | -> Int -- number of strings to generate 229 | -> [(L m a s, R m a s)] -- transition relation 230 | -> (S m a s -> Exit) -- halting function 231 | -> [a] -- input symbols 232 | -> S m a s -- initial state 233 | -> IO [[L m a s]] -- IO action that returns a list of valid strings 234 | generateLsRandom maxLength numStrings transitions hlt syms initState = do 235 | strings <- replicateM numStrings $ randomWalk initState Empty 0 236 | return $ filter (not . null) strings 237 | where 238 | randomWalk :: S m a s -> Seq (L m a s) -> Int -> IO [L m a s] 239 | randomWalk state acc len 240 | | len > maxLength = return [] 241 | | hlt state == Success = return (toList acc) 242 | | hlt state == Error = return [] 243 | | otherwise = do 244 | let validTransitions = concatMap (\a -> 245 | let ls = filter (\(l, _) -> matchAny l (mkL a state)) transitions 246 | in map (\(l, r) -> (action r state, acc |> l)) ls 247 | ) syms 248 | if null validTransitions 249 | then return [] 250 | else do 251 | index <- randomRIO (0, length validTransitions - 1) 252 | let (newState, newAcc) = validTransitions !! index 253 | randomWalk newState newAcc (len + 1) 254 | 255 | -- | Randomized Iterative Deepening 256 | generateLsRandomizedID :: forall m a s. (Machine m a s, Ord (L m a s), MatchAny (L m a s)) 257 | => Int -- maximum string length 258 | -> Int -- number of strings to generate 259 | -> Float -- randomization factor (between 0 and 1) 260 | -> [(L m a s, R m a s)] -- transition relation 261 | -> (S m a s -> Exit) -- halting function 262 | -> [a] -- input symbols 263 | -> S m a s -- initial state 264 | -> IO [[L m a s]] -- IO action that returns a list of valid strings 265 | generateLsRandomizedID maxLength numStrings randomFactor transitions hlt syms initState = do 266 | strings <- iterativeDeepening 0 267 | return $ take numStrings strings 268 | where 269 | iterativeDeepening :: Int -> IO [[L m a s]] 270 | iterativeDeepening depth 271 | | depth > maxLength = return [] 272 | | otherwise = do 273 | currentStrings <- randomizedDFS depth initState Empty 274 | nextStrings <- iterativeDeepening (depth + 1) 275 | return (currentStrings ++ nextStrings) 276 | 277 | randomizedDFS :: Int -> S m a s -> Seq (L m a s) -> IO [[L m a s]] 278 | randomizedDFS depth state acc 279 | | depth == 0 = return [] 280 | | hlt state == Success = return [toList acc] 281 | | hlt state == Error = return [] 282 | | otherwise = do 283 | let transitions' = concatMap (\a -> 284 | let ls = filter (\(l, _) -> matchAny l (mkL a state)) transitions 285 | in map (\(l, r) -> (action r state, acc |> l)) ls 286 | ) syms 287 | if null transitions' 288 | then return [] 289 | else do 290 | let numTransitions = length transitions' 291 | numToExplore <- randomRIO (1, ceiling (fromIntegral numTransitions * randomFactor)) 292 | transitionsToExplore <- getRandomTransitions numToExplore transitions' 293 | concat <$> mapM (\(newState, newAcc) -> randomizedDFS (depth - 1) newState newAcc) transitionsToExplore 294 | 295 | getRandomTransitions :: Int -> [(S m a s, Seq (L m a s))] -> IO [(S m a s, Seq (L m a s))] 296 | getRandomTransitions n transitions' = do 297 | indices <- getRandomIndices n (length transitions') 298 | return $ map (transitions' !!) indices 299 | 300 | getRandomIndices :: Int -> Int -> IO [Int] 301 | getRandomIndices n max' = take n . nub . randomRs (0, max' - 1) <$> newStdGen 302 | 303 | 304 | -------------------------------------------------- 305 | -- * Class 306 | 307 | class 308 | (ToJSON (L m a s), 309 | FromJSON (L m a s), 310 | ToJSON (R m a s), 311 | FromJSON (R m a s) 312 | ) => Machine m a (s :: Type) where 313 | data L m a s -- ^ the Left side of a delta function/relation 314 | data R m a s -- ^ the Right side of a delta function/relation 315 | data S m a s -- ^ the State of the Machine 316 | -- | update the state (ex apply stack ops) 317 | action :: R m a s -> S m a s -> S m a s 318 | -- | build an input (ex add a peek at the top of a stack) 319 | mkL :: a -> S m a s -> L m a s 320 | 321 | -- | Run a machine on an input symbol 322 | runStep :: (Machine m a s, Eq (L m a s), Show (L m a s), MatchAny (L m a s), Eq (R m a s)) 323 | => [(L m a s, R m a s)] -- transition table 324 | -> S m a s -- state 325 | -> a -- single input 326 | -> Maybe (R m a s, S m a s) -- (transition value, new state) 327 | runStep table st input = 328 | case lookupMatchAny (mkL input st, Any) (second A <$> table) of 329 | Just (_, A transition) -> Just (transition, action transition st) 330 | _ -> Nothing -- no transition found 331 | 332 | -- | Run a machine on a list of input symbols 333 | runMachine :: (Machine m a s 334 | , Eq (L m a s) 335 | , Eq (R m a s) 336 | , Show (L m a s) 337 | , MatchAny (L m a s) 338 | ) 339 | => [(L m a s, R m a s)] -- transition table 340 | -> S m a s -- initial state 341 | -> [a] -- input symbols 342 | -> Maybe (R m a s, S m a s) 343 | runMachine table initState = foldl' f $ Just (error "empty input", initState) 344 | where 345 | f (Just (_, state)) = runStep table state 346 | f Nothing = const Nothing 347 | 348 | parseAt :: FromJSON a => Vector.Vector Value -> Int -> Parser a 349 | parseAt arr i = parseJSON (arr Vector.! i) 350 | -------------------------------------------------------------------------------- /data/an_b2n_progs.json: -------------------------------------------------------------------------------- 1 | {"sentences":["^abb$","^aabbbb$","^aaabbbbbb$","^aaaabbbbbbbb$","^aaaaabbbbbbbbbb$","^aaaaaabbbbbbbbbbbb$","^aaaaaaabbbbbbbbbbbbbb$","^aaaaaaaabbbbbbbbbbbbbbbb$","^aaaaaaaaabbbbbbbbbbbbbbbbbb$","^aaaaaaaaaabbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb$"],"spec":{"machine":"PDA","rules":[[["^","INITIAL",null],["Q1",["push","$"]]],[["$","Q3","$"],["ACCEPT","pop"]],[["a","Q1","$"],["Q2",["push","X"]]],[["a","Q1","X"],["Q2",["push","X"]]],[["","Q2","X"],["Q1",["push","X"]]],[["b","Q1","X"],["Q3","pop"]],[["b","Q3","X"],["Q3","pop"]]],"symbols":["^","a","b","x","y","$",""]}} -------------------------------------------------------------------------------- /data/qa/an_bn_cn_progs.json: -------------------------------------------------------------------------------- 1 | {"sentences":["^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbcccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbccccccccccccccccccc$","^aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbcccccccccccccccccc$","^aaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbccccccccccccccccc$","^aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbcccccccccccccccc$","^aaaaaaaaaaaaaaabbbbbbbbbbbbbbbccccccccccccccc$","^aaaaaaaaaaaaaabbbbbbbbbbbbbbcccccccccccccc$","^aaaaaaaaaaaaabbbbbbbbbbbbbccccccccccccc$","^aaaaaaaaaaaabbbbbbbbbbbbcccccccccccc$","^aaaaaaaaaaabbbbbbbbbbbccccccccccc$","^aaaaaaaaaabbbbbbbbbbcccccccccc$","^aaaaaaaaabbbbbbbbbccccccccc$","^aaaaaaaabbbbbbbbcccccccc$","^aaaaaaabbbbbbbccccccc$","^aaaaaabbbbbbcccccc$","^aaaaabbbbbccccc$","^aaaabbbbcccc$","^aaabbbccc$","^aabbcc$","^abc$"],"spec":{"machine":"QA","rules":[[["^","INITIAL",null],["Q1","NULLOP"]],[["a","Q1","ANY"],["Q1",["ENQR","A"]]],[["b","Q1","A"],["START_B","DEQL"]],[["","START_B","ANY"],["Q2",["ENQR","#"]]],[["b","Q2","A"],["CONT_B","DEQL"]],[["","CONT_B","ANY"],["Q2",["ENQR","B"]]],[["c","Q2","#"],["START_C","DEQL"]],[["","START_C","ANY"],["Q3",["ENQR","#"]]],[["c","Q3","B"],["Q3","DEQL"]],[["$","Q3","#"],["ACCEPT","NULLOP"]],[["$","Q3",null],["ACCEPT","NULLOP"]]],"symbols":["^","a","b","c","$",""]}} -------------------------------------------------------------------------------- /data/wcwr_progs.json: -------------------------------------------------------------------------------- 1 | {"sentences":["^aca$","^bcb$","^aacaa$","^abcba$","^bacab$","^bbcbb$","^aaacaaa$","^aabcbaa$","^abacaba$","^abbcbba$","^baacaab$","^babcbab$","^bbacabb$","^bbbcbbb$","^aaaacaaaa$","^aaabcbaaa$","^aabacabaa$","^aabbcbbaa$","^abaacaaba$","^ababcbaba$","^abbacabba$","^abbbcbbba$","^baaacaaab$","^baabcbaab$","^babacabab$","^babbcbbab$","^bbaacaabb$","^bbabcbabb$","^bbbacabbb$","^bbbbcbbbb$","^aaaaacaaaaa$","^aaaabcbaaaa$","^aaabacabaaa$","^aaabbcbbaaa$","^aabaacaabaa$","^aababcbabaa$","^aabbacabbaa$","^aabbbcbbbaa$","^abaaacaaaba$","^abaabcbaaba$","^ababacababa$","^ababbcbbaba$","^abbaacaabba$","^abbabcbabba$","^abbbacabbba$","^abbbbcbbbba$","^baaaacaaaab$","^baaabcbaaab$","^baabacabaab$","^baabbcbbaab$","^babaacaabab$","^bababcbabab$","^babbacabbab$","^babbbcbbbab$","^bbaaacaaabb$","^bbaabcbaabb$","^bbabacababb$","^bbabbcbbabb$","^bbbaacaabbb$","^bbbabcbabbb$","^bbbbacabbbb$","^bbbbbcbbbbb$","^aaaaaacaaaaaa$","^aaaaabcbaaaaa$","^aaaabacabaaaa$","^aaaabbcbbaaaa$","^aaabaacaabaaa$","^aaababcbabaaa$","^aaabbacabbaaa$","^aaabbbcbbbaaa$","^aabaaacaaabaa$","^aabaabcbaabaa$","^aababacababaa$","^aababbcbbabaa$","^aabbaacaabbaa$","^aabbabcbabbaa$","^aabbbacabbbaa$","^aabbbbcbbbbaa$","^abaaaacaaaaba$","^abaaabcbaaaba$","^abaabacabaaba$","^abaabbcbbaaba$","^ababaacaababa$","^abababcbababa$","^ababbacabbaba$","^ababbbcbbbaba$","^abbaaacaaabba$","^abbaabcbaabba$","^abbabacababba$","^abbabbcbbabba$","^abbbaacaabbba$","^abbbabcbabbba$","^abbbbacabbbba$","^abbbbbcbbbbba$","^baaaaacaaaaab$","^baaaabcbaaaab$","^baaabacabaaab$","^baaabbcbbaaab$","^baabaacaabaab$","^baababcbabaab$","^baabbacabbaab$","^baabbbcbbbaab$","^babaaacaaabab$","^babaabcbaabab$","^bababacababab$","^bababbcbbabab$","^babbaacaabbab$","^babbabcbabbab$","^babbbacabbbab$","^babbbbcbbbbab$","^bbaaaacaaaabb$","^bbaaabcbaaabb$","^bbaabacabaabb$","^bbaabbcbbaabb$","^bbabaacaababb$","^bbababcbababb$","^bbabbacabbabb$","^bbabbbcbbbabb$","^bbbaaacaaabbb$","^bbbaabcbaabbb$","^bbbabacababbb$","^bbbabbcbbabbb$","^bbbbaacaabbbb$","^bbbbabcbabbbb$","^bbbbbacabbbbb$","^bbbbbbcbbbbbb$","^aaaaaaacaaaaaaa$","^aaaaaabcbaaaaaa$","^aaaaabacabaaaaa$","^aaaaabbcbbaaaaa$","^aaaabaacaabaaaa$","^aaaababcbabaaaa$","^aaaabbacabbaaaa$","^aaaabbbcbbbaaaa$","^aaabaaacaaabaaa$","^aaabaabcbaabaaa$","^aaababacababaaa$","^aaababbcbbabaaa$","^aaabbaacaabbaaa$","^aaabbabcbabbaaa$","^aaabbbacabbbaaa$","^aaabbbbcbbbbaaa$","^aabaaaacaaaabaa$","^aabaaabcbaaabaa$","^aabaabacabaabaa$","^aabaabbcbbaabaa$","^aababaacaababaa$","^aabababcbababaa$","^aababbacabbabaa$","^aababbbcbbbabaa$","^aabbaaacaaabbaa$","^aabbaabcbaabbaa$","^aabbabacababbaa$","^aabbabbcbbabbaa$","^aabbbaacaabbbaa$","^aabbbabcbabbbaa$","^aabbbbacabbbbaa$","^aabbbbbcbbbbbaa$","^abaaaaacaaaaaba$","^abaaaabcbaaaaba$","^abaaabacabaaaba$","^abaaabbcbbaaaba$","^abaabaacaabaaba$","^abaababcbabaaba$","^abaabbacabbaaba$","^abaabbbcbbbaaba$","^ababaaacaaababa$","^ababaabcbaababa$","^abababacabababa$","^abababbcbbababa$","^ababbaacaabbaba$","^ababbabcbabbaba$","^ababbbacabbbaba$","^ababbbbcbbbbaba$","^abbaaaacaaaabba$","^abbaaabcbaaabba$","^abbaabacabaabba$","^abbaabbcbbaabba$","^abbabaacaababba$","^abbababcbababba$","^abbabbacabbabba$","^abbabbbcbbbabba$","^abbbaaacaaabbba$","^abbbaabcbaabbba$","^abbbabacababbba$","^abbbabbcbbabbba$","^abbbbaacaabbbba$","^abbbbabcbabbbba$","^abbbbbacabbbbba$","^abbbbbbcbbbbbba$","^baaaaaacaaaaaab$","^baaaaabcbaaaaab$","^baaaabacabaaaab$","^baaaabbcbbaaaab$","^baaabaacaabaaab$","^baaababcbabaaab$","^baaabbacabbaaab$","^baaabbbcbbbaaab$","^baabaaacaaabaab$","^baabaabcbaabaab$","^baababacababaab$","^baababbcbbabaab$","^baabbaacaabbaab$","^baabbabcbabbaab$","^baabbbacabbbaab$","^baabbbbcbbbbaab$","^babaaaacaaaabab$","^babaaabcbaaabab$","^babaabacabaabab$","^babaabbcbbaabab$","^bababaacaababab$","^babababcbababab$","^bababbacabbabab$","^bababbbcbbbabab$","^babbaaacaaabbab$","^babbaabcbaabbab$","^babbabacababbab$","^babbabbcbbabbab$","^babbbaacaabbbab$","^babbbabcbabbbab$","^babbbbacabbbbab$","^babbbbbcbbbbbab$","^bbaaaaacaaaaabb$","^bbaaaabcbaaaabb$","^bbaaabacabaaabb$","^bbaaabbcbbaaabb$","^bbaabaacaabaabb$","^bbaababcbabaabb$","^bbaabbacabbaabb$","^bbaabbbcbbbaabb$","^bbabaaacaaababb$","^bbabaabcbaababb$","^bbababacabababb$","^bbababbcbbababb$","^bbabbaacaabbabb$","^bbabbabcbabbabb$","^bbabbbacabbbabb$","^bbabbbbcbbbbabb$","^bbbaaaacaaaabbb$","^bbbaaabcbaaabbb$","^bbbaabacabaabbb$","^bbbaabbcbbaabbb$","^bbbabaacaababbb$","^bbbababcbababbb$","^bbbabbacabbabbb$","^bbbabbbcbbbabbb$","^bbbbaaacaaabbbb$","^bbbbaabcbaabbbb$","^bbbbabacababbbb$","^bbbbabbcbbabbbb$","^bbbbbaacaabbbbb$","^bbbbbabcbabbbbb$","^bbbbbbacabbbbbb$","^bbbbbbbcbbbbbbb$","^aaaaaaaacaaaaaaaa$","^aaaaaaabcbaaaaaaa$","^aaaaaabacabaaaaaa$","^aaaaaabbcbbaaaaaa$","^aaaaabaacaabaaaaa$","^aaaaababcbabaaaaa$","^aaaaabbacabbaaaaa$","^aaaaabbbcbbbaaaaa$","^aaaabaaacaaabaaaa$","^aaaabaabcbaabaaaa$","^aaaababacababaaaa$","^aaaababbcbbabaaaa$","^aaaabbaacaabbaaaa$","^aaaabbabcbabbaaaa$","^aaaabbbacabbbaaaa$","^aaaabbbbcbbbbaaaa$","^aaabaaaacaaaabaaa$","^aaabaaabcbaaabaaa$","^aaabaabacabaabaaa$","^aaabaabbcbbaabaaa$","^aaababaacaababaaa$","^aaabababcbababaaa$","^aaababbacabbabaaa$","^aaababbbcbbbabaaa$","^aaabbaaacaaabbaaa$","^aaabbaabcbaabbaaa$","^aaabbabacababbaaa$","^aaabbabbcbbabbaaa$","^aaabbbaacaabbbaaa$","^aaabbbabcbabbbaaa$","^aaabbbbacabbbbaaa$","^aaabbbbbcbbbbbaaa$","^aabaaaaacaaaaabaa$","^aabaaaabcbaaaabaa$","^aabaaabacabaaabaa$","^aabaaabbcbbaaabaa$","^aabaabaacaabaabaa$","^aabaababcbabaabaa$","^aabaabbacabbaabaa$","^aabaabbbcbbbaabaa$","^aababaaacaaababaa$","^aababaabcbaababaa$","^aabababacabababaa$","^aabababbcbbababaa$","^aababbaacaabbabaa$","^aababbabcbabbabaa$","^aababbbacabbbabaa$","^aababbbbcbbbbabaa$","^aabbaaaacaaaabbaa$","^aabbaaabcbaaabbaa$","^aabbaabacabaabbaa$","^aabbaabbcbbaabbaa$","^aabbabaacaababbaa$","^aabbababcbababbaa$","^aabbabbacabbabbaa$","^aabbabbbcbbbabbaa$","^aabbbaaacaaabbbaa$","^aabbbaabcbaabbbaa$","^aabbbabacababbbaa$","^aabbbabbcbbabbbaa$","^aabbbbaacaabbbbaa$","^aabbbbabcbabbbbaa$","^aabbbbbacabbbbbaa$","^aabbbbbbcbbbbbbaa$","^abaaaaaacaaaaaaba$","^abaaaaabcbaaaaaba$","^abaaaabacabaaaaba$","^abaaaabbcbbaaaaba$","^abaaabaacaabaaaba$","^abaaababcbabaaaba$","^abaaabbacabbaaaba$","^abaaabbbcbbbaaaba$","^abaabaaacaaabaaba$","^abaabaabcbaabaaba$","^abaababacababaaba$","^abaababbcbbabaaba$","^abaabbaacaabbaaba$","^abaabbabcbabbaaba$","^abaabbbacabbbaaba$","^abaabbbbcbbbbaaba$","^ababaaaacaaaababa$","^ababaaabcbaaababa$","^ababaabacabaababa$","^ababaabbcbbaababa$","^abababaacaabababa$","^ababababcbabababa$","^abababbacabbababa$","^abababbbcbbbababa$","^ababbaaacaaabbaba$","^ababbaabcbaabbaba$","^ababbabacababbaba$","^ababbabbcbbabbaba$","^ababbbaacaabbbaba$","^ababbbabcbabbbaba$","^ababbbbacabbbbaba$","^ababbbbbcbbbbbaba$","^abbaaaaacaaaaabba$","^abbaaaabcbaaaabba$","^abbaaabacabaaabba$","^abbaaabbcbbaaabba$","^abbaabaacaabaabba$","^abbaababcbabaabba$","^abbaabbacabbaabba$","^abbaabbbcbbbaabba$","^abbabaaacaaababba$","^abbabaabcbaababba$","^abbababacabababba$","^abbababbcbbababba$","^abbabbaacaabbabba$","^abbabbabcbabbabba$","^abbabbbacabbbabba$","^abbabbbbcbbbbabba$","^abbbaaaacaaaabbba$","^abbbaaabcbaaabbba$","^abbbaabacabaabbba$","^abbbaabbcbbaabbba$","^abbbabaacaababbba$","^abbbababcbababbba$","^abbbabbacabbabbba$","^abbbabbbcbbbabbba$","^abbbbaaacaaabbbba$","^abbbbaabcbaabbbba$","^abbbbabacababbbba$","^abbbbabbcbbabbbba$","^abbbbbaacaabbbbba$","^abbbbbabcbabbbbba$","^abbbbbbacabbbbbba$","^abbbbbbbcbbbbbbba$","^baaaaaaacaaaaaaab$","^baaaaaabcbaaaaaab$","^baaaaabacabaaaaab$","^baaaaabbcbbaaaaab$","^baaaabaacaabaaaab$","^baaaababcbabaaaab$","^baaaabbacabbaaaab$","^baaaabbbcbbbaaaab$","^baaabaaacaaabaaab$","^baaabaabcbaabaaab$","^baaababacababaaab$","^baaababbcbbabaaab$","^baaabbaacaabbaaab$","^baaabbabcbabbaaab$","^baaabbbacabbbaaab$","^baaabbbbcbbbbaaab$","^baabaaaacaaaabaab$","^baabaaabcbaaabaab$","^baabaabacabaabaab$","^baabaabbcbbaabaab$","^baababaacaababaab$","^baabababcbababaab$","^baababbacabbabaab$","^baababbbcbbbabaab$","^baabbaaacaaabbaab$","^baabbaabcbaabbaab$","^baabbabacababbaab$","^baabbabbcbbabbaab$","^baabbbaacaabbbaab$","^baabbbabcbabbbaab$","^baabbbbacabbbbaab$","^baabbbbbcbbbbbaab$","^babaaaaacaaaaabab$","^babaaaabcbaaaabab$","^babaaabacabaaabab$","^babaaabbcbbaaabab$","^babaabaacaabaabab$","^babaababcbabaabab$","^babaabbacabbaabab$","^babaabbbcbbbaabab$","^bababaaacaaababab$","^bababaabcbaababab$","^babababacabababab$","^babababbcbbababab$","^bababbaacaabbabab$","^bababbabcbabbabab$","^bababbbacabbbabab$","^bababbbbcbbbbabab$","^babbaaaacaaaabbab$","^babbaaabcbaaabbab$","^babbaabacabaabbab$","^babbaabbcbbaabbab$","^babbabaacaababbab$","^babbababcbababbab$","^babbabbacabbabbab$","^babbabbbcbbbabbab$","^babbbaaacaaabbbab$","^babbbaabcbaabbbab$","^babbbabacababbbab$","^babbbabbcbbabbbab$","^babbbbaacaabbbbab$","^babbbbabcbabbbbab$","^babbbbbacabbbbbab$","^babbbbbbcbbbbbbab$","^bbaaaaaacaaaaaabb$","^bbaaaaabcbaaaaabb$","^bbaaaabacabaaaabb$","^bbaaaabbcbbaaaabb$","^bbaaabaacaabaaabb$","^bbaaababcbabaaabb$","^bbaaabbacabbaaabb$","^bbaaabbbcbbbaaabb$","^bbaabaaacaaabaabb$","^bbaabaabcbaabaabb$","^bbaababacababaabb$","^bbaababbcbbabaabb$","^bbaabbaacaabbaabb$","^bbaabbabcbabbaabb$","^bbaabbbacabbbaabb$","^bbaabbbbcbbbbaabb$","^bbabaaaacaaaababb$","^bbabaaabcbaaababb$","^bbabaabacabaababb$","^bbabaabbcbbaababb$","^bbababaacaabababb$","^bbabababcbabababb$","^bbababbacabbababb$","^bbababbbcbbbababb$","^bbabbaaacaaabbabb$","^bbabbaabcbaabbabb$","^bbabbabacababbabb$","^bbabbabbcbbabbabb$","^bbabbbaacaabbbabb$","^bbabbbabcbabbbabb$","^bbabbbbacabbbbabb$","^bbabbbbbcbbbbbabb$","^bbbaaaaacaaaaabbb$","^bbbaaaabcbaaaabbb$","^bbbaaabacabaaabbb$","^bbbaaabbcbbaaabbb$","^bbbaabaacaabaabbb$","^bbbaababcbabaabbb$","^bbbaabbacabbaabbb$","^bbbaabbbcbbbaabbb$","^bbbabaaacaaababbb$","^bbbabaabcbaababbb$","^bbbababacabababbb$","^bbbababbcbbababbb$","^bbbabbaacaabbabbb$","^bbbabbabcbabbabbb$","^bbbabbbacabbbabbb$","^bbbabbbbcbbbbabbb$","^bbbbaaaacaaaabbbb$","^bbbbaaabcbaaabbbb$","^bbbbaabacabaabbbb$","^bbbbaabbcbbaabbbb$","^bbbbabaacaababbbb$","^bbbbababcbababbbb$","^bbbbabbacabbabbbb$","^bbbbabbbcbbbabbbb$","^bbbbbaaacaaabbbbb$","^bbbbbaabcbaabbbbb$","^bbbbbabacababbbbb$","^bbbbbabbcbbabbbbb$","^bbbbbbaacaabbbbbb$","^bbbbbbabcbabbbbbb$","^bbbbbbbacabbbbbbb$","^bbbbbbbbcbbbbbbbb$","^aaaaaaaaacaaaaaaaaa$","^aaaaaaaabcbaaaaaaaa$","^aaaaaaabacabaaaaaaa$","^aaaaaaabbcbbaaaaaaa$","^aaaaaabaacaabaaaaaa$","^aaaaaababcbabaaaaaa$","^aaaaaabbacabbaaaaaa$","^aaaaaabbbcbbbaaaaaa$","^aaaaabaaacaaabaaaaa$","^aaaaabaabcbaabaaaaa$","^aaaaababacababaaaaa$","^aaaaababbcbbabaaaaa$","^aaaaabbaacaabbaaaaa$","^aaaaabbabcbabbaaaaa$","^aaaaabbbacabbbaaaaa$","^aaaaabbbbcbbbbaaaaa$","^aaaabaaaacaaaabaaaa$","^aaaabaaabcbaaabaaaa$","^aaaabaabacabaabaaaa$","^aaaabaabbcbbaabaaaa$","^aaaababaacaababaaaa$","^aaaabababcbababaaaa$","^aaaababbacabbabaaaa$","^aaaababbbcbbbabaaaa$","^aaaabbaaacaaabbaaaa$","^aaaabbaabcbaabbaaaa$","^aaaabbabacababbaaaa$","^aaaabbabbcbbabbaaaa$","^aaaabbbaacaabbbaaaa$","^aaaabbbabcbabbbaaaa$","^aaaabbbbacabbbbaaaa$","^aaaabbbbbcbbbbbaaaa$","^aaabaaaaacaaaaabaaa$","^aaabaaaabcbaaaabaaa$","^aaabaaabacabaaabaaa$","^aaabaaabbcbbaaabaaa$","^aaabaabaacaabaabaaa$","^aaabaababcbabaabaaa$","^aaabaabbacabbaabaaa$","^aaabaabbbcbbbaabaaa$","^aaababaaacaaababaaa$","^aaababaabcbaababaaa$","^aaabababacabababaaa$","^aaabababbcbbababaaa$","^aaababbaacaabbabaaa$","^aaababbabcbabbabaaa$","^aaababbbacabbbabaaa$","^aaababbbbcbbbbabaaa$","^aaabbaaaacaaaabbaaa$","^aaabbaaabcbaaabbaaa$","^aaabbaabacabaabbaaa$","^aaabbaabbcbbaabbaaa$","^aaabbabaacaababbaaa$","^aaabbababcbababbaaa$","^aaabbabbacabbabbaaa$","^aaabbabbbcbbbabbaaa$","^aaabbbaaacaaabbbaaa$","^aaabbbaabcbaabbbaaa$","^aaabbbabacababbbaaa$","^aaabbbabbcbbabbbaaa$","^aaabbbbaacaabbbbaaa$","^aaabbbbabcbabbbbaaa$","^aaabbbbbacabbbbbaaa$","^aaabbbbbbcbbbbbbaaa$","^aabaaaaaacaaaaaabaa$","^aabaaaaabcbaaaaabaa$","^aabaaaabacabaaaabaa$","^aabaaaabbcbbaaaabaa$","^aabaaabaacaabaaabaa$","^aabaaababcbabaaabaa$","^aabaaabbacabbaaabaa$","^aabaaabbbcbbbaaabaa$","^aabaabaaacaaabaabaa$","^aabaabaabcbaabaabaa$","^aabaababacababaabaa$","^aabaababbcbbabaabaa$","^aabaabbaacaabbaabaa$","^aabaabbabcbabbaabaa$","^aabaabbbacabbbaabaa$","^aabaabbbbcbbbbaabaa$","^aababaaaacaaaababaa$","^aababaaabcbaaababaa$","^aababaabacabaababaa$","^aababaabbcbbaababaa$","^aabababaacaabababaa$","^aababababcbabababaa$","^aabababbacabbababaa$","^aabababbbcbbbababaa$","^aababbaaacaaabbabaa$","^aababbaabcbaabbabaa$","^aababbabacababbabaa$","^aababbabbcbbabbabaa$","^aababbbaacaabbbabaa$","^aababbbabcbabbbabaa$","^aababbbbacabbbbabaa$","^aababbbbbcbbbbbabaa$","^aabbaaaaacaaaaabbaa$","^aabbaaaabcbaaaabbaa$","^aabbaaabacabaaabbaa$","^aabbaaabbcbbaaabbaa$","^aabbaabaacaabaabbaa$","^aabbaababcbabaabbaa$","^aabbaabbacabbaabbaa$","^aabbaabbbcbbbaabbaa$","^aabbabaaacaaababbaa$","^aabbabaabcbaababbaa$","^aabbababacabababbaa$","^aabbababbcbbababbaa$","^aabbabbaacaabbabbaa$","^aabbabbabcbabbabbaa$","^aabbabbbacabbbabbaa$","^aabbabbbbcbbbbabbaa$","^aabbbaaaacaaaabbbaa$","^aabbbaaabcbaaabbbaa$","^aabbbaabacabaabbbaa$","^aabbbaabbcbbaabbbaa$","^aabbbabaacaababbbaa$","^aabbbababcbababbbaa$","^aabbbabbacabbabbbaa$","^aabbbabbbcbbbabbbaa$","^aabbbbaaacaaabbbbaa$","^aabbbbaabcbaabbbbaa$","^aabbbbabacababbbbaa$","^aabbbbabbcbbabbbbaa$","^aabbbbbaacaabbbbbaa$","^aabbbbbabcbabbbbbaa$","^aabbbbbbacabbbbbbaa$","^aabbbbbbbcbbbbbbbaa$","^abaaaaaaacaaaaaaaba$","^abaaaaaabcbaaaaaaba$","^abaaaaabacabaaaaaba$","^abaaaaabbcbbaaaaaba$","^abaaaabaacaabaaaaba$","^abaaaababcbabaaaaba$","^abaaaabbacabbaaaaba$","^abaaaabbbcbbbaaaaba$","^abaaabaaacaaabaaaba$","^abaaabaabcbaabaaaba$","^abaaababacababaaaba$","^abaaababbcbbabaaaba$","^abaaabbaacaabbaaaba$","^abaaabbabcbabbaaaba$","^abaaabbbacabbbaaaba$","^abaaabbbbcbbbbaaaba$","^abaabaaaacaaaabaaba$","^abaabaaabcbaaabaaba$","^abaabaabacabaabaaba$","^abaabaabbcbbaabaaba$","^abaababaacaababaaba$","^abaabababcbababaaba$","^abaababbacabbabaaba$","^abaababbbcbbbabaaba$","^abaabbaaacaaabbaaba$","^abaabbaabcbaabbaaba$","^abaabbabacababbaaba$","^abaabbabbcbbabbaaba$","^abaabbbaacaabbbaaba$","^abaabbbabcbabbbaaba$","^abaabbbbacabbbbaaba$","^abaabbbbbcbbbbbaaba$","^ababaaaaacaaaaababa$","^ababaaaabcbaaaababa$","^ababaaabacabaaababa$","^ababaaabbcbbaaababa$","^ababaabaacaabaababa$","^ababaababcbabaababa$","^ababaabbacabbaababa$","^ababaabbbcbbbaababa$","^abababaaacaaabababa$","^abababaabcbaabababa$","^ababababacababababa$","^ababababbcbbabababa$","^abababbaacaabbababa$","^abababbabcbabbababa$","^abababbbacabbbababa$","^abababbbbcbbbbababa$","^ababbaaaacaaaabbaba$","^ababbaaabcbaaabbaba$","^ababbaabacabaabbaba$","^ababbaabbcbbaabbaba$","^ababbabaacaababbaba$","^ababbababcbababbaba$","^ababbabbacabbabbaba$","^ababbabbbcbbbabbaba$","^ababbbaaacaaabbbaba$","^ababbbaabcbaabbbaba$","^ababbbabacababbbaba$","^ababbbabbcbbabbbaba$","^ababbbbaacaabbbbaba$","^ababbbbabcbabbbbaba$","^ababbbbbacabbbbbaba$","^ababbbbbbcbbbbbbaba$","^abbaaaaaacaaaaaabba$","^abbaaaaabcbaaaaabba$","^abbaaaabacabaaaabba$","^abbaaaabbcbbaaaabba$","^abbaaabaacaabaaabba$","^abbaaababcbabaaabba$","^abbaaabbacabbaaabba$","^abbaaabbbcbbbaaabba$","^abbaabaaacaaabaabba$","^abbaabaabcbaabaabba$","^abbaababacababaabba$","^abbaababbcbbabaabba$","^abbaabbaacaabbaabba$","^abbaabbabcbabbaabba$","^abbaabbbacabbbaabba$","^abbaabbbbcbbbbaabba$","^abbabaaaacaaaababba$","^abbabaaabcbaaababba$","^abbabaabacabaababba$","^abbabaabbcbbaababba$","^abbababaacaabababba$","^abbabababcbabababba$","^abbababbacabbababba$","^abbababbbcbbbababba$","^abbabbaaacaaabbabba$","^abbabbaabcbaabbabba$","^abbabbabacababbabba$","^abbabbabbcbbabbabba$","^abbabbbaacaabbbabba$","^abbabbbabcbabbbabba$","^abbabbbbacabbbbabba$","^abbabbbbbcbbbbbabba$","^abbbaaaaacaaaaabbba$","^abbbaaaabcbaaaabbba$","^abbbaaabacabaaabbba$","^abbbaaabbcbbaaabbba$","^abbbaabaacaabaabbba$","^abbbaababcbabaabbba$","^abbbaabbacabbaabbba$","^abbbaabbbcbbbaabbba$","^abbbabaaacaaababbba$","^abbbabaabcbaababbba$","^abbbababacabababbba$","^abbbababbcbbababbba$","^abbbabbaacaabbabbba$","^abbbabbabcbabbabbba$","^abbbabbbacabbbabbba$","^abbbabbbbcbbbbabbba$","^abbbbaaaacaaaabbbba$","^abbbbaaabcbaaabbbba$","^abbbbaabacabaabbbba$","^abbbbaabbcbbaabbbba$","^abbbbabaacaababbbba$","^abbbbababcbababbbba$","^abbbbabbacabbabbbba$","^abbbbabbbcbbbabbbba$","^abbbbbaaacaaabbbbba$","^abbbbbaabcbaabbbbba$","^abbbbbabacababbbbba$","^abbbbbabbcbbabbbbba$","^abbbbbbaacaabbbbbba$","^abbbbbbabcbabbbbbba$","^abbbbbbbacabbbbbbba$","^abbbbbbbbcbbbbbbbba$","^baaaaaaaacaaaaaaaab$","^baaaaaaabcbaaaaaaab$","^baaaaaabacabaaaaaab$","^baaaaaabbcbbaaaaaab$","^baaaaabaacaabaaaaab$","^baaaaababcbabaaaaab$","^baaaaabbacabbaaaaab$","^baaaaabbbcbbbaaaaab$","^baaaabaaacaaabaaaab$","^baaaabaabcbaabaaaab$","^baaaababacababaaaab$","^baaaababbcbbabaaaab$","^baaaabbaacaabbaaaab$","^baaaabbabcbabbaaaab$","^baaaabbbacabbbaaaab$","^baaaabbbbcbbbbaaaab$","^baaabaaaacaaaabaaab$","^baaabaaabcbaaabaaab$","^baaabaabacabaabaaab$","^baaabaabbcbbaabaaab$","^baaababaacaababaaab$","^baaabababcbababaaab$","^baaababbacabbabaaab$","^baaababbbcbbbabaaab$","^baaabbaaacaaabbaaab$","^baaabbaabcbaabbaaab$","^baaabbabacababbaaab$","^baaabbabbcbbabbaaab$","^baaabbbaacaabbbaaab$","^baaabbbabcbabbbaaab$","^baaabbbbacabbbbaaab$","^baaabbbbbcbbbbbaaab$","^baabaaaaacaaaaabaab$","^baabaaaabcbaaaabaab$","^baabaaabacabaaabaab$","^baabaaabbcbbaaabaab$","^baabaabaacaabaabaab$","^baabaababcbabaabaab$","^baabaabbacabbaabaab$","^baabaabbbcbbbaabaab$","^baababaaacaaababaab$","^baababaabcbaababaab$","^baabababacabababaab$","^baabababbcbbababaab$","^baababbaacaabbabaab$","^baababbabcbabbabaab$","^baababbbacabbbabaab$","^baababbbbcbbbbabaab$","^baabbaaaacaaaabbaab$","^baabbaaabcbaaabbaab$","^baabbaabacabaabbaab$","^baabbaabbcbbaabbaab$","^baabbabaacaababbaab$","^baabbababcbababbaab$","^baabbabbacabbabbaab$","^baabbabbbcbbbabbaab$","^baabbbaaacaaabbbaab$","^baabbbaabcbaabbbaab$","^baabbbabacababbbaab$","^baabbbabbcbbabbbaab$","^baabbbbaacaabbbbaab$","^baabbbbabcbabbbbaab$","^baabbbbbacabbbbbaab$","^baabbbbbbcbbbbbbaab$","^babaaaaaacaaaaaabab$","^babaaaaabcbaaaaabab$","^babaaaabacabaaaabab$","^babaaaabbcbbaaaabab$","^babaaabaacaabaaabab$","^babaaababcbabaaabab$","^babaaabbacabbaaabab$","^babaaabbbcbbbaaabab$","^babaabaaacaaabaabab$","^babaabaabcbaabaabab$","^babaababacababaabab$","^babaababbcbbabaabab$","^babaabbaacaabbaabab$","^babaabbabcbabbaabab$","^babaabbbacabbbaabab$","^babaabbbbcbbbbaabab$","^bababaaaacaaaababab$","^bababaaabcbaaababab$","^bababaabacabaababab$","^bababaabbcbbaababab$","^babababaacaabababab$","^bababababcbabababab$","^babababbacabbababab$","^babababbbcbbbababab$","^bababbaaacaaabbabab$","^bababbaabcbaabbabab$","^bababbabacababbabab$","^bababbabbcbbabbabab$","^bababbbaacaabbbabab$","^bababbbabcbabbbabab$","^bababbbbacabbbbabab$","^bababbbbbcbbbbbabab$","^babbaaaaacaaaaabbab$","^babbaaaabcbaaaabbab$","^babbaaabacabaaabbab$","^babbaaabbcbbaaabbab$","^babbaabaacaabaabbab$","^babbaababcbabaabbab$","^babbaabbacabbaabbab$","^babbaabbbcbbbaabbab$","^babbabaaacaaababbab$","^babbabaabcbaababbab$","^babbababacabababbab$","^babbababbcbbababbab$","^babbabbaacaabbabbab$","^babbabbabcbabbabbab$","^babbabbbacabbbabbab$","^babbabbbbcbbbbabbab$","^babbbaaaacaaaabbbab$","^babbbaaabcbaaabbbab$","^babbbaabacabaabbbab$","^babbbaabbcbbaabbbab$","^babbbabaacaababbbab$","^babbbababcbababbbab$","^babbbabbacabbabbbab$","^babbbabbbcbbbabbbab$","^babbbbaaacaaabbbbab$","^babbbbaabcbaabbbbab$","^babbbbabacababbbbab$","^babbbbabbcbbabbbbab$","^babbbbbaacaabbbbbab$","^babbbbbabcbabbbbbab$","^babbbbbbacabbbbbbab$","^babbbbbbbcbbbbbbbab$","^bbaaaaaaacaaaaaaabb$","^bbaaaaaabcbaaaaaabb$","^bbaaaaabacabaaaaabb$","^bbaaaaabbcbbaaaaabb$","^bbaaaabaacaabaaaabb$","^bbaaaababcbabaaaabb$","^bbaaaabbacabbaaaabb$","^bbaaaabbbcbbbaaaabb$","^bbaaabaaacaaabaaabb$","^bbaaabaabcbaabaaabb$","^bbaaababacababaaabb$","^bbaaababbcbbabaaabb$","^bbaaabbaacaabbaaabb$","^bbaaabbabcbabbaaabb$","^bbaaabbbacabbbaaabb$","^bbaaabbbbcbbbbaaabb$","^bbaabaaaacaaaabaabb$","^bbaabaaabcbaaabaabb$","^bbaabaabacabaabaabb$","^bbaabaabbcbbaabaabb$","^bbaababaacaababaabb$","^bbaabababcbababaabb$","^bbaababbacabbabaabb$","^bbaababbbcbbbabaabb$","^bbaabbaaacaaabbaabb$","^bbaabbaabcbaabbaabb$","^bbaabbabacababbaabb$","^bbaabbabbcbbabbaabb$","^bbaabbbaacaabbbaabb$","^bbaabbbabcbabbbaabb$","^bbaabbbbacabbbbaabb$","^bbaabbbbbcbbbbbaabb$","^bbabaaaaacaaaaababb$","^bbabaaaabcbaaaababb$","^bbabaaabacabaaababb$","^bbabaaabbcbbaaababb$","^bbabaabaacaabaababb$","^bbabaababcbabaababb$","^bbabaabbacabbaababb$","^bbabaabbbcbbbaababb$","^bbababaaacaaabababb$","^bbababaabcbaabababb$","^bbabababacababababb$","^bbabababbcbbabababb$","^bbababbaacaabbababb$","^bbababbabcbabbababb$","^bbababbbacabbbababb$","^bbababbbbcbbbbababb$","^bbabbaaaacaaaabbabb$","^bbabbaaabcbaaabbabb$","^bbabbaabacabaabbabb$","^bbabbaabbcbbaabbabb$","^bbabbabaacaababbabb$","^bbabbababcbababbabb$","^bbabbabbacabbabbabb$","^bbabbabbbcbbbabbabb$","^bbabbbaaacaaabbbabb$","^bbabbbaabcbaabbbabb$","^bbabbbabacababbbabb$","^bbabbbabbcbbabbbabb$","^bbabbbbaacaabbbbabb$","^bbabbbbabcbabbbbabb$","^bbabbbbbacabbbbbabb$","^bbabbbbbbcbbbbbbabb$","^bbbaaaaaacaaaaaabbb$","^bbbaaaaabcbaaaaabbb$","^bbbaaaabacabaaaabbb$","^bbbaaaabbcbbaaaabbb$","^bbbaaabaacaabaaabbb$","^bbbaaababcbabaaabbb$","^bbbaaabbacabbaaabbb$","^bbbaaabbbcbbbaaabbb$","^bbbaabaaacaaabaabbb$","^bbbaabaabcbaabaabbb$","^bbbaababacababaabbb$","^bbbaababbcbbabaabbb$","^bbbaabbaacaabbaabbb$","^bbbaabbabcbabbaabbb$","^bbbaabbbacabbbaabbb$","^bbbaabbbbcbbbbaabbb$","^bbbabaaaacaaaababbb$","^bbbabaaabcbaaababbb$","^bbbabaabacabaababbb$","^bbbabaabbcbbaababbb$","^bbbababaacaabababbb$","^bbbabababcbabababbb$","^bbbababbacabbababbb$","^bbbababbbcbbbababbb$","^bbbabbaaacaaabbabbb$","^bbbabbaabcbaabbabbb$","^bbbabbabacababbabbb$","^bbbabbabbcbbabbabbb$","^bbbabbbaacaabbbabbb$","^bbbabbbabcbabbbabbb$","^bbbabbbbacabbbbabbb$","^bbbabbbbbcbbbbbabbb$","^bbbbaaaaacaaaaabbbb$","^bbbbaaaabcbaaaabbbb$","^bbbbaaabacabaaabbbb$","^bbbbaaabbcbbaaabbbb$","^bbbbaabaacaabaabbbb$","^bbbbaababcbabaabbbb$","^bbbbaabbacabbaabbbb$","^bbbbaabbbcbbbaabbbb$","^bbbbabaaacaaababbbb$","^bbbbabaabcbaababbbb$"],"spec":{"machine":"PDA","rules":[[["^","INITIAL",null],["Q1",["push","$"]]],[["a","Q1","$"],["Q1",["push","a"]]],[["b","Q1","$"],["Q1",["push","b"]]],[["a","Q1","a"],["Q1",["push","a"]]],[["a","Q1","b"],["Q1",["push","a"]]],[["b","Q1","a"],["Q1",["push","b"]]],[["b","Q1","b"],["Q1",["push","b"]]],[["c","Q1","a"],["Q2","nullop"]],[["c","Q1","b"],["Q2","nullop"]],[["a","Q2","a"],["Q2","pop"]],[["b","Q2","b"],["Q2","pop"]],[["$","Q2","$"],["ACCEPT","pop"]]],"symbols":["^","a","b","c","$"]}} -------------------------------------------------------------------------------- /data/anbn_plus_progs.json: -------------------------------------------------------------------------------- 1 | {"sentences":["^ab$","^aabb$","^abab$","^aaabbb$","^aabbab$","^abaabb$","^ababab$","^aaaabbbb$","^aaabbbab$","^aabbaabb$","^aabbabab$","^abaaabbb$","^abaabbab$","^ababaabb$","^abababab$","^aaaaabbbbb$","^aaaabbbbab$","^aaabbbaabb$","^aaabbbabab$","^aabbaaabbb$","^aabbaabbab$","^aabbabaabb$","^aabbababab$","^abaaaabbbb$","^abaaabbbab$","^abaabbaabb$","^abaabbabab$","^ababaaabbb$","^ababaabbab$","^abababaabb$","^ababababab$","^aaaaaabbbbbb$","^aaaaabbbbbab$","^aaaabbbbaabb$","^aaaabbbbabab$","^aaabbbaaabbb$","^aaabbbaabbab$","^aaabbbabaabb$","^aaabbbababab$","^aabbaaaabbbb$","^aabbaaabbbab$","^aabbaabbaabb$","^aabbaabbabab$","^aabbabaaabbb$","^aabbabaabbab$","^aabbababaabb$","^aabbabababab$","^abaaaaabbbbb$","^abaaaabbbbab$","^abaaabbbaabb$","^abaaabbbabab$","^abaabbaaabbb$","^abaabbaabbab$","^abaabbabaabb$","^abaabbababab$","^ababaaaabbbb$","^ababaaabbbab$","^ababaabbaabb$","^ababaabbabab$","^abababaaabbb$","^abababaabbab$","^ababababaabb$","^abababababab$","^aaaaaaabbbbbbb$","^aaaaaabbbbbbab$","^aaaaabbbbbaabb$","^aaaaabbbbbabab$","^aaaabbbbaaabbb$","^aaaabbbbaabbab$","^aaaabbbbabaabb$","^aaaabbbbababab$","^aaabbbaaaabbbb$","^aaabbbaaabbbab$","^aaabbbaabbaabb$","^aaabbbaabbabab$","^aaabbbabaaabbb$","^aaabbbabaabbab$","^aaabbbababaabb$","^aaabbbabababab$","^aabbaaaaabbbbb$","^aabbaaaabbbbab$","^aabbaaabbbaabb$","^aabbaaabbbabab$","^aabbaabbaaabbb$","^aabbaabbaabbab$","^aabbaabbabaabb$","^aabbaabbababab$","^aabbabaaaabbbb$","^aabbabaaabbbab$","^aabbabaabbaabb$","^aabbabaabbabab$","^aabbababaaabbb$","^aabbababaabbab$","^aabbabababaabb$","^aabbababababab$","^abaaaaaabbbbbb$","^abaaaaabbbbbab$","^abaaaabbbbaabb$","^abaaaabbbbabab$","^abaaabbbaaabbb$","^abaaabbbaabbab$","^abaaabbbabaabb$","^abaaabbbababab$","^abaabbaaaabbbb$","^abaabbaaabbbab$","^abaabbaabbaabb$","^abaabbaabbabab$","^abaabbabaaabbb$","^abaabbabaabbab$","^abaabbababaabb$","^abaabbabababab$","^ababaaaaabbbbb$","^ababaaaabbbbab$","^ababaaabbbaabb$","^ababaaabbbabab$","^ababaabbaaabbb$","^ababaabbaabbab$","^ababaabbabaabb$","^ababaabbababab$","^abababaaaabbbb$","^abababaaabbbab$","^abababaabbaabb$","^abababaabbabab$","^ababababaaabbb$","^ababababaabbab$","^abababababaabb$","^ababababababab$","^aaaaaaaabbbbbbbb$","^aaaaaaabbbbbbbab$","^aaaaaabbbbbbaabb$","^aaaaaabbbbbbabab$","^aaaaabbbbbaaabbb$","^aaaaabbbbbaabbab$","^aaaaabbbbbabaabb$","^aaaaabbbbbababab$","^aaaabbbbaaaabbbb$","^aaaabbbbaaabbbab$","^aaaabbbbaabbaabb$","^aaaabbbbaabbabab$","^aaaabbbbabaaabbb$","^aaaabbbbabaabbab$","^aaaabbbbababaabb$","^aaaabbbbabababab$","^aaabbbaaaaabbbbb$","^aaabbbaaaabbbbab$","^aaabbbaaabbbaabb$","^aaabbbaaabbbabab$","^aaabbbaabbaaabbb$","^aaabbbaabbaabbab$","^aaabbbaabbabaabb$","^aaabbbaabbababab$","^aaabbbabaaaabbbb$","^aaabbbabaaabbbab$","^aaabbbabaabbaabb$","^aaabbbabaabbabab$","^aaabbbababaaabbb$","^aaabbbababaabbab$","^aaabbbabababaabb$","^aaabbbababababab$","^aabbaaaaaabbbbbb$","^aabbaaaaabbbbbab$","^aabbaaaabbbbaabb$","^aabbaaaabbbbabab$","^aabbaaabbbaaabbb$","^aabbaaabbbaabbab$","^aabbaaabbbabaabb$","^aabbaaabbbababab$","^aabbaabbaaaabbbb$","^aabbaabbaaabbbab$","^aabbaabbaabbaabb$","^aabbaabbaabbabab$","^aabbaabbabaaabbb$","^aabbaabbabaabbab$","^aabbaabbababaabb$","^aabbaabbabababab$","^aabbabaaaaabbbbb$","^aabbabaaaabbbbab$","^aabbabaaabbbaabb$","^aabbabaaabbbabab$","^aabbabaabbaaabbb$","^aabbabaabbaabbab$","^aabbabaabbabaabb$","^aabbabaabbababab$","^aabbababaaaabbbb$","^aabbababaaabbbab$","^aabbababaabbaabb$","^aabbababaabbabab$","^aabbabababaaabbb$","^aabbabababaabbab$","^aabbababababaabb$","^aabbabababababab$","^abaaaaaaabbbbbbb$","^abaaaaaabbbbbbab$","^abaaaaabbbbbaabb$","^abaaaaabbbbbabab$","^abaaaabbbbaaabbb$","^abaaaabbbbaabbab$","^abaaaabbbbabaabb$","^abaaaabbbbababab$","^abaaabbbaaaabbbb$","^abaaabbbaaabbbab$","^abaaabbbaabbaabb$","^abaaabbbaabbabab$","^abaaabbbabaaabbb$","^abaaabbbabaabbab$","^abaaabbbababaabb$","^abaaabbbabababab$","^abaabbaaaaabbbbb$","^abaabbaaaabbbbab$","^abaabbaaabbbaabb$","^abaabbaaabbbabab$","^abaabbaabbaaabbb$","^abaabbaabbaabbab$","^abaabbaabbabaabb$","^abaabbaabbababab$","^abaabbabaaaabbbb$","^abaabbabaaabbbab$","^abaabbabaabbaabb$","^abaabbabaabbabab$","^abaabbababaaabbb$","^abaabbababaabbab$","^abaabbabababaabb$","^abaabbababababab$","^ababaaaaaabbbbbb$","^ababaaaaabbbbbab$","^ababaaaabbbbaabb$","^ababaaaabbbbabab$","^ababaaabbbaaabbb$","^ababaaabbbaabbab$","^ababaaabbbabaabb$","^ababaaabbbababab$","^ababaabbaaaabbbb$","^ababaabbaaabbbab$","^ababaabbaabbaabb$","^ababaabbaabbabab$","^ababaabbabaaabbb$","^ababaabbabaabbab$","^ababaabbababaabb$","^ababaabbabababab$","^abababaaaaabbbbb$","^abababaaaabbbbab$","^abababaaabbbaabb$","^abababaaabbbabab$","^abababaabbaaabbb$","^abababaabbaabbab$","^abababaabbabaabb$","^abababaabbababab$","^ababababaaaabbbb$","^ababababaaabbbab$","^ababababaabbaabb$","^ababababaabbabab$","^abababababaaabbb$","^abababababaabbab$","^ababababababaabb$","^abababababababab$","^aaaaaaaaabbbbbbbbb$","^aaaaaaaabbbbbbbbab$","^aaaaaaabbbbbbbaabb$","^aaaaaaabbbbbbbabab$","^aaaaaabbbbbbaaabbb$","^aaaaaabbbbbbaabbab$","^aaaaaabbbbbbabaabb$","^aaaaaabbbbbbababab$","^aaaaabbbbbaaaabbbb$","^aaaaabbbbbaaabbbab$","^aaaaabbbbbaabbaabb$","^aaaaabbbbbaabbabab$","^aaaaabbbbbabaaabbb$","^aaaaabbbbbabaabbab$","^aaaaabbbbbababaabb$","^aaaaabbbbbabababab$","^aaaabbbbaaaaabbbbb$","^aaaabbbbaaaabbbbab$","^aaaabbbbaaabbbaabb$","^aaaabbbbaaabbbabab$","^aaaabbbbaabbaaabbb$","^aaaabbbbaabbaabbab$","^aaaabbbbaabbabaabb$","^aaaabbbbaabbababab$","^aaaabbbbabaaaabbbb$","^aaaabbbbabaaabbbab$","^aaaabbbbabaabbaabb$","^aaaabbbbabaabbabab$","^aaaabbbbababaaabbb$","^aaaabbbbababaabbab$","^aaaabbbbabababaabb$","^aaaabbbbababababab$","^aaabbbaaaaaabbbbbb$","^aaabbbaaaaabbbbbab$","^aaabbbaaaabbbbaabb$","^aaabbbaaaabbbbabab$","^aaabbbaaabbbaaabbb$","^aaabbbaaabbbaabbab$","^aaabbbaaabbbabaabb$","^aaabbbaaabbbababab$","^aaabbbaabbaaaabbbb$","^aaabbbaabbaaabbbab$","^aaabbbaabbaabbaabb$","^aaabbbaabbaabbabab$","^aaabbbaabbabaaabbb$","^aaabbbaabbabaabbab$","^aaabbbaabbababaabb$","^aaabbbaabbabababab$","^aaabbbabaaaaabbbbb$","^aaabbbabaaaabbbbab$","^aaabbbabaaabbbaabb$","^aaabbbabaaabbbabab$","^aaabbbabaabbaaabbb$","^aaabbbabaabbaabbab$","^aaabbbabaabbabaabb$","^aaabbbabaabbababab$","^aaabbbababaaaabbbb$","^aaabbbababaaabbbab$","^aaabbbababaabbaabb$","^aaabbbababaabbabab$","^aaabbbabababaaabbb$","^aaabbbabababaabbab$","^aaabbbababababaabb$","^aaabbbabababababab$","^aabbaaaaaaabbbbbbb$","^aabbaaaaaabbbbbbab$","^aabbaaaaabbbbbaabb$","^aabbaaaaabbbbbabab$","^aabbaaaabbbbaaabbb$","^aabbaaaabbbbaabbab$","^aabbaaaabbbbabaabb$","^aabbaaaabbbbababab$","^aabbaaabbbaaaabbbb$","^aabbaaabbbaaabbbab$","^aabbaaabbbaabbaabb$","^aabbaaabbbaabbabab$","^aabbaaabbbabaaabbb$","^aabbaaabbbabaabbab$","^aabbaaabbbababaabb$","^aabbaaabbbabababab$","^aabbaabbaaaaabbbbb$","^aabbaabbaaaabbbbab$","^aabbaabbaaabbbaabb$","^aabbaabbaaabbbabab$","^aabbaabbaabbaaabbb$","^aabbaabbaabbaabbab$","^aabbaabbaabbabaabb$","^aabbaabbaabbababab$","^aabbaabbabaaaabbbb$","^aabbaabbabaaabbbab$","^aabbaabbabaabbaabb$","^aabbaabbabaabbabab$","^aabbaabbababaaabbb$","^aabbaabbababaabbab$","^aabbaabbabababaabb$","^aabbaabbababababab$","^aabbabaaaaaabbbbbb$","^aabbabaaaaabbbbbab$","^aabbabaaaabbbbaabb$","^aabbabaaaabbbbabab$","^aabbabaaabbbaaabbb$","^aabbabaaabbbaabbab$","^aabbabaaabbbabaabb$","^aabbabaaabbbababab$","^aabbabaabbaaaabbbb$","^aabbabaabbaaabbbab$","^aabbabaabbaabbaabb$","^aabbabaabbaabbabab$","^aabbabaabbabaaabbb$","^aabbabaabbabaabbab$","^aabbabaabbababaabb$","^aabbabaabbabababab$","^aabbababaaaaabbbbb$","^aabbababaaaabbbbab$","^aabbababaaabbbaabb$","^aabbababaaabbbabab$","^aabbababaabbaaabbb$","^aabbababaabbaabbab$","^aabbababaabbabaabb$","^aabbababaabbababab$","^aabbabababaaaabbbb$","^aabbabababaaabbbab$","^aabbabababaabbaabb$","^aabbabababaabbabab$","^aabbababababaaabbb$","^aabbababababaabbab$","^aabbabababababaabb$","^aabbababababababab$","^abaaaaaaaabbbbbbbb$","^abaaaaaaabbbbbbbab$","^abaaaaaabbbbbbaabb$","^abaaaaaabbbbbbabab$","^abaaaaabbbbbaaabbb$","^abaaaaabbbbbaabbab$","^abaaaaabbbbbabaabb$","^abaaaaabbbbbababab$","^abaaaabbbbaaaabbbb$","^abaaaabbbbaaabbbab$","^abaaaabbbbaabbaabb$","^abaaaabbbbaabbabab$","^abaaaabbbbabaaabbb$","^abaaaabbbbabaabbab$","^abaaaabbbbababaabb$","^abaaaabbbbabababab$","^abaaabbbaaaaabbbbb$","^abaaabbbaaaabbbbab$","^abaaabbbaaabbbaabb$","^abaaabbbaaabbbabab$","^abaaabbbaabbaaabbb$","^abaaabbbaabbaabbab$","^abaaabbbaabbabaabb$","^abaaabbbaabbababab$","^abaaabbbabaaaabbbb$","^abaaabbbabaaabbbab$","^abaaabbbabaabbaabb$","^abaaabbbabaabbabab$","^abaaabbbababaaabbb$","^abaaabbbababaabbab$","^abaaabbbabababaabb$","^abaaabbbababababab$","^abaabbaaaaaabbbbbb$","^abaabbaaaaabbbbbab$","^abaabbaaaabbbbaabb$","^abaabbaaaabbbbabab$","^abaabbaaabbbaaabbb$","^abaabbaaabbbaabbab$","^abaabbaaabbbabaabb$","^abaabbaaabbbababab$","^abaabbaabbaaaabbbb$","^abaabbaabbaaabbbab$","^abaabbaabbaabbaabb$","^abaabbaabbaabbabab$","^abaabbaabbabaaabbb$","^abaabbaabbabaabbab$","^abaabbaabbababaabb$","^abaabbaabbabababab$","^abaabbabaaaaabbbbb$","^abaabbabaaaabbbbab$","^abaabbabaaabbbaabb$","^abaabbabaaabbbabab$","^abaabbabaabbaaabbb$","^abaabbabaabbaabbab$","^abaabbabaabbabaabb$","^abaabbabaabbababab$","^abaabbababaaaabbbb$","^abaabbababaaabbbab$","^abaabbababaabbaabb$","^abaabbababaabbabab$","^abaabbabababaaabbb$","^abaabbabababaabbab$","^abaabbababababaabb$","^abaabbabababababab$","^ababaaaaaaabbbbbbb$","^ababaaaaaabbbbbbab$","^ababaaaaabbbbbaabb$","^ababaaaaabbbbbabab$","^ababaaaabbbbaaabbb$","^ababaaaabbbbaabbab$","^ababaaaabbbbabaabb$","^ababaaaabbbbababab$","^ababaaabbbaaaabbbb$","^ababaaabbbaaabbbab$","^ababaaabbbaabbaabb$","^ababaaabbbaabbabab$","^ababaaabbbabaaabbb$","^ababaaabbbabaabbab$","^ababaaabbbababaabb$","^ababaaabbbabababab$","^ababaabbaaaaabbbbb$","^ababaabbaaaabbbbab$","^ababaabbaaabbbaabb$","^ababaabbaaabbbabab$","^ababaabbaabbaaabbb$","^ababaabbaabbaabbab$","^ababaabbaabbabaabb$","^ababaabbaabbababab$","^ababaabbabaaaabbbb$","^ababaabbabaaabbbab$","^ababaabbabaabbaabb$","^ababaabbabaabbabab$","^ababaabbababaaabbb$","^ababaabbababaabbab$","^ababaabbabababaabb$","^ababaabbababababab$","^abababaaaaaabbbbbb$","^abababaaaaabbbbbab$","^abababaaaabbbbaabb$","^abababaaaabbbbabab$","^abababaaabbbaaabbb$","^abababaaabbbaabbab$","^abababaaabbbabaabb$","^abababaaabbbababab$","^abababaabbaaaabbbb$","^abababaabbaaabbbab$","^abababaabbaabbaabb$","^abababaabbaabbabab$","^abababaabbabaaabbb$","^abababaabbabaabbab$","^abababaabbababaabb$","^abababaabbabababab$","^ababababaaaaabbbbb$","^ababababaaaabbbbab$","^ababababaaabbbaabb$","^ababababaaabbbabab$","^ababababaabbaaabbb$","^ababababaabbaabbab$","^ababababaabbabaabb$","^ababababaabbababab$","^abababababaaaabbbb$","^abababababaaabbbab$","^abababababaabbaabb$","^abababababaabbabab$","^ababababababaaabbb$","^ababababababaabbab$","^abababababababaabb$","^ababababababababab$","^aaaaaaaaaabbbbbbbbbb$","^aaaaaaaaabbbbbbbbbab$","^aaaaaaaabbbbbbbbaabb$","^aaaaaaaabbbbbbbbabab$","^aaaaaaabbbbbbbaaabbb$","^aaaaaaabbbbbbbaabbab$","^aaaaaaabbbbbbbabaabb$","^aaaaaaabbbbbbbababab$","^aaaaaabbbbbbaaaabbbb$","^aaaaaabbbbbbaaabbbab$","^aaaaaabbbbbbaabbaabb$","^aaaaaabbbbbbaabbabab$","^aaaaaabbbbbbabaaabbb$","^aaaaaabbbbbbabaabbab$","^aaaaaabbbbbbababaabb$","^aaaaaabbbbbbabababab$","^aaaaabbbbbaaaaabbbbb$","^aaaaabbbbbaaaabbbbab$","^aaaaabbbbbaaabbbaabb$","^aaaaabbbbbaaabbbabab$","^aaaaabbbbbaabbaaabbb$","^aaaaabbbbbaabbaabbab$","^aaaaabbbbbaabbabaabb$","^aaaaabbbbbaabbababab$","^aaaaabbbbbabaaaabbbb$","^aaaaabbbbbabaaabbbab$","^aaaaabbbbbabaabbaabb$","^aaaaabbbbbabaabbabab$","^aaaaabbbbbababaaabbb$","^aaaaabbbbbababaabbab$","^aaaaabbbbbabababaabb$","^aaaaabbbbbababababab$","^aaaabbbbaaaaaabbbbbb$","^aaaabbbbaaaaabbbbbab$","^aaaabbbbaaaabbbbaabb$","^aaaabbbbaaaabbbbabab$","^aaaabbbbaaabbbaaabbb$","^aaaabbbbaaabbbaabbab$","^aaaabbbbaaabbbabaabb$","^aaaabbbbaaabbbababab$","^aaaabbbbaabbaaaabbbb$","^aaaabbbbaabbaaabbbab$","^aaaabbbbaabbaabbaabb$","^aaaabbbbaabbaabbabab$","^aaaabbbbaabbabaaabbb$","^aaaabbbbaabbabaabbab$","^aaaabbbbaabbababaabb$","^aaaabbbbaabbabababab$","^aaaabbbbabaaaaabbbbb$","^aaaabbbbabaaaabbbbab$","^aaaabbbbabaaabbbaabb$","^aaaabbbbabaaabbbabab$","^aaaabbbbabaabbaaabbb$","^aaaabbbbabaabbaabbab$","^aaaabbbbabaabbabaabb$","^aaaabbbbabaabbababab$","^aaaabbbbababaaaabbbb$","^aaaabbbbababaaabbbab$","^aaaabbbbababaabbaabb$","^aaaabbbbababaabbabab$","^aaaabbbbabababaaabbb$","^aaaabbbbabababaabbab$","^aaaabbbbababababaabb$","^aaaabbbbabababababab$","^aaabbbaaaaaaabbbbbbb$","^aaabbbaaaaaabbbbbbab$","^aaabbbaaaaabbbbbaabb$","^aaabbbaaaaabbbbbabab$","^aaabbbaaaabbbbaaabbb$","^aaabbbaaaabbbbaabbab$","^aaabbbaaaabbbbabaabb$","^aaabbbaaaabbbbababab$","^aaabbbaaabbbaaaabbbb$","^aaabbbaaabbbaaabbbab$","^aaabbbaaabbbaabbaabb$","^aaabbbaaabbbaabbabab$","^aaabbbaaabbbabaaabbb$","^aaabbbaaabbbabaabbab$","^aaabbbaaabbbababaabb$","^aaabbbaaabbbabababab$","^aaabbbaabbaaaaabbbbb$","^aaabbbaabbaaaabbbbab$","^aaabbbaabbaaabbbaabb$","^aaabbbaabbaaabbbabab$","^aaabbbaabbaabbaaabbb$","^aaabbbaabbaabbaabbab$","^aaabbbaabbaabbabaabb$","^aaabbbaabbaabbababab$","^aaabbbaabbabaaaabbbb$","^aaabbbaabbabaaabbbab$","^aaabbbaabbabaabbaabb$","^aaabbbaabbabaabbabab$","^aaabbbaabbababaaabbb$","^aaabbbaabbababaabbab$","^aaabbbaabbabababaabb$","^aaabbbaabbababababab$","^aaabbbabaaaaaabbbbbb$","^aaabbbabaaaaabbbbbab$","^aaabbbabaaaabbbbaabb$","^aaabbbabaaaabbbbabab$","^aaabbbabaaabbbaaabbb$","^aaabbbabaaabbbaabbab$","^aaabbbabaaabbbabaabb$","^aaabbbabaaabbbababab$","^aaabbbabaabbaaaabbbb$","^aaabbbabaabbaaabbbab$","^aaabbbabaabbaabbaabb$","^aaabbbabaabbaabbabab$","^aaabbbabaabbabaaabbb$","^aaabbbabaabbabaabbab$","^aaabbbabaabbababaabb$","^aaabbbabaabbabababab$","^aaabbbababaaaaabbbbb$","^aaabbbababaaaabbbbab$","^aaabbbababaaabbbaabb$","^aaabbbababaaabbbabab$","^aaabbbababaabbaaabbb$","^aaabbbababaabbaabbab$","^aaabbbababaabbabaabb$","^aaabbbababaabbababab$","^aaabbbabababaaaabbbb$","^aaabbbabababaaabbbab$","^aaabbbabababaabbaabb$","^aaabbbabababaabbabab$","^aaabbbababababaaabbb$","^aaabbbababababaabbab$","^aaabbbabababababaabb$","^aaabbbababababababab$","^aabbaaaaaaaabbbbbbbb$","^aabbaaaaaaabbbbbbbab$","^aabbaaaaaabbbbbbaabb$","^aabbaaaaaabbbbbbabab$","^aabbaaaaabbbbbaaabbb$","^aabbaaaaabbbbbaabbab$","^aabbaaaaabbbbbabaabb$","^aabbaaaaabbbbbababab$","^aabbaaaabbbbaaaabbbb$","^aabbaaaabbbbaaabbbab$","^aabbaaaabbbbaabbaabb$","^aabbaaaabbbbaabbabab$","^aabbaaaabbbbabaaabbb$","^aabbaaaabbbbabaabbab$","^aabbaaaabbbbababaabb$","^aabbaaaabbbbabababab$","^aabbaaabbbaaaaabbbbb$","^aabbaaabbbaaaabbbbab$","^aabbaaabbbaaabbbaabb$","^aabbaaabbbaaabbbabab$","^aabbaaabbbaabbaaabbb$","^aabbaaabbbaabbaabbab$","^aabbaaabbbaabbabaabb$","^aabbaaabbbaabbababab$","^aabbaaabbbabaaaabbbb$","^aabbaaabbbabaaabbbab$","^aabbaaabbbabaabbaabb$","^aabbaaabbbabaabbabab$","^aabbaaabbbababaaabbb$","^aabbaaabbbababaabbab$","^aabbaaabbbabababaabb$","^aabbaaabbbababababab$","^aabbaabbaaaaaabbbbbb$","^aabbaabbaaaaabbbbbab$","^aabbaabbaaaabbbbaabb$","^aabbaabbaaaabbbbabab$","^aabbaabbaaabbbaaabbb$","^aabbaabbaaabbbaabbab$","^aabbaabbaaabbbabaabb$","^aabbaabbaaabbbababab$","^aabbaabbaabbaaaabbbb$","^aabbaabbaabbaaabbbab$","^aabbaabbaabbaabbaabb$","^aabbaabbaabbaabbabab$","^aabbaabbaabbabaaabbb$","^aabbaabbaabbabaabbab$","^aabbaabbaabbababaabb$","^aabbaabbaabbabababab$","^aabbaabbabaaaaabbbbb$","^aabbaabbabaaaabbbbab$","^aabbaabbabaaabbbaabb$","^aabbaabbabaaabbbabab$","^aabbaabbabaabbaaabbb$","^aabbaabbabaabbaabbab$","^aabbaabbabaabbabaabb$","^aabbaabbabaabbababab$","^aabbaabbababaaaabbbb$","^aabbaabbababaaabbbab$","^aabbaabbababaabbaabb$","^aabbaabbababaabbabab$","^aabbaabbabababaaabbb$","^aabbaabbabababaabbab$","^aabbaabbababababaabb$","^aabbaabbabababababab$","^aabbabaaaaaaabbbbbbb$","^aabbabaaaaaabbbbbbab$","^aabbabaaaaabbbbbaabb$","^aabbabaaaaabbbbbabab$","^aabbabaaaabbbbaaabbb$","^aabbabaaaabbbbaabbab$","^aabbabaaaabbbbabaabb$","^aabbabaaaabbbbababab$","^aabbabaaabbbaaaabbbb$","^aabbabaaabbbaaabbbab$","^aabbabaaabbbaabbaabb$","^aabbabaaabbbaabbabab$","^aabbabaaabbbabaaabbb$","^aabbabaaabbbabaabbab$","^aabbabaaabbbababaabb$","^aabbabaaabbbabababab$","^aabbabaabbaaaaabbbbb$","^aabbabaabbaaaabbbbab$","^aabbabaabbaaabbbaabb$","^aabbabaabbaaabbbabab$","^aabbabaabbaabbaaabbb$","^aabbabaabbaabbaabbab$","^aabbabaabbaabbabaabb$","^aabbabaabbaabbababab$","^aabbabaabbabaaaabbbb$","^aabbabaabbabaaabbbab$","^aabbabaabbabaabbaabb$","^aabbabaabbabaabbabab$","^aabbabaabbababaaabbb$","^aabbabaabbababaabbab$","^aabbabaabbabababaabb$","^aabbabaabbababababab$","^aabbababaaaaaabbbbbb$","^aabbababaaaaabbbbbab$","^aabbababaaaabbbbaabb$","^aabbababaaaabbbbabab$","^aabbababaaabbbaaabbb$","^aabbababaaabbbaabbab$","^aabbababaaabbbabaabb$","^aabbababaaabbbababab$","^aabbababaabbaaaabbbb$","^aabbababaabbaaabbbab$","^aabbababaabbaabbaabb$","^aabbababaabbaabbabab$","^aabbababaabbabaaabbb$","^aabbababaabbabaabbab$","^aabbababaabbababaabb$","^aabbababaabbabababab$","^aabbabababaaaaabbbbb$","^aabbabababaaaabbbbab$","^aabbabababaaabbbaabb$","^aabbabababaaabbbabab$","^aabbabababaabbaaabbb$","^aabbabababaabbaabbab$","^aabbabababaabbabaabb$","^aabbabababaabbababab$","^aabbababababaaaabbbb$","^aabbababababaaabbbab$","^aabbababababaabbaabb$","^aabbababababaabbabab$","^aabbabababababaaabbb$","^aabbabababababaabbab$","^aabbababababababaabb$","^aabbabababababababab$","^abaaaaaaaaabbbbbbbbb$","^abaaaaaaaabbbbbbbbab$","^abaaaaaaabbbbbbbaabb$","^abaaaaaaabbbbbbbabab$","^abaaaaaabbbbbbaaabbb$","^abaaaaaabbbbbbaabbab$","^abaaaaaabbbbbbabaabb$","^abaaaaaabbbbbbababab$","^abaaaaabbbbbaaaabbbb$","^abaaaaabbbbbaaabbbab$","^abaaaaabbbbbaabbaabb$","^abaaaaabbbbbaabbabab$","^abaaaaabbbbbabaaabbb$","^abaaaaabbbbbabaabbab$","^abaaaaabbbbbababaabb$","^abaaaaabbbbbabababab$","^abaaaabbbbaaaaabbbbb$","^abaaaabbbbaaaabbbbab$","^abaaaabbbbaaabbbaabb$","^abaaaabbbbaaabbbabab$","^abaaaabbbbaabbaaabbb$","^abaaaabbbbaabbaabbab$","^abaaaabbbbaabbabaabb$","^abaaaabbbbaabbababab$","^abaaaabbbbabaaaabbbb$","^abaaaabbbbabaaabbbab$","^abaaaabbbbabaabbaabb$","^abaaaabbbbabaabbabab$","^abaaaabbbbababaaabbb$","^abaaaabbbbababaabbab$","^abaaaabbbbabababaabb$","^abaaaabbbbababababab$","^abaaabbbaaaaaabbbbbb$","^abaaabbbaaaaabbbbbab$","^abaaabbbaaaabbbbaabb$","^abaaabbbaaaabbbbabab$","^abaaabbbaaabbbaaabbb$","^abaaabbbaaabbbaabbab$","^abaaabbbaaabbbabaabb$","^abaaabbbaaabbbababab$","^abaaabbbaabbaaaabbbb$","^abaaabbbaabbaaabbbab$","^abaaabbbaabbaabbaabb$","^abaaabbbaabbaabbabab$","^abaaabbbaabbabaaabbb$","^abaaabbbaabbabaabbab$","^abaaabbbaabbababaabb$","^abaaabbbaabbabababab$","^abaaabbbabaaaaabbbbb$","^abaaabbbabaaaabbbbab$","^abaaabbbabaaabbbaabb$","^abaaabbbabaaabbbabab$","^abaaabbbabaabbaaabbb$","^abaaabbbabaabbaabbab$","^abaaabbbabaabbabaabb$","^abaaabbbabaabbababab$","^abaaabbbababaaaabbbb$","^abaaabbbababaaabbbab$","^abaaabbbababaabbaabb$","^abaaabbbababaabbabab$","^abaaabbbabababaaabbb$","^abaaabbbabababaabbab$","^abaaabbbababababaabb$","^abaaabbbabababababab$","^abaabbaaaaaaabbbbbbb$","^abaabbaaaaaabbbbbbab$","^abaabbaaaaabbbbbaabb$","^abaabbaaaaabbbbbabab$","^abaabbaaaabbbbaaabbb$","^abaabbaaaabbbbaabbab$","^abaabbaaaabbbbabaabb$","^abaabbaaaabbbbababab$","^abaabbaaabbbaaaabbbb$","^abaabbaaabbbaaabbbab$","^abaabbaaabbbaabbaabb$","^abaabbaaabbbaabbabab$","^abaabbaaabbbabaaabbb$","^abaabbaaabbbabaabbab$","^abaabbaaabbbababaabb$","^abaabbaaabbbabababab$","^abaabbaabbaaaaabbbbb$","^abaabbaabbaaaabbbbab$","^abaabbaabbaaabbbaabb$","^abaabbaabbaaabbbabab$","^abaabbaabbaabbaaabbb$","^abaabbaabbaabbaabbab$","^abaabbaabbaabbabaabb$","^abaabbaabbaabbababab$","^abaabbaabbabaaaabbbb$","^abaabbaabbabaaabbbab$","^abaabbaabbabaabbaabb$","^abaabbaabbabaabbabab$","^abaabbaabbababaaabbb$","^abaabbaabbababaabbab$","^abaabbaabbabababaabb$","^abaabbaabbababababab$","^abaabbabaaaaaabbbbbb$","^abaabbabaaaaabbbbbab$","^abaabbabaaaabbbbaabb$","^abaabbabaaaabbbbabab$","^abaabbabaaabbbaaabbb$","^abaabbabaaabbbaabbab$","^abaabbabaaabbbabaabb$","^abaabbabaaabbbababab$","^abaabbabaabbaaaabbbb$","^abaabbabaabbaaabbbab$","^abaabbabaabbaabbaabb$","^abaabbabaabbaabbabab$","^abaabbabaabbabaaabbb$","^abaabbabaabbabaabbab$","^abaabbabaabbababaabb$","^abaabbabaabbabababab$","^abaabbababaaaaabbbbb$","^abaabbababaaaabbbbab$","^abaabbababaaabbbaabb$","^abaabbababaaabbbabab$","^abaabbababaabbaaabbb$","^abaabbababaabbaabbab$","^abaabbababaabbabaabb$","^abaabbababaabbababab$","^abaabbabababaaaabbbb$","^abaabbabababaaabbbab$","^abaabbabababaabbaabb$","^abaabbabababaabbabab$","^abaabbababababaaabbb$","^abaabbababababaabbab$","^abaabbabababababaabb$","^abaabbababababababab$","^ababaaaaaaaabbbbbbbb$","^ababaaaaaaabbbbbbbab$","^ababaaaaaabbbbbbaabb$","^ababaaaaaabbbbbbabab$","^ababaaaaabbbbbaaabbb$","^ababaaaaabbbbbaabbab$","^ababaaaaabbbbbabaabb$","^ababaaaaabbbbbababab$","^ababaaaabbbbaaaabbbb$","^ababaaaabbbbaaabbbab$","^ababaaaabbbbaabbaabb$","^ababaaaabbbbaabbabab$","^ababaaaabbbbabaaabbb$","^ababaaaabbbbabaabbab$","^ababaaaabbbbababaabb$","^ababaaaabbbbabababab$","^ababaaabbbaaaaabbbbb$","^ababaaabbbaaaabbbbab$","^ababaaabbbaaabbbaabb$","^ababaaabbbaaabbbabab$","^ababaaabbbaabbaaabbb$","^ababaaabbbaabbaabbab$","^ababaaabbbaabbabaabb$","^ababaaabbbaabbababab$","^ababaaabbbabaaaabbbb$","^ababaaabbbabaaabbbab$","^ababaaabbbabaabbaabb$","^ababaaabbbabaabbabab$","^ababaaabbbababaaabbb$","^ababaaabbbababaabbab$","^ababaaabbbabababaabb$","^ababaaabbbababababab$","^ababaabbaaaaaabbbbbb$","^ababaabbaaaaabbbbbab$","^ababaabbaaaabbbbaabb$","^ababaabbaaaabbbbabab$","^ababaabbaaabbbaaabbb$","^ababaabbaaabbbaabbab$","^ababaabbaaabbbabaabb$","^ababaabbaaabbbababab$","^ababaabbaabbaaaabbbb$","^ababaabbaabbaaabbbab$","^ababaabbaabbaabbaabb$","^ababaabbaabbaabbabab$","^ababaabbaabbabaaabbb$","^ababaabbaabbabaabbab$","^ababaabbaabbababaabb$","^ababaabbaabbabababab$","^ababaabbabaaaaabbbbb$","^ababaabbabaaaabbbbab$","^ababaabbabaaabbbaabb$","^ababaabbabaaabbbabab$","^ababaabbabaabbaaabbb$","^ababaabbabaabbaabbab$","^ababaabbabaabbabaabb$","^ababaabbabaabbababab$","^ababaabbababaaaabbbb$","^ababaabbababaaabbbab$","^ababaabbababaabbaabb$","^ababaabbababaabbabab$","^ababaabbabababaaabbb$","^ababaabbabababaabbab$","^ababaabbababababaabb$","^ababaabbabababababab$","^abababaaaaaaabbbbbbb$","^abababaaaaaabbbbbbab$","^abababaaaaabbbbbaabb$","^abababaaaaabbbbbabab$","^abababaaaabbbbaaabbb$","^abababaaaabbbbaabbab$","^abababaaaabbbbabaabb$","^abababaaaabbbbababab$","^abababaaabbbaaaabbbb$","^abababaaabbbaaabbbab$","^abababaaabbbaabbaabb$","^abababaaabbbaabbabab$","^abababaaabbbabaaabbb$","^abababaaabbbabaabbab$","^abababaaabbbababaabb$","^abababaaabbbabababab$","^abababaabbaaaaabbbbb$","^abababaabbaaaabbbbab$","^abababaabbaaabbbaabb$","^abababaabbaaabbbabab$","^abababaabbaabbaaabbb$","^abababaabbaabbaabbab$","^abababaabbaabbabaabb$","^abababaabbaabbababab$","^abababaabbabaaaabbbb$","^abababaabbabaaabbbab$","^abababaabbabaabbaabb$","^abababaabbabaabbabab$","^abababaabbababaaabbb$","^abababaabbababaabbab$","^abababaabbabababaabb$","^abababaabbababababab$","^ababababaaaaaabbbbbb$","^ababababaaaaabbbbbab$","^ababababaaaabbbbaabb$","^ababababaaaabbbbabab$","^ababababaaabbbaaabbb$","^ababababaaabbbaabbab$","^ababababaaabbbabaabb$","^ababababaaabbbababab$","^ababababaabbaaaabbbb$"],"spec":{"machine":"PDA","rules":[[["^","INITIAL",null],["Q1",["push","$"]]],[["$","Q3","$"],["ACCEPT","pop"]],[["a","Q1","$"],["Q2",["push","A"]]],[["a","Q2","A"],["Q2",["push","A"]]],[["b","Q2","A"],["Q3","pop"]],[["b","Q3","A"],["Q3","pop"]],[["a","Q3","$"],["Q2",["push","A"]]]],"symbols":["^","a","b","c","d","e","$"]}} --------------------------------------------------------------------------------