Migrated from GitHub

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 safe-autonomy-lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,303 @@
+# Adaptive Reward Design for Reinforcement Learning
+
+**Citation:** If you use this code or build upon it, please cite:
+
+```bibtex
+@inproceedings{Kwon2025AdaptiveReward,
+  title     = {Adaptive Reward Design for Reinforcement Learning},
+  author    = {Kwon, Minjae and ElSayed-Aly, Ingy and Feng, Lu},
+  booktitle = {Proceedings of the Conference on Uncertainty in Artificial Intelligence (UAI)},
+  year      = {2025},
+}
+```
+
+**Contact:** For questions or collaborations, please contact:
+
+Minjae Kwon - hbt9su@virginia.edu
+
+## Overview
+
+This repository implements our method for **Adaptive Reward Design for Reinforcement Learning**, addressing the common challenge of sparse rewards when using Linear Temporal Logic (LTL) to specify complex tasks. While LTL provides precision, sparse rewards (e.g., feedback only on full task completion) often make it difficult for RL agents to learn effectively.
+
+Our approach overcomes this by:
+* Introducing **LTL-derived reward functions** that provide denser feedback compared to typical goal-achieved reward functions (which might assign 1 for completion and 0 otherwise). Our denser feedback is based on the structure of the Deterministic Finite Automaton (DFA) derived from the LTL formula, where we consider each node in the DFA as a sub-task. With our reward design, this encourages agents to complete as much of a task as possible, not just the final goal.
+* Developing an **adaptive reward shaping mechanism** that dynamically updates these LTL-derived reward functions during the learning process. This guides the agent more effectively based on its progress. While assigning partial rewards for solving sub-tasks (as illustrated in our toy example) can be beneficial, it also risks the policy converging to a sub-optimal solution that completes only early sub-tasks. Our adaptive reward design specifically addresses this issue of getting trapped in sub-optimal policies, a capability supported by theoretical guarantees (see Theorem 1 in our paper).
+
+The key idea is to reward incremental progress and adapting the learning signals as the agent explores. This repository contains the code to reproduce the experiments and utilize the proposed methods. Experimental results on a range of benchmark RL environments demonstrate that our approach generally outperforms baselines, achieving earlier convergence to a better policy with higher expected return and task completion rate.
+
+
+## Introduction
+We observed that **optimizing a policy in terms of reward** does not always align with **optimizing a policy for task completion**, particularly when using LTL-based reward shaping. To illustrate this, we provided a toy example in our paper. 
+
+The following plots illustrate the performance comparison in the toy environment:
+
+![Toy Environment Results](./results_plot/saved_plots/toy_normal_ablation.png)
+
+The plots on the left and right show the average reward during training and the success rate over time. Comparisons with QRM, CRM, and HRM in more complex environments are presented in our paper.
+
+## Installation 
+
+We have tested with Python 3.8.18 and Conda 23.7.4 on Ubuntu 20.04. We recommend using an Anaconda virtual environment
+
+You might need `pythonx.x-dev` package matching your python version installed with apt-get, and 
+the following.
+```bash
+sudo apt-get update
+sudo apt-get install build-essential
+```
+
+```bash
+conda create -n psltl python=3.8
+```
+### Download this folder
+
+Go to Files - Github.
+Click 'Download this folder' to download zip file.
+<!-- ### Clone the Repository
+
+```bash
+git clone https://github.com/IngyN/PartialSatLTL.git
+``` -->
+
+### Install the Package
+```bash
+cd AdaptiveRewardShaping
+pip install wheel==0.38.4
+pip install setuptools==65.5.0
+pip3 install -e .
+```
+
+### Mujoco Installation
+
+Please follow the instructions on the webpage: https://github.com/openai/mujoco-py
+
+### Troubleshooting Possible Errors
+If you face errors while building the gym package's wheel, such as:
+```bash
+wheel.vendored.packaging.requirements.InvalidRequirement: Expected end or semicolon (after version specifier) opencv-python>=3.
+```
+
+Please refer to this GitHub issue for solutions (https://github.com/openai/gym/issues/3202).
+
+
+
+## Testing the Installation
+
+### Running Tests
+
+#### List of Arguments
+- `--algo_name`: str (RL algorithm)
+- `--missing`: bool (Test with infeasible environment)
+- `--noise_level`: float (Determine likelihood of noisy action)
+- `--use_one_hot`: bool (Use one-hot encoding for automaton states)
+- `--node_embedding`: bool (Use node embedding for automaton states)
+- `--default_setting`: bool (Use default hyperparameters for each algorithm)
+- `--env_name`: str (e.g. office, water, toy, cheetah, etc.)
+- `--reward_types`: p (Options: p - progress, h - hybrid, n - naive)
+- `--use_adrs`: bool (Enable or disable adaptive reward shaping)
+- `--hybrid_eta`: float (Trade-off factor between negative and positive feedback)
+- `--ards_update`: int (Frequency of adaptive reward shaping updates)
+- `--adrs_mu`: float (Parameter for the trade-off between past and upcoming experiences)
+- `--episode_step`: int (Maximum steps per episode)
+- `--total_timesteps`: int (Total timesteps for each run)
+- `--total_run`: int (Number of times to run the same environment for accurate performance measurement considering standard deviation)
+- Numerous other hyperparameters available for RL algorithm settings.
+
+#### Usage Examples:
+Vary `--reward_types` n, p, h to test with reward functions: naive, progress, and hybrid, respectively.
+
+**Note** `--default_setting True` automatically use hyperparameter reported in the paper. We have used seeds 0 to 9 for 10 independent runs.
+For noisy or infeasible environments runs, additional arguments like `--noise_level=0.1` or `--missing=True` can be appended.
+
+
+##### Toy
+```bash
+python run.py --env_name toy --total_timesteps 10000 --total_run 1 --episode_step 25 --reward_types p --default_setting True --seed 0 --algo_name dqn --use_adrs True --node_embedding True --eval_freq 100
+```
+
+```bash
+python run.py --env_name toy --total_timesteps 10000 --total_run 1 --episode_step 25 --reward_types p --default_setting True --seed 0 --algo_name dqn --node_embedding True --eval_freq 100
+```
+
+##### Office
+```bash
+python run.py --env_name office --total_timesteps 60000 --total_run 1 --episode_step 100 --reward_types p --default_setting True --seed 0 --algo_name dqn --adrs_update 25 --use_adrs True --node_embedding True --eval_freq 100
+```
+
+##### Taxi
+```bash
+python run.py --env_name taxi --total_timesteps 500000 --total_run 1 --episode_step 200 --reward_types p --default_setting True --seed 0 --algo_name dqn --use_adrs True --node_embedding True --eval_freq 1000
+```
+
+##### Water
+```bash
+python run.py --env_name water --total_timesteps 2000000 --total_run 1 --episode_step 600 --reward_types p --default_setting True --seed 0 --algo_name ddqn --adrs_update 1000 --use_adrs True --use_one_hot True --map_id 3 --eval_freq 1000
+```
+
+##### HalfCheetah
+For DDPG,
+```bash
+python run.py --algo_name ddpg --env_name cheetah --total_timesteps 2000000 --total_run 1 --episode_step 1000 --reward_types p --default_setting True --seed 0 --adrs_update 100 --use_adrs True --use_one_hot True --eval_freq 1000
+```
+
+For A2C,
+```bash
+python run.py --algo_name a2c --env_name cheetah --total_timesteps 2000000 --total_run 1 --episode_step 1000 --reward_types p --default_setting True --seed 0 --adrs_update 500 --use_adrs True --use_one_hot True --eval_freq 1000
+```
+
+For PPO,
+```bash
+python run.py --algo_name ppo --env_name cheetah --total_timesteps 2000000 --total_run 1 --episode_step 1000 --reward_types p --default_setting True --seed 0 --adrs_update 500 --use_adrs True --use_one_hot True --eval_freq 1000
+```
+
+### Baseline Runs
+For Baselines run, please refer to the following GitHub repositories:
+
+QRM: https://bitbucket.org/RToroIcarte/qrm/src/master/
+
+CRM: https://github.com/RodrigoToroIcarte/reward_machines
+
+#### For QRM:
+Change your current directory to `./psltl/baseline_algo/qrm/src` and use the following commands:
+
+##### Office
+- Deterministic:
+```bash
+python run.py --algorithm="qrm-rs" --world="office" --map=0 --num_times=10 --batch_size=1 --buffer_size=1
+```
+- Noise:
+```bash
+python run.py --algorithm="qrm-rs" --world="office" --map=0 --num_times=10 --batch_size=1 --buffer_size=1 --noise_level=0.1
+```
+- Infeasible:
+```bash
+python run.py --algorithm="qrm-rs" --world="office" --map=0 --num_times=10 --batch_size=1 --buffer_size=1 --missing=True
+```
+
+##### Taxi
+ - Deterministic: 
+ ```bash
+ python run.py --algorithm="qrm-rs" --world="taxi" --map=0 --num_times=10 --batch_size=1 --buffer_size=1
+ ```
+ 
+##### Water
+ - Deterministic: 
+ ```bash
+ python run.py --algorithm="qrm-rs" --world="water" --map=3 --num_times=10 --batch_size=32 --buffer_size=50000
+ ```
+
+For noisy or infeasible environments runs, additional arguments like `--noise_level=0.1` or `--missing=True` can be appended.
+
+#### CRM and HRM
+Change your current directory to `./psltl/baseline_algo/crm` and use the following commands:
+
+##### Office
+ - Deterministic: 
+ ```bash
+ python run.py --alg=qlearning --env=Office-single-v0 --num_timesteps=6e4 --gamma=0.95 --env_name="office" --seed 0 --use_crm --eval_freq=100 --use_rs
+ ```
+ - Noise: 
+ ```bash
+ python run.py --alg=qlearning --env=Office-single-v0 --num_timesteps=6e4 --gamma=0.95 --env_name="office" --seed 0 --use_crm --eval_freq=100 --use_rs --noise_level 0.1
+ ```
+ - Infeasible: 
+ ```bash
+ python run.py --alg=qlearning --env=Office-single-v0 --num_timesteps=6e4 --gamma=0.95 --env_name="office" --seed 0 --use_crm --eval_freq=100 --use_rs --missing True
+ ```
+ 
+##### Taxi
+ - Deterministic: 
+ ```bash
+ python run.py --alg=qlearning --env=Taxi-v0 --num_timesteps=5e5 --gamma=0.9 --env_name="taxi" --seed 0 --use_rs --use_crm --eval_freq=1000 
+ ```
+  
+##### Water
+ - Deterministic: 
+ ```bash
+ python run.py --alg=deepq --env=Water-single-M3-v0 --num_timesteps=2e6 --gamma=0.9 --env_name="water" --use_crm --seed 0 --use_rs
+ ```
+ 
+##### HalfCheetah
+ - Deterministic: 
+ ```bash
+ python run.py --alg=ddpg --env=Half-Cheetah-RM2-v0 --num_timesteps=2e6 --gamma=0.99 --env_name="cheetah" --use_crm --seed 0 --normalize_observations=True
+ ```
+For noisy or infeasible environments runs, additional arguments like `--noise_level=0.1` or `--missing=True` can be appended.
+
+**Note**: For CRM run, only one run will be executed. To test multiple run results, change the seed. We have used seeds 0 to 9 for 10 independent runs
+For HRM run, simply change `--alg=qlearning` command to 1) `--alg=hrm` for Office and Taxi worlds, and 2) `--alg=dhrm` for Water and HalfCheetah worlds.
+
+
+## Scalability
+
+| Algorithm | On-Policy | Off-Policy | Compatability |
+| -------- | :--------: | :--------: | ----------------|
+| QRM | - | ✓ | DQN, DDQN |
+| HRM, CRM | - | ✓ | DDPG, DQN, DDQN |
+| Ours | ✓ | ✓ | DDPG, TD3, SAC, PPO, A2C, DQN, DDQN (customized from stable-baseline3) |
+
+
+## Reproducibility for the results
+
+### Computing Resources
+**Note**: Experiments were primarily conducted on a server using the Slurm scheduler. We ran experiments in parallel, specifying `--total_run 1` while varying the seed from `--seed 0` to `--seed 9` for both CRM and our approach. For QRM, we conducted 10 runs specifying `--num_times=10`. The execution times for each run varied based on the specific environment:
+- Office World: Each run took between 5 to 10 minutes.
+- Taxi World: Each run required approximately one hour.
+- Water World: Each run took more than a day to complete.
+- HalfCheetah World: Each run also took more than a day.
+
+Note that the running time varied depending on the type of reward function used. 
+Empirically, we observed that runs with hybrid reward functions typically took significantly more time. 
+In the case of Water and Cheetah worlds with hybrid functions, each run took approximately 2 to 4 days to complete.
+
+If you have limited computing resources, we suggest using Progress reward function, as they require less time to run and still demonstrate good performance compared to Reward Machine methods.
+
+We note the hardware specifications upon which all experiments were conducted:
+#### Hardware Specification
+When running without a GPU, we recommend focusing on the grid world examples (Office and Taxi) with at least a 10th gen i7 CPU and 8GB of RAM. 
+However, for the other environments, we recommend using a GPU enabled server or desktop with 16GB RAM and a CUDA enabled GPU such as an RTX 2080 or later.
+
+### How to Plot
+To ensure the reproducibility of the result plots presented in the paper, we have organized the relevant plot-related files into the results_plot folder.
+
+For monitoring and tracking reward and success rates during training, we have implemented custom callbacks and utilized evaluate_policy.py, which is derived from the stable-baselines3 library. These functionalities can be found in the following files: `psltl/rl_agents/common/callbacks.py` and `psltl/rl_agents/common/evaluation.py`.
+
+The results obtained from the callbacks, including reward and success rate, are stored in the `/log` folder with a specific format: `/log/environment's name/reward function name, adrs, automaton representation/seed/evaluations.npz`. Additionally, the trained model is saved as `RL algorithm.zip` in the same log folder.
+
+In order to facilitate result visualization and comparison across all algorithms, we convert the saved npz files into CSV format. Please note that the saved file types may vary for QRM and CRM, as they are based on the original implementations. For more detailed instructions, please refer to the README.md file included in the corresponding folder.
+
+## Repository Structure
+
+### Environments
+1. `psltl/envs/skeletons`: Core files for RM or LTL environments (not specific to environments like office, toy, etc.).
+2. `psltl/envs/common`: Specific environment designs (state, dynamic, action) like office, toy, mujoco, etc.
+3. `psltl/envs/ltl_envs`: LTL environments based on the designs in the "common" folder. These can be continuous control or grid world environments.
+
+### Linear Temporal Logic
+1. `psltl/ltl/ltl_infos`: Saved LTL information for each environment (number of states, transitions, etc.).
+2. `psltl/ltl`: Include python files to encode LTL formular with DFA using lydia library (`generate_ltl.ipynb` and `partial_sat_atm.py`), and load the saved DFA (`partial_sat_atm_load.py`). **Note**: In order to run generate_ltl.ipynb, you should use docker, and follow the instruction from here: https://github.com/whitemech/logaut. If you are using virtual environment, you should execute the following terminal command in the directory of your virtual environment; 
+```
+echo '#!/usr/bin/env sh' > lydia
+echo 'docker run -v$(pwd):/home/default whitemech/lydia lydia "$@"' >> lydia
+sudo chmod u+x lydia
+```
+
+For example, my virtual environment directory is 'home/mj/anaconda3/envs/psltl/bin', and I type the terminal command on the directory.
+
+### Reward Functions
+1. `psltl/reward_functions/reward_function_standards.py`: Contains naive, progress, hybrid reward function classes.
+
+### Algorithms
+1. `psltl/rl_agents`: Customized RL agents for generic environments, typically used for LTL environments. Includes a custom evaluation method for success rate tracking.
+
+### Training
+1. `psltl/learner/learner.py`: Executes the algorithm.
+2. `psltl/learner/learning_param.py`: Defines learning parameters.
+3. `psltl/learner/ltl_learner.py`: Sets up the LTL environment and RL algorithms
+
+### Plot
+1. `results_plot`: Plot Results
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

data/psltl/baseline_algo/crm/autoexcution.py

@@ -0,0 +1,50 @@
+import subprocess
+from itertools import product
+import sys
+
+# python run.py --alg=hrm --env=Taxi-v0 --num_timesteps=5e5 --gamma=0.9 --env_name="taxi" --seed 0
+# python run.py --alg=dhrm --env=Water-single-M3-v0 --num_timesteps=2e6 --gamma=0.9 --env_name="water" --use_rs --seed 0
+# python run.py --alg=dhrm --num_timesteps=2e6 --gamma=0.99 --use_crm --env=Half-Cheetah-RM2-v0 --normalize_observations=True --seed=0 --env_name=cheetah
+
+algs = ["hrm"]
+# grid worlds
+envs = ["Taxi-v0", "Office-single-v0"]
+envs2names = {"Taxi-v0": "taxi", "Office-single-v0": "office"}
+names2steps = {"taxi": 5e5, "office": 6e4}
+names2gamma = {"taxi": 0.9, "office": 0.95}
+env_types = ["complete", "noise", "missing"]
+# continous worlds
+# envs = ["Water-single-M3-v0", "Half-Cheetah-RM2-v0"]
+envs = ["Water-single-M3-v0"]
+envs2names = {"Water-single-M3-v0": "water", "Half-Cheetah-RM2-v0": "cheetah"}
+names2steps = {"water": 2e6, "cheetah": 2e6}
+names2gamma = {"water": 0.9, "cheetah": 0.99}
+env_types = ["complete", "noise", "missing"]
+env_types = ["complete"]
+
+# env_names = ["office", "taxi", "cheetah"]
+# env_names = ["office", "taxi", "water", "cheetah"]
+
+total_comb = list(
+            product([i for i in algs], [i for i in envs], [i for i in env_types])
+            )
+
+with open("temp_experiments.txt", "w") as f:
+    f.write("ArrayTaskID,AlgoName,Env,TimeSteps,Gamma,EnvName,Seed,EnvType\n")
+    idx = 0
+    for element in total_comb:
+        env = element[1]
+        name = envs2names[env]
+        if name in ["office", "taxi", "water", "cheetah"]:
+            for seed in range(10):
+                idx += 1
+                steps = names2steps[name]
+                gamma = names2gamma[name]
+                env_type = element[-1]
+                f.write(f"{idx},{element[0]},{env},{steps},{gamma},{name},{seed},{env_type}\n")
+
+command = ['awk', 'BEGIN {FS=OFS=","} {gsub(/,/, "\t"); print}', 'temp_experiments.txt']
+output_file = "hrm_experiments.txt"
+subprocess.run(command, stdout=open(output_file, 'w'))
+del_command = ['rm', 'temp_experiments.txt']
+subprocess.run(del_command, stdout=subprocess.PIPE)

data/psltl/baseline_algo/crm/cmd_util.py

@@ -0,0 +1,139 @@
+"""
+Helpers for scripts like run_atari.py.
+"""
+
+import os
+try:
+    from mpi4py import MPI
+except ImportError:
+    MPI = None
+
+import gym
+from gym.wrappers import FlattenObservation, FilterObservation
+from baselines import logger
+from baselines.bench import Monitor
+from baselines.common import set_global_seeds
+from baselines.common.atari_wrappers import make_atari, wrap_deepmind
+from baselines.common.vec_env.subproc_vec_env import SubprocVecEnv
+from baselines.common.vec_env.dummy_vec_env import DummyVecEnv
+from baselines.common import retro_wrappers
+from baselines.common.wrappers import ClipActionsWrapper
+from baselines.common.cmd_util import arg_parser
+
+from psltl.baseline_algo.crm.reward_machines.rm_environment import RewardMachineWrapper, HierarchicalRMWrapper
+
+def make_vec_env(env_id, env_type, num_env, seed, args, 
+                 wrapper_kwargs=None,
+                 env_kwargs=None,
+                 start_index=0,
+                 reward_scale=1.0,
+                 flatten_dict_observations=True,
+                 gamestate=None,
+                 initializer=None,
+                 force_dummy=False):
+    """
+    Create a wrapped, monitored SubprocVecEnv for Atari and MuJoCo.
+    """
+    wrapper_kwargs = wrapper_kwargs or {}
+    env_kwargs = env_kwargs or {}
+    mpi_rank = MPI.COMM_WORLD.Get_rank() if MPI else 0
+    seed = seed + 10000 * mpi_rank if seed is not None else None
+    logger_dir = logger.get_dir()
+    def make_thunk(rank, initializer=None):
+        return lambda: make_env(
+            env_id=env_id,
+            env_type=env_type,
+            args=args,
+            mpi_rank=mpi_rank,
+            subrank=rank,
+            seed=seed,
+            reward_scale=reward_scale,
+            gamestate=gamestate,
+            flatten_dict_observations=flatten_dict_observations,
+            wrapper_kwargs=wrapper_kwargs,
+            env_kwargs=env_kwargs,
+            logger_dir=logger_dir,
+            initializer=initializer
+        )
+
+    set_global_seeds(seed)
+    if not force_dummy and num_env > 1:
+        return SubprocVecEnv([make_thunk(i + start_index, initializer=initializer) for i in range(num_env)])
+    else:
+        return DummyVecEnv([make_thunk(i + start_index, initializer=None) for i in range(num_env)])
+
+def make_env(env_id, env_type, args, mpi_rank=0, subrank=0, seed=None, reward_scale=1.0, gamestate=None, flatten_dict_observations=True, wrapper_kwargs=None, env_kwargs=None, logger_dir=None, initializer=None):
+    if initializer is not None:
+        initializer(mpi_rank=mpi_rank, subrank=subrank)
+
+    wrapper_kwargs = wrapper_kwargs or {}
+    env_kwargs = env_kwargs or {}
+    if ':' in env_id:
+        import re
+        import importlib
+        module_name = re.sub(':.*','',env_id)
+        env_id = re.sub('.*:', '', env_id)
+        importlib.import_module(module_name)
+    
+    env = gym.make(env_id, **env_kwargs)
+
+    # Adding RM wrappers if needed
+    if args.alg.endswith("hrm") or args.alg.endswith("dhrm"):
+        env = RewardMachineWrapper(env, args.use_crm, args.use_rs, args.gamma, args.rs_gamma, args.missing)
+        env = HierarchicalRMWrapper(env, args.r_min, args.r_max, args.use_self_loops, args.use_rs, args.gamma, args.rs_gamma,)
+        eval_env = HierarchicalRMWrapper(env, args.r_min, args.r_max, args.use_self_loops, args.use_rs, args.gamma, args.rs_gamma,)
+    else:
+        env = RewardMachineWrapper(env, args.use_crm, args.use_rs, args.gamma, args.rs_gamma, args.missing)
+        env = HierarchicalRMWrapper(env, args.r_min, args.r_max, args.use_self_loops, args.use_rs, args.gamma, args.rs_gamma,)
+        
+    # elif args.use_rs or args.use_crm or args.missing:
+    #     env = RewardMachineWrapper(env, args.use_crm, args.use_rs, args.gamma, args.rs_gamma, args.missing)
+
+    if flatten_dict_observations and isinstance(env.observation_space, gym.spaces.Dict):
+        env = FlattenObservation(env)
+
+    env.seed(seed + subrank if seed is not None else None)
+    # env = Monitor(env,
+    #               logger_dir and os.path.join(logger_dir, str(mpi_rank) + '.' + str(subrank)),
+    #               allow_early_resets=True)
+
+    if isinstance(env.action_space, gym.spaces.Box):
+        env = ClipActionsWrapper(env)
+
+    if reward_scale != 1:
+        env = retro_wrappers.RewardScaler(env, reward_scale)
+
+    return env
+
+def common_arg_parser():
+    """
+    Create an argparse.ArgumentParser.
+    """
+    parser = arg_parser()
+    parser.add_argument('--env', help='environment ID', type=str, default='Reacher-v2')
+    parser.add_argument('--env_name', help='environment name', type=str, default='office')
+    parser.add_argument('--missing', help='missing goal', type=bool, default=False)
+    parser.add_argument('--noise_level', help='noise_level in environment', type=float, default=0.)
+    parser.add_argument('--env_type', help='type of environment, used when the environment type cannot be automatically determined', type=str)
+    parser.add_argument('--seed', help='RNG seed', type=int, default=None)
+    parser.add_argument('--alg', help='Algorithm', type=str, default='ppo2')
+    parser.add_argument('--num_timesteps', type=float, default=1e6),
+    parser.add_argument('--network', help='network type (mlp, cnn, lstm, cnn_lstm, conv_only)', default=None)
+    parser.add_argument('--gamestate', help='game state to load (so far only used in retro games)', default=None)
+    parser.add_argument('--num_env', help='Number of environment copies being run in parallel. When not specified, set to number of cpus for Atari, and to 1 for Mujoco', default=None, type=int)
+    parser.add_argument('--reward_scale', help='Reward scale factor. Default: 1.0', default=1.0, type=float)
+    parser.add_argument('--save_path', help='Path to save trained model to', default=None, type=str)
+    parser.add_argument('--save_video_interval', help='Save video every x steps (0 = disabled)', default=0, type=int)
+    parser.add_argument('--save_video_length', help='Length of recorded video. Default: 200', default=200, type=int)
+    parser.add_argument('--log_path', help='Directory to save learning curve data.', default=None, type=str)
+    parser.add_argument('--test', default=False, help='we only test environment with saved models')
+    parser.add_argument('--play', default=False, action='store_true')
+    # RM-related arguments
+    parser.add_argument("--use_rs", help="Use reward shaping", action="store_true", default=False)
+    parser.add_argument("--use_crm", help="Use counterfactual experience", action="store_true", default=False)
+    parser.add_argument('--gamma', help="Discount factor", type=float, default=0.9)
+    parser.add_argument('--rs_gamma', help="Discount factor used for reward shaping", type=float, default=0.9)
+    parser.add_argument('--r_min', help="R-min reward used for training option policies in hrm", type=float, default=0.0)
+    parser.add_argument('--r_max', help="R-max reward used for training option policies in hrm", type=float, default=1.0)
+    parser.add_argument("--use_self_loops", help="Add option policies for self-loops in the RMs", action="store_true", default=False)
+    return parser

data/psltl/baseline_algo/crm/envs/__init__.py

@@ -0,0 +1,97 @@
+from gym.envs.registration import register
+import gym
+env_dict = gym.envs.registration.registry.env_specs.copy()
+for env in env_dict:
+    if 'Half-Cheetah-RM1-v0' in env:
+        print("Remove {} from registry".format(env))
+        del gym.envs.registration.registry.env_specs[env]
+    if 'Half-Cheetah-RM2-v0' in env:
+        print("Remove {} from registry".format(env))
+        del gym.envs.registration.registry.env_specs[env]
+    
+    for i in range(11):
+        w_id = 'Water-single-M%d-v0'%i
+        if w_id in env:
+            print("Remove {} from registry".format(env))
+            del gym.envs.registration.registry.env_specs[env]
+    for i in range(11):
+        w_id = 'Water-M%d-v0'%i
+        if w_id in env:
+            print("Remove {} from registry".format(env))
+            del gym.envs.registration.registry.env_specs[env]
+
+        
+
+
+# ----------------------------------------- Half-Cheetah
+
+register(
+    id='Half-Cheetah-RM1-v0',
+    entry_point='envs.mujoco_rm.half_cheetah_environment:MyHalfCheetahEnvRM1',
+    max_episode_steps=1000,
+)
+register(
+    id='Half-Cheetah-RM2-v0',
+    entry_point='envs.mujoco_rm.half_cheetah_environment:MyHalfCheetahEnvRM2',
+    max_episode_steps=1000,
+)
+
+
+
+# ----------------------------------------- WATER
+for i in range(11):
+    w_id = 'Water-M%d-v0'%i
+    w_en = 'envs.water.water_environment:WaterRMEnvM%d'%i
+    register(
+        id=w_id,
+        entry_point=w_en,
+        max_episode_steps=600
+    )
+
+for i in range(11):
+    w_id = 'Water-single-M%d-v0'%i
+    w_en = 'envs.water.water_environment:WaterRM10EnvM%d'%i
+    register(
+        id=w_id,
+        entry_point=w_en,
+        max_episode_steps=600
+    )
+
+# # ----------------------------------------- OFFICE
+# register(
+#     id='Office-v0',
+#     entry_point='envs.grids.grid_environment:OfficeRMEnv',
+#     max_episode_steps=1000
+# )
+
+register(
+    id='Office-single-v0',
+    entry_point='envs.grids.grid_environment:OfficeRM3Env',
+    max_episode_steps=100
+)
+
+# # ----------------------------------------- CRAFT
+# for i in range(11):
+#     w_id = 'Craft-M%d-v0'%i
+#     w_en = 'envs.grids.grid_environment:CraftRMEnvM%d'%i
+#     register(
+#         id=w_id,
+#         entry_point=w_en,
+#         max_episode_steps=1000
+#     )
+
+# for i in range(11):
+#     w_id = 'Craft-single-M%d-v0'%i
+#     w_en = 'envs.grids.grid_environment:CraftRM10EnvM%d'%i
+#     register(
+#         id=w_id,
+#         entry_point=w_en,
+#         max_episode_steps=1000
+#     )
+
+# ----------------------------------------- Taxi
+register(
+    id='Taxi-v0',
+    entry_point='envs.grids.grid_environment:TaxiRMEnv',
+    max_episode_steps=200
+)

data/psltl/baseline_algo/crm/envs/grids/craft_world.py

@@ -0,0 +1,136 @@
+from psltl.baseline_algo.crm.envs.grids.game_objects import *
+import random, math, os
+import numpy as np
+
+class CraftWorld:
+
+    def __init__(self, file_map):
+        self.file_map = file_map
+        self._load_map(file_map)
+        self.env_game_over = False
+
+    def reset(self):
+        self.agent.reset()
+
+    def execute_action(self, a):
+        """
+        We execute 'action' in the game
+        """
+        agent = self.agent
+        ni,nj = agent.i, agent.j
+
+        # Getting new position after executing action
+        ni,nj = self._get_next_position(ni,nj,a)
+        
+        # Interacting with the objects that is in the next position (this doesn't include monsters)
+        action_succeeded = self.map_array[ni][nj].interact(agent)
+
+        # So far, an action can only fail if the new position is a wall
+        if action_succeeded:
+            agent.change_position(ni,nj)
+
+
+    def _get_next_position(self, ni, nj, a):
+        """
+        Returns the position where the agent would be if we execute action
+        """
+        action = Actions(a)
+        
+        # OBS: Invalid actions behave as NO-OP
+        if action == Actions.up   : ni-=1
+        if action == Actions.down : ni+=1
+        if action == Actions.left : nj-=1
+        if action == Actions.right: nj+=1
+        
+        return ni,nj
+
+
+    def get_true_propositions(self):
+        """
+        Returns the string with the propositions that are True in this state
+        """
+        ret = str(self.map_array[self.agent.i][self.agent.j]).strip()
+        return ret
+
+    def get_features(self):
+        """
+        Returns the features of the current state (i.e., the location of the agent)
+        """
+        return np.array([self.agent.i,self.agent.j])
+
+    def show(self):    
+        """
+        Prints the current map
+        """
+        r = ""
+        for i in range(self.map_height):
+            s = ""
+            for j in range(self.map_width):
+                if self.agent.idem_position(i,j):
+                    s += str(self.agent)
+                else:
+                    s += str(self.map_array[i][j])
+            if(i > 0):
+                r += "\n"
+            r += s
+        print(r)
+
+
+    def get_model(self):
+        """
+        This method returns a model of the environment. 
+        We use the model to compute optimal policies using value iteration.
+        The optimal policies are used to set the average reward per step of each task to 1.
+        """
+        S = [(x,y) for x in range(1,40) for y in range(1,40)] # States
+        A = self.actions.copy()                               # Actions
+        L = dict([((x,y),str(self.map_array[x][y]).strip()) for x,y in S])  # Labeling function
+        T = {}                  # Transitions (s,a) -> s' (they are deterministic)
+        for s in S:
+            x,y = s
+            for a in A:
+                x2,y2 = self._get_next_position(x,y,a)
+                T[(s,a)] = s if str(self.map_array[x2][y2]) == "X" else (x2,y2)
+        return S,A,L,T # SALT xD
+
+
+    def _load_map(self,file_map):
+        """
+        This method adds the following attributes to the game:
+            - self.map_array: array containing all the static objects in the map (no monsters and no agent)
+                - e.g. self.map_array[i][j]: contains the object located on row 'i' and column 'j'
+            - self.agent: is the agent!
+            - self.map_height: number of rows in every room 
+            - self.map_width: number of columns in every room
+        The inputs:
+            - file_map: path to the map file
+        """
+        # contains all the actions that the agent can perform
+        self.actions = [Actions.up.value, Actions.right.value, Actions.down.value, Actions.left.value]
+        # loading the map
+        self.map_array = []
+        self.class_ids = {} # I use the lower case letters to define the features
+        f = open(file_map)
+        i,j = 0,0
+        for l in f:
+            # I don't consider empty lines!
+            if(len(l.rstrip()) == 0): continue
+            
+            # this is not an empty line!
+            row = []
+            j = 0
+            for e in l.rstrip():
+                if e in "abcdefghijklmnopqrstuvwxyzH":
+                    entity = Empty(i,j,label=e)
+                    if e not in self.class_ids:
+                        self.class_ids[e] = len(self.class_ids)
+                if e in " A":  entity = Empty(i,j)
+                if e == "X":   entity = Obstacle(i,j)
+                if e == "A":   self.agent = Agent(i,j,self.actions)
+                row.append(entity)
+                j += 1
+            self.map_array.append(row)
+            i += 1
+        f.close()
+        # height width
+        self.map_height, self.map_width = len(self.map_array), len(self.map_array[0])

data/psltl/baseline_algo/crm/envs/grids/game_objects.py

@@ -0,0 +1,66 @@
+from enum import Enum
+import random
+
+"""
+The following classes are the types of objects that we are currently supporting 
+"""
+
+class Entity:
+    def __init__(self,i,j): #row and column
+        self.i = i
+        self.j = j
+
+    def change_position(self,i,j):
+        self.i = i
+        self.j = j
+        
+    def idem_position(self,i,j):
+        return self.i==i and self.j==j
+
+    def interact(self, agent):
+        return True
+
+class Agent(Entity):
+    def __init__(self,i,j,actions):
+        super().__init__(i,j)
+        self.actions = actions
+        self.initial_position = (i,j)
+
+    def reset(self):
+        self.change_position(*self.initial_position)
+
+    def get_actions(self):
+        return self.actions
+
+    def __str__(self):
+        return "A"
+
+class Obstacle(Entity):
+    def __init__(self,i,j):
+        super().__init__(i,j)
+
+    def interact(self, agent):
+        return False
+
+    def __str__(self):
+        return "X"
+
+class Empty(Entity):
+    def __init__(self,i,j,label=" "):
+        super().__init__(i,j)
+        self.label = label
+
+    def __str__(self):
+        return self.label
+
+
+"""
+Enum with the actions that the agent can execute
+"""
+class Actions(Enum):
+    up    = 0 # move up
+    right = 1 # move right
+    down  = 2 # move down
+    left  = 3 # move left
+    none  = 4 # none or pick
+    drop  = 5

data/psltl/baseline_algo/crm/envs/grids/grid_environment.py

@@ -0,0 +1,262 @@
+import gym, random
+from gym import spaces
+import numpy as np
+from psltl.baseline_algo.crm.reward_machines.rm_environment import RewardMachineEnv
+from psltl.baseline_algo.crm.envs.grids.craft_world import CraftWorld
+from psltl.baseline_algo.crm.envs.grids.office_world import OfficeWorld
+from psltl.baseline_algo.crm.envs.grids.value_iteration import value_iteration
+from psltl.baseline_algo.crm.envs.grids.taxi_world import Taxi
+
+class GridEnv(gym.Env):
+    def __init__(self, env, env_name: str="office"):
+        self.env = env
+        N,M      = self.env.map_height, self.env.map_width
+        if env_name == "office":
+            self.action_space = spaces.Discrete(4) # up, right, down, left
+        elif env_name == "taxi":
+            self.action_space = spaces.Discrete(6) # up, right, down, left, pickup, drop-off
+        self.observation_space = spaces.Box(low=0, high=max([N,M]), shape=(2,), dtype=np.uint8)
+
+    def get_events(self):
+        return self.env.get_true_propositions()
+
+    def step(self, action):
+        self.env.execute_action(action)
+        obs = self.env.get_features()
+        reward = 0 # all the reward comes from the RM
+        done = False
+        info = {}
+        return obs, reward, done, info
+
+    def reset(self):
+        self.env.reset()
+        return self.env.get_features()
+
+    def show(self):
+        self.env.show()
+
+    def get_model(self):
+        return self.env.get_model()
+
+class GridRMEnv(RewardMachineEnv):
+    def __init__(self, env, rm_files):
+        super().__init__(env, rm_files)
+
+    def render(self, mode='human'):
+        if mode == 'human':
+            # commands
+            str_to_action = {"w":0,"d":1,"s":2,"a":3}
+
+            # play the game!
+            done = True
+            while True:
+                if done:
+                    print("New episode --------------------------------")
+                    obs = self.reset()
+                    print("Current task:", self.rm_files[self.current_rm_id])
+                    self.env.show()
+                    print("Features:", obs)
+                    print("RM state:", self.current_u_id)
+                    print("Events:", self.env.get_events())
+
+                print("\nAction? (WASD keys or q to quite) ", end="")
+                a = input()
+                print()
+                if a == 'q':
+                    break
+                # Executing action
+                if a in str_to_action:
+                    obs, rew, done, _ = self.step(str_to_action[a])
+                    self.env.show()
+                    print("Features:", obs)
+                    print("Reward:", rew)
+                    print("RM state:", self.current_u_id)
+                    print("Events:", self.env.get_events())
+                else:
+                    print("Forbidden action")
+        else:
+            raise NotImplementedError
+
+    def test_optimal_policies(self, num_episodes, epsilon, gamma):
+        """
+        This code computes optimal policies for each reward machine and evaluates them using epsilon-greedy exploration
+
+        PARAMS
+        ----------
+        num_episodes(int): Number of evaluation episodes
+        epsilon(float):    Epsilon constant for exploring the environment
+        gamma(float):      Discount factor
+
+        RETURNS
+        ----------
+        List with the optimal average-reward-per-step per reward machine
+        """
+        S,A,L,T = self.env.get_model()
+        print("\nComputing optimal policies... ", end='', flush=True)
+        optimal_policies = [value_iteration(S,A,L,T,rm,gamma) for rm in self.reward_machines]
+        print("Done!")
+        optimal_ARPS = [[] for _ in range(len(optimal_policies))]
+        print("\nEvaluating optimal policies.")
+        for ep in range(num_episodes):
+            if ep % 100 == 0 and ep > 0:
+                print("%d/%d"%(ep,num_episodes))
+            self.reset()
+            s = tuple(self.obs)
+            u = self.current_u_id
+            rm_id = self.current_rm_id
+            rewards = []
+            done = False
+            while not done:
+                a = random.choice(A) if random.random() < epsilon else optimal_policies[rm_id][(s,u)]
+                _, r, done, _ = self.step(a)
+                rewards.append(r)
+                s = tuple(self.obs)
+                u = self.current_u_id
+            optimal_ARPS[rm_id].append(sum(rewards)/len(rewards))
+        print("Done!\n")
+
+        return [sum(arps)/len(arps) for arps in optimal_ARPS]
+
+
+class OfficeRMEnv(GridRMEnv):
+    def __init__(self):
+        rm_files = ["./envs/grids/reward_machines/office/t%d.txt"%i for i in range(1,5)]
+        env = OfficeWorld()
+        super().__init__(GridEnv(env, "office"),rm_files)
+
+class OfficeRM3Env(GridRMEnv):
+    def __init__(self):
+        rm_files = ["./envs/grids/reward_machines/office/t3.txt"]
+        env = OfficeWorld()
+        super().__init__(GridEnv(env, "office"),rm_files)
+
+class TaxiRMEnv(GridRMEnv):
+    def __init__(self):
+        rm_files = ["./envs/grids/reward_machines/taxi/t.txt"]
+        env = Taxi()
+        super().__init__(GridEnv(env,  "taxi"),rm_files)
+
+class CraftRMEnv(GridRMEnv):
+    def __init__(self, file_map):
+        rm_files = ["./envs/grids/reward_machines/craft/t%d.txt"%i for i in range(1,11)]
+        env = CraftWorld(file_map)
+        super().__init__(GridEnv(env), rm_files)
+
+class CraftRMEnvM0(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_0.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM1(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_1.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM2(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_2.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM3(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_3.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM4(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_4.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM5(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_5.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM6(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_6.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM7(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_7.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM8(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_8.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM9(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_9.txt"
+        super().__init__(file_map)
+
+class CraftRMEnvM10(CraftRMEnv):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_10.txt"
+        super().__init__(file_map)
+
+# ----------------------------------------------- SINGLE TASK
+
+class CraftRM10Env(GridRMEnv):
+    def __init__(self, file_map):
+        rm_files = ["./envs/grids/reward_machines/craft/t10.txt"]
+        env = CraftWorld(file_map)
+        super().__init__(GridEnv(env), rm_files)
+
+class CraftRM10EnvM0(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_0.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM1(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_1.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM2(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_2.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM3(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_3.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM4(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_4.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM5(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_5.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM6(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_6.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM7(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_7.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM8(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_8.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM9(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_9.txt"
+        super().__init__(file_map)
+
+class CraftRM10EnvM10(CraftRM10Env):
+    def __init__(self):
+        file_map = "./envs/grids/maps/map_10.txt"
+        super().__init__(file_map)
+

data/psltl/baseline_algo/crm/envs/grids/maps/map_0.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X                                       X
+X                c                      X
+X                                       X
+X            h        f                 X
+X                         d             X
+X                      d                X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X         h          g                  X
+X   f                              f    X
+X                                       X
+X        d                              X
+X      d            A                   X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                          b            X
+X                   b                   X
+X                                       X
+X                    f                  X
+X                                 d     X
+X                                       X
+X                      c            a   X
+X                     f                 X
+X        a                      e       X
+X                                       X
+X                                       X
+Xa                             a        X
+X              g                        X
+X             e                         X
+X         a                             X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_1.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                            f          X
+X a                      a              X
+X                                       X
+X                                       X
+X                c                      X
+X                                       X
+X           h                   e       X
+X                               e       X
+X                                    b  X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                             d         X
+X                                       X
+X                                       X
+X              a                        X
+X f     g                               X
+X                   A                   X
+X f                                     X
+X                                h      X
+X              a                        X
+X                                       X
+X             c                         X
+X                                       X
+X                                   g   X
+X f                                    dX
+X                              bd       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X              a                        X
+Xd                                      X
+X              f                        X
+X                                       X
+X      d                                X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_10.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X                                       X
+X                          a            X
+X                                       X
+X                                     h X
+X                                       X
+X                                       X
+X                                       X
+X                                      dX
+X                                       X
+X  e                                    X
+X                   f                   X
+X                   f                   X
+X                             b         X
+X                                       X
+X        d           h  f               X
+X                             d         X
+X                                       X
+X                                       X
+X                   A                   X
+X    d                                  X
+X                                       X
+X                        f              X
+X        a                              X
+X  f                                    X
+X                                       X
+X                  a                    X
+X                              c        X
+X                                       X
+X               d                       X
+X                                       X
+X                 c                     X
+X                                       X
+X                               a       X
+X                       g               X
+X                            g          X
+Xe b                                    X
+Xa                                      X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_2.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X           f           f               X
+X                                     e X
+X     b                                 X
+X                                       X
+X                       c               X
+X                                       X
+X                                       X
+X                                d      X
+X                                       X
+X                   e       a           X
+X                            h          X
+X                                       X
+X                                      cX
+X                                       X
+X              d                        X
+X                                      bX
+X  d                                    X
+X                                       X
+X                   A                   X
+X           a                           X
+X                                       X
+X                                       X
+X                                  f  h X
+X                           d           X
+X                                d      X
+X                                 g     X
+X                                       X
+X                                a      X
+X                    a                  X
+X                                       X
+X                                       X
+X                       f           g   X
+X          f                            X
+X                                       X
+X           a                           X
+X                                       X
+X                                       X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_3.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X    d                         e        X
+X                 d                     X
+X        h          a                   X
+X                                       X
+X                                      cX
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                     f X
+X                                       X
+X                                       X
+X                                       X
+X         f  d                          X
+X                                     b X
+X                           h       a   X
+X                                       X
+X                                       X
+X                   A                   X
+X                                       X
+X                                       X
+X                                       X
+X      g                               eX
+X                           a           X
+X         d                          d  X
+X                                       X
+X                                       X
+X        f                              X
+X                                       X
+X                                  f  bfX
+X             g                         X
+X                                       X
+X                        a              X
+X        c                              X
+X                              a        X
+X                                       X
+X                                       X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_4.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X                f        c             X
+X                                       X
+X              a                        X
+X                                       X
+X    b                              f  aX
+X                         c             X
+X                                       X
+X                                       X
+X                                       X
+X                   d                   X
+X      a        a                       X
+X                          h            X
+X                                       X
+X                                       X
+X                   b                   X
+X             d                         X
+X            a                          X
+X                       f            h  X
+Xg                  A            g      X
+X                                       X
+X                        d              X
+X                                       X
+X                 f                     X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X         e       d                     X
+X                                       X
+X               f                       X
+X                                  d    X
+X                                       X
+X                  e                    X
+X                                       X
+X                                       X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_5.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+Xd            f                         X
+X                             c         X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X        a                              X
+X                                       X
+X    f  b ha                            X
+X                        d              X
+X                        d         f    X
+X           a f                         X
+X                                       X
+X   e                    e              X
+X    g                                  X
+X                                       X
+X                    d                  X
+X f                 A                   X
+X                                       X
+X                   h                   X
+X                                 b     X
+X                          g   c        X
+X                                       X
+X                                       X
+X                 a                     X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X      a                                X
+X                                       X
+X               d                       X
+X                                       X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_6.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X                                       X
+Xe                                    d X
+X                                       X
+X                                       X
+X                           f           X
+X            a                          X
+X                                       X
+X                                       X
+X                                     b X
+X                                       X
+X                                       X
+X                       f  d            X
+X                                       X
+X                                       X
+X                                       X
+X                            f          X
+X                               a       X
+X      a                                X
+X                   A  g                X
+X e                                     X
+X     a                                 X
+X                                       X
+X               g          d            X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                       c               X
+X            a   c                      X
+X f                                  d  X
+X                                       X
+X                                  f    X
+X                                       X
+X     b                             d   X
+X       h                               X
+X                           h           X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_7.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X                                       X
+X     a                             d   X
+X              a                     d  X
+X               f                  e    X
+X                                   a   X
+X                       b             h X
+X                                       X
+X                  f                    X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                     a X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                   A                   X
+X         b                             X
+X                                       X
+X                                       X
+X      h                                X
+X                                       X
+X   c                                   X
+X         a                             X
+X   d                      d            X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X             e                         X
+X                                       X
+X       d                               X
+X           g                           X
+X       f    g      f                   X
+X   c                     f             X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_8.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                                       X
+X                 a           a         X
+X                               h       X
+X                     a                 X
+X                                  g    X
+X        b                              X
+X    d                                  X
+X                a                      X
+X                                       X
+X                                      hX
+X                                       X
+X                                       X
+X  e                                    X
+X                         e           g X
+X                       b               X
+X     d                          c      X
+X                                       X
+X                                       X
+X                                       X
+X                   A                   X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X      f c                      f       X
+X     d                                 X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                        f              X
+X              f              d   f     X
+X                                       X
+X                          d            X
+X                                       X
+X                                       X
+X            a                          X
+X                                       X
+X                                       X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/maps/map_9.txt

@@ -0,0 +1,41 @@
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X                     e                 X
+X                                       X
+X                                       X
+X                                       X
+X                        a              X
+X                                       X
+X                  d                    X
+X        d                             hX
+X h         c                           X
+X                                       X
+X          f                            X
+X                                       X
+Xd                                      X
+X              f                        X
+X                                       X
+X   a                       g           X
+X                                       X
+X             d                         X
+X                                       X
+X                   A                   X
+X                                       X
+X  a                                e   X
+X                                       X
+X                 b                     X
+X          a                    g       X
+X                 f                     X
+X   f a                                 X
+X                                       X
+X                           d           X
+X                                       X
+X                                       X
+X                                       X
+X                             b       f X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X                                       X
+X     c                                 X
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

data/psltl/baseline_algo/crm/envs/grids/office_world.py

@@ -0,0 +1,150 @@
+from psltl.baseline_algo.crm.envs.grids.game_objects import Actions
+import random, math, os
+import numpy as np
+
+
+class OfficeWorld:
+
+    def __init__(self):
+        self._load_map()
+        self.map_height, self.map_width = 12,9
+
+    def reset(self):
+        self.agent = (2,1)
+
+    def execute_action(self, a):
+        """
+        We execute 'action' in the game
+        """
+        x,y = self.agent
+        self.agent = self._get_new_position(x,y,a)
+
+    def _get_new_position(self, x, y, a):
+        action = Actions(a)
+        # executing action
+        if (x,y,action) not in self.forbidden_transitions:
+            if action == Actions.up   : y+=1
+            if action == Actions.down : y-=1
+            if action == Actions.left : x-=1
+            if action == Actions.right: x+=1
+        return x,y
+
+
+    def get_true_propositions(self):
+        """
+        Returns the string with the propositions that are True in this state
+        """
+        ret = ""
+        if self.agent in self.objects:
+            ret += self.objects[self.agent]
+        return ret
+
+    def get_features(self):
+        """
+        Returns the features of the current state (i.e., the location of the agent)
+        """
+        x,y = self.agent
+        return np.array([x,y])
+
+    def show(self):
+        for y in range(8,-1,-1):
+            if y % 3 == 2:
+                for x in range(12):
+                    if x % 3 == 0:
+                        print("_",end="")
+                        if 0 < x < 11:
+                            print("_",end="")
+                    if (x,y,Actions.up) in self.forbidden_transitions:
+                        print("_",end="")
+                    else:
+                        print(" ",end="")
+                print()                
+            for x in range(12):
+                if (x,y,Actions.left) in self.forbidden_transitions:
+                    print("|",end="")
+                elif x % 3 == 0:
+                    print(" ",end="")
+                if (x,y) == self.agent:
+                    print("A",end="")
+                elif (x,y) in self.objects:
+                    print(self.objects[(x,y)],end="")
+                else:
+                    print(" ",end="")
+                if (x,y,Actions.right) in self.forbidden_transitions:
+                    print("|",end="")
+                elif x % 3 == 2:
+                    print(" ",end="")
+            print()      
+            if y % 3 == 0:      
+                for x in range(12):
+                    if x % 3 == 0:
+                        print("_",end="")
+                        if 0 < x < 11:
+                            print("_",end="")
+                    if (x,y,Actions.down) in self.forbidden_transitions:
+                        print("_",end="")
+                    else:
+                        print(" ",end="")
+                print()                
+
+    def get_model(self):
+        """
+        This method returns a model of the environment. 
+        We use the model to compute optimal policies using value iteration.
+        The optimal policies are used to set the average reward per step of each task to 1.
+        """
+        S = [(x,y) for x in range(12) for y in range(9)] # States
+        A = self.actions.copy() # Actions
+        L = self.objects.copy() # Labeling function
+        T = {}                  # Transitions (s,a) -> s' (they are deterministic)
+        for s in S:
+            x,y = s
+            for a in A:
+                T[(s,a)] = self._get_new_position(x,y,a)
+        return S,A,L,T # SALT xD
+
+    def _load_map(self):
+        # Creating the map
+        self.objects = {}
+        self.objects[(1,1)] = "a"
+        self.objects[(1,7)] = "b"
+        self.objects[(10,7)] = "c"
+        self.objects[(10,1)] = "d"
+        self.objects[(7,4)] = "e"  # MAIL
+        # self.objects[(6,4)] = "n"  # PLANT
+        # self.objects[(3,5)] = "n"  # PLANT
+        self.objects[(8,2)] = "f"  # COFFEE
+        self.objects[(3,6)] = "f"  # COFFEE
+        self.objects[(6,4)] = "n"  # PLANT
+        
+        self.objects[(4,4)] = "g"  # OFFICE
+        self.objects[(4,1)] = "n"  # PLANT
+        self.objects[(7,1)] = "n"  # PLANT
+        self.objects[(4,7)] = "n"  # PLANT
+        self.objects[(7,7)] = "n"  # PLANT
+        self.objects[(1,4)] = "n"  # PLANT
+        self.objects[(10,4)] = "n" # PLANT
+        # Adding walls
+        self.forbidden_transitions = set()
+        # general grid
+        for x in range(12):
+            for y in [0,3,6]:
+                self.forbidden_transitions.add((x,y,Actions.down)) 
+                self.forbidden_transitions.add((x,y+2,Actions.up))
+        for y in range(9):
+            for x in [0,3,6,9]:
+                self.forbidden_transitions.add((x,y,Actions.left))
+                self.forbidden_transitions.add((x+2,y,Actions.right))
+        # adding 'doors'
+        for y in [1,7]:
+            for x in [2,5,8]:
+                self.forbidden_transitions.remove((x,y,Actions.right))
+                self.forbidden_transitions.remove((x+1,y,Actions.left))
+        for x in [1,4,7,10]:
+            self.forbidden_transitions.remove((x,5,Actions.up))
+            self.forbidden_transitions.remove((x,6,Actions.down))
+        for x in [1,10]:
+            self.forbidden_transitions.remove((x,2,Actions.up))
+            self.forbidden_transitions.remove((x,3,Actions.down))
+        # Adding the agent
+        self.actions = [Actions.up.value,Actions.right.value,Actions.down.value,Actions.left.value]

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t1.txt

@@ -0,0 +1,6 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!a',ConstantRewardFunction(0))
+(0,1,'a',ConstantRewardFunction(0))
+(1,1,'!b',ConstantRewardFunction(0))
+(1,2,'b',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t10.txt

@@ -0,0 +1,18 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!a&!f',ConstantRewardFunction(0))
+(0,1,'a',ConstantRewardFunction(0))
+(0,4,'f',ConstantRewardFunction(0))
+(1,1,'!c&!f',ConstantRewardFunction(0))
+(1,3,'c',ConstantRewardFunction(0))
+(1,5,'f',ConstantRewardFunction(0))
+(3,3,'!f',ConstantRewardFunction(0))
+(3,6,'f',ConstantRewardFunction(0))
+(4,4,'!a',ConstantRewardFunction(0))
+(4,5,'a',ConstantRewardFunction(0))
+(5,5,'!c',ConstantRewardFunction(0))
+(5,6,'c',ConstantRewardFunction(0))
+(6,6,'!b',ConstantRewardFunction(0))
+(6,7,'b',ConstantRewardFunction(0))
+(7,2,'h',ConstantRewardFunction(1))
+(7,7,'!h',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t2.txt

@@ -0,0 +1,6 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!a',ConstantRewardFunction(0))
+(0,1,'a',ConstantRewardFunction(0))
+(1,1,'!c',ConstantRewardFunction(0))
+(1,2,'c',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t3.txt

@@ -0,0 +1,6 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!d',ConstantRewardFunction(0))
+(0,1,'d',ConstantRewardFunction(0))
+(1,1,'!e',ConstantRewardFunction(0))
+(1,2,'e',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t4.txt

@@ -0,0 +1,6 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!d',ConstantRewardFunction(0))
+(0,1,'d',ConstantRewardFunction(0))
+(1,1,'!b',ConstantRewardFunction(0))
+(1,2,'b',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t5.txt

@@ -0,0 +1,11 @@
+0 # initial state
+[1] # terminal state
+(0,0,'!a&!f',ConstantRewardFunction(0))
+(0,2,'f',ConstantRewardFunction(0))
+(0,3,'a',ConstantRewardFunction(0))
+(2,2,'!a',ConstantRewardFunction(0))
+(2,4,'a',ConstantRewardFunction(0))
+(3,3,'!f',ConstantRewardFunction(0))
+(3,4,'f',ConstantRewardFunction(0))
+(4,1,'e',ConstantRewardFunction(1))
+(4,4,'!e',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t6.txt

@@ -0,0 +1,16 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!a&!d',ConstantRewardFunction(0))
+(0,1,'a',ConstantRewardFunction(0))
+(0,4,'d',ConstantRewardFunction(0))
+(1,1,'!b&!d',ConstantRewardFunction(0))
+(1,3,'b',ConstantRewardFunction(0))
+(1,5,'d',ConstantRewardFunction(0))
+(3,3,'!d',ConstantRewardFunction(0))
+(3,6,'d',ConstantRewardFunction(0))
+(4,4,'!a',ConstantRewardFunction(0))
+(4,5,'a',ConstantRewardFunction(0))
+(5,5,'!b',ConstantRewardFunction(0))
+(5,6,'b',ConstantRewardFunction(0))
+(6,2,'c',ConstantRewardFunction(1))
+(6,6,'!c',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t7.txt

@@ -0,0 +1,16 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!a&!f',ConstantRewardFunction(0))
+(0,1,'a',ConstantRewardFunction(0))
+(0,4,'f',ConstantRewardFunction(0))
+(1,1,'!c&!f',ConstantRewardFunction(0))
+(1,3,'c',ConstantRewardFunction(0))
+(1,5,'f',ConstantRewardFunction(0))
+(3,3,'!f',ConstantRewardFunction(0))
+(3,6,'f',ConstantRewardFunction(0))
+(4,4,'!a',ConstantRewardFunction(0))
+(4,5,'a',ConstantRewardFunction(0))
+(5,5,'!c',ConstantRewardFunction(0))
+(5,6,'c',ConstantRewardFunction(0))
+(6,2,'b',ConstantRewardFunction(1))
+(6,6,'!b',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t8.txt

@@ -0,0 +1,11 @@
+0 # initial state
+[1] # terminal state
+(0,0,'!a&!f',ConstantRewardFunction(0))
+(0,2,'a',ConstantRewardFunction(0))
+(0,3,'f',ConstantRewardFunction(0))
+(2,2,'!f',ConstantRewardFunction(0))
+(2,4,'f',ConstantRewardFunction(0))
+(3,3,'!a',ConstantRewardFunction(0))
+(3,4,'a',ConstantRewardFunction(0))
+(4,1,'c',ConstantRewardFunction(1))
+(4,4,'!c',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/craft/t9.txt

@@ -0,0 +1,13 @@
+0 # initial state
+[1] # terminal state
+(0,0,'!a&!f',ConstantRewardFunction(0))
+(0,2,'f',ConstantRewardFunction(0))
+(0,3,'a',ConstantRewardFunction(0))
+(2,2,'!a',ConstantRewardFunction(0))
+(2,4,'a',ConstantRewardFunction(0))
+(3,3,'!f',ConstantRewardFunction(0))
+(3,4,'f',ConstantRewardFunction(0))
+(4,4,'!e',ConstantRewardFunction(0))
+(4,5,'e',ConstantRewardFunction(0))
+(5,1,'g',ConstantRewardFunction(1))
+(5,5,'!g',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/office/t1.txt

@@ -0,0 +1,6 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!f&!n',ConstantRewardFunction(0))
+(0,1,'f&!n',ConstantRewardFunction(0))
+(1,1,'!g&!n',ConstantRewardFunction(0))
+(1,2,'g&!n',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/office/t2.txt

@@ -0,0 +1,6 @@
+0 # initial state
+[2] # terminal state
+(0,0,'!e&!n',ConstantRewardFunction(0))
+(0,1,'e&!n',ConstantRewardFunction(0))
+(1,1,'!g&!n',ConstantRewardFunction(0))
+(1,2,'g&!n',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/office/t3.txt

@@ -0,0 +1,11 @@
+0 # initial state
+[1] # terminal state
+(0,0,'!e&!f&!n',ConstantRewardFunction(0))
+(0,2,'e&!n',ConstantRewardFunction(0))
+(0,3,'!e&f&!n',ConstantRewardFunction(0))
+(2,2,'!f&!n',ConstantRewardFunction(0))
+(2,4,'f&!n',ConstantRewardFunction(0))
+(3,3,'!e&!n',ConstantRewardFunction(0))
+(3,4,'e&!n',ConstantRewardFunction(0))
+(4,1,'g&!n',ConstantRewardFunction(1))
+(4,4,'!g&!n',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/office/t4.txt

@@ -0,0 +1,10 @@
+0 # initial state
+[4] # terminal state
+(0,0,'!a&!n',ConstantRewardFunction(0))
+(0,1,'a&!n',ConstantRewardFunction(0))
+(1,1,'!b&!n',ConstantRewardFunction(0))
+(1,2,'b&!n',ConstantRewardFunction(0))
+(2,2,'!c&!n',ConstantRewardFunction(0))
+(2,3,'c&!n',ConstantRewardFunction(0))
+(3,3,'!d&!n',ConstantRewardFunction(0))
+(3,4,'d&!n',ConstantRewardFunction(1))

data/psltl/baseline_algo/crm/envs/grids/reward_machines/taxi/t.txt

@@ -0,0 +1,11 @@
+0 # initial state
+[3] # terminal state
+(0,0,'g&l&!d&!p|g&!d&!l&!p|l&!d&!g&!p|!d&!g&!l&!p',ConstantRewardFunction(0))
+(0,1,'d&g&p&!l|g&p&!d&!l|p&!d&!g&!l',ConstantRewardFunction(0))
+(0,2,'l&p&!d&!g',ConstantRewardFunction(0)) # 2
+(0,3,'d&g&l&p|g&l&p&!d',ConstantRewardFunction(0)) # 3
+(1,1,'g&!d&!l|d&g&p&!l|!d&!g&!l',ConstantRewardFunction(0))
+(1,2,'l&!d&!g',ConstantRewardFunction(0)) # 2
+(1,3,'g&l&!d|d&g&l&p',ConstantRewardFunction(0)) # 3
+(2,2,'!d&!g',ConstantRewardFunction(0)) # 2
+(2,3,'g&!d|d&g&p',ConstantRewardFunction(1)) # 3

data/psltl/baseline_algo/crm/envs/grids/taxi_world.py

@@ -0,0 +1,123 @@
+if __name__ == '__main__':
+    # This is a terrible hack just to be able to execute this file directly
+    import sys
+    sys.path.insert(0, '../')
+
+from psltl.baseline_algo.crm.envs.grids.game_objects import Actions
+import random, math, os
+import numpy as np
+
+import gymnasium as gym
+import numpy as np
+
+# render_mode will be 'human', 'None'
+
+class TaxiWorldParams:
+    def __init__(self, max_count:int = 20, seed: int = 0):
+        self.max_count = max_count
+        self.seed = seed
+
+
+class Taxi(gym.Wrapper):
+    def __init__(self, max_count: int=20, seed=0):
+        env = gym.make('Taxi-v3', render_mode=None)
+        super().__init__(env)
+        self.seed = seed
+        self.env = env
+        self.curr_mdp_state, _ = env.reset()
+        self.curr_label = ""
+        self.max_count = max_count
+        self.map_height = 1
+        self.map_width = 500
+        self.episode_step = 0
+
+        # actions [0, 1, 2, 3, 4, 5]
+        self.pickup_count = 0 # action is 4
+        self.dropoff_count = 0 # action is 5
+        self.actions = [i for i in range(self.action_space.n)]
+        self.reset()
+
+    def get_events(self):
+
+        label = self.curr_label 
+        return label 
+    
+    def get_actions(self):
+        
+        return self.actions
+    
+    def get_count(self):
+
+        total_count = self.pickup_count + self.dropoff_count
+        return total_count
+
+    def get_location(self, idx):
+        
+        return self.env.locs[idx]
+    
+    def get_features(self):
+
+        return self.curr_mdp_state
+    
+    def get_vector_features(self):
+        
+        return np.identity(self.map_height * self.map_width)[self.curr_mdp_state]
+    
+    def get_true_propositions(self):
+
+        return self.curr_label
+    
+    def get_state(self):
+        return None # we are only using "simple reward machines" for the craft domain
+
+    def execute_action(self, action):
+        self.step(action)
+
+    def step(self, action):
+        self.episode_step += 1
+        
+        next_state, reward, _, done, info = self.env.step(action)        
+        self.curr_mdp_state = next_state
+        taxi_row, taxi_col, pass_loc, dest_idx = self.env.decode(self.curr_mdp_state)
+        self.curr_label = ""
+        
+        # reach destination regardless of passengers
+        if ((taxi_row, taxi_col) == self.get_location(dest_idx)):
+            self.curr_label += "l"
+        
+        if pass_loc == 4:
+            self.curr_label += "p"
+            self.have_passenger = 1
+        
+        # while the taxi has passenger
+        if self.have_passenger:
+            self.curr_label += "p"
+            if action == 5:
+                self.curr_label += "d"
+                self.have_passenger = 0
+                # drop-off to the destinaion
+                if "l" in self.curr_label:
+                    self.curr_label += "g"
+
+        else:
+            if action == 5:
+                self.curr_label += "d"
+            # pick up passenger
+            elif action == 4 and ((taxi_row, taxi_col) == self.get_location(pass_loc)):
+                self.curr_label += "p" # get passenger
+                self.have_passenger = 1
+        
+        self.env_game_over = done
+        return next_state, reward, done, info
+    
+    def reset(self):
+        init_state = self.env.reset()
+        self.curr_mdp_state, _ = init_state
+        self.curr_label = ""
+        self.episode_step = 0
+        self.pickup_count = 0 
+        self.dropoff_count = 0
+        self.have_passenger = 0
+        self.done = False
+
+        return self.curr_mdp_state

data/psltl/baseline_algo/crm/envs/grids/value_iteration.py

@@ -0,0 +1,54 @@
+
+def value_iteration(S,A,L,T,rm,gamma):
+    """
+    Standard value iteration to compute optimal policies for the grid environments.
+    
+    PARAMS
+    ----------
+    S:     List of states
+    A:     List of actions
+    L:     Labeling function (it is a dictionary from states to events)
+    T:     Transitions (it is a dictionary from SxA -> S)
+    rm:    Reward machine
+    gamma: Discount factor 
+
+    RETURNS
+    ----------
+    Optimal deterministic policy (dictionary maping from states (SxU) to actions)
+    """
+    U = rm.get_states() # RM states
+    V = dict([((s,u),0) for s in S for u in U])
+    V_error = 1
+
+    # Computing the optimal value function
+    while V_error > 0.0000001:
+        V_error = 0
+        for s1 in S:
+            for u1 in U:
+                q_values = []
+                for a in A:
+                    s2 = T[(s1,a)]
+                    l  = '' if s2 not in L else L[s2]
+                    u2, r, done = rm.step(u1, l, None)
+                    if done: q_values.append(r)
+                    else:    q_values.append(r+gamma*V[(s2,u2)])
+                v_new = max(q_values)
+                V_error = max([V_error, abs(v_new-V[(s1,u1)])])
+                V[(s1,u1)] = v_new
+
+    # Extracting the optimal policy
+    policy = {}
+    for s1 in S:
+        for u1 in U:
+            q_values = []
+            for a in A:
+                s2 = T[(s1,a)]
+                l  = '' if s2 not in L else L[s2]
+                u2, r, done = rm.step(u1, l, None)
+                if done: q_values.append(r)
+                else:    q_values.append(r+gamma*V[(s2,u2)])
+            a_i = max((x,i) for i,x in enumerate(q_values))[1] # argmax over the q-valies
+            policy[(s1,u1)] = A[a_i]
+
+    return policy
+

data/psltl/baseline_algo/crm/envs/mujoco_rm/half_cheetah_environment.py

@@ -0,0 +1,50 @@
+"""
+This code add event detectors to the Ant3 Environment
+"""
+import gym
+import numpy as np
+from gym.envs.mujoco.half_cheetah_v3 import HalfCheetahEnv
+from psltl.baseline_algo.crm.reward_machines.rm_environment import RewardMachineEnv
+
+class MyHalfCheetahEnv(gym.Wrapper):
+    def __init__(self):
+        # Note that the current position is key for our tasks
+        super().__init__(HalfCheetahEnv(exclude_current_positions_from_observation=False))
+
+    def step(self, action):
+        # executing the action in the environment
+        next_obs, original_reward, env_done, info = self.env.step(action)
+        self.info = info
+        return next_obs, original_reward, env_done, info
+
+    def get_events(self):
+        events = ''
+        if self.info['x_position'] < -10:
+            events+='b'
+        if self.info['x_position'] > 10:
+            events+='a'
+        if self.info['x_position'] < -2:
+            events+='d'
+        if self.info['x_position'] > 2:
+            events+='c'
+        if self.info['x_position'] > 4:
+            events+='e'
+        if self.info['x_position'] > 6:
+            events+='f'
+        if self.info['x_position'] > 8:
+            events+='g'
+        
+        return events
+
+
+class MyHalfCheetahEnvRM1(RewardMachineEnv):
+    def __init__(self):
+        env = MyHalfCheetahEnv()
+        rm_files = ["./envs/mujoco_rm/reward_machines/t1.txt"]
+        super().__init__(env, rm_files)
+
+class MyHalfCheetahEnvRM2(RewardMachineEnv):
+    def __init__(self):
+        env = MyHalfCheetahEnv()
+        rm_files = ["./envs/mujoco_rm/reward_machines/t2.txt"]
+        super().__init__(env, rm_files)

data/psltl/baseline_algo/crm/envs/mujoco_rm/reward_machines/t1.txt

@@ -0,0 +1,6 @@
+0   # initial state
+[]  # terminal state
+(0,0,'!c',RewardControl())
+(0,1,'c',RewardControl())
+(1,1,'!d',RewardControl())
+(1,0,'d',ConstantRewardFunction(1000))

data/psltl/baseline_algo/crm/envs/mujoco_rm/reward_machines/t2.txt

@@ -0,0 +1,12 @@
+0   # initial state
+[5]  # terminal state
+(0,0,'!c',RewardControl())
+(0,1,'c',RewardControl())
+(1,1,'!e',RewardControl())
+(1,2,'e',RewardControl())
+(2,2,'!f',RewardControl())
+(2,3,'f',RewardControl())
+(3,3,'!g',RewardControl())
+(3,4,'g',RewardControl())
+(4,4,'!a',RewardControl())
+(4,5,'a',ConstantRewardFunction(1000))

data/psltl/baseline_algo/crm/envs/water/maps/world_3.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b92992768eb0e257d3c657a2441abf4b403418e0a1e34bdfbb67402feb3a3c8
+size 1908

data/psltl/baseline_algo/crm/envs/water/reward_machines/org_t10.txt

@@ -0,0 +1,8 @@
+1 # initial state
+[0] # terminal state
+(1,1,'!a&!b&!c&!d&!e&!f',ConstantRewardFunction(0))
+(1,2,'!a&!b&!c&d&!e&!f',ConstantRewardFunction(0))
+(2,2,'!a&!b&!c&!d&!e&!f',ConstantRewardFunction(0))
+(2,3,'!a&!b&!c&!d&e&!f',ConstantRewardFunction(0))
+(3,0,'!a&!b&!c&!d&!e&f',ConstantRewardFunction(1))
+(3,3,'!a&!b&!c&!d&!e&!f',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/water/reward_machines/t1.txt

@@ -0,0 +1,6 @@
+1 # initial state
+[2] # terminal state
+(0,0,'!b',ConstantRewardFunction(0))
+(0,2,'b',ConstantRewardFunction(1))
+(1,1,'!a',ConstantRewardFunction(0))
+(1,0,'a',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/water/reward_machines/t10.txt

@@ -0,0 +1,8 @@
+1 # initial state
+[0] # terminal states
+(1,1,'!a&!b&!c&!d&!e&!f',ConstantRewardFunction(0))
+(1,2,'a&!b&!c&!d&!e&!f',ConstantRewardFunction(0)) # red strict
+(2,2,'!a&!b&!c&!d&!e&!f',ConstantRewardFunction(0))
+(2,3,'!a&b&!c&!d&!e&!f',ConstantRewardFunction(0)) # green strcit
+(3,0,'c',ConstantRewardFunction(1)) # touch blue
+(3,3,'!c',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/water/reward_machines/t2.txt

@@ -0,0 +1,6 @@
+1 # initial state
+[2] # terminal state
+(0,0,'!d',ConstantRewardFunction(0))
+(0,2,'d',ConstantRewardFunction(1))
+(1,1,'!c',ConstantRewardFunction(0))
+(1,0,'c',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/water/reward_machines/t3.txt

@@ -0,0 +1,6 @@
+1 # initial state
+[2] # terminal state
+(0,0,'!f',ConstantRewardFunction(0))
+(0,2,'f',ConstantRewardFunction(1))
+(1,1,'!e',ConstantRewardFunction(0))
+(1,0,'e',ConstantRewardFunction(0))

data/psltl/baseline_algo/crm/envs/water/reward_machines/t4.txt

@@ -0,0 +1,22 @@
+1 # initial state
+[4] # terminal state
+(0,0,'!b&!c',ConstantRewardFunction(0))
+(0,6,'b',ConstantRewardFunction(0))
+(0,2,'!b&c',ConstantRewardFunction(0))
+(1,1,'!a&!c',ConstantRewardFunction(0))
+(1,0,'a',ConstantRewardFunction(0))
+(1,3,'!a&c',ConstantRewardFunction(0))
+(2,2,'!d&!b',ConstantRewardFunction(0))
+(2,7,'d',ConstantRewardFunction(0))
+(2,5,'!d&b',ConstantRewardFunction(0))
+(3,3,'!d&!a',ConstantRewardFunction(0))
+(3,8,'d',ConstantRewardFunction(0))
+(3,2,'!d&a',ConstantRewardFunction(0))
+(5,5,'!d',ConstantRewardFunction(0))
+(5,4,'d',ConstantRewardFunction(1))
+(6,6,'!c',ConstantRewardFunction(0))
+(6,5,'c',ConstantRewardFunction(0))
+(7,7,'!b',ConstantRewardFunction(0))
+(7,4,'b',ConstantRewardFunction(1))
+(8,8,'!a',ConstantRewardFunction(0))
+(8,7,'a',ConstantRewardFunction(0))