diff --git a/pyvene/data_generators/causal_model.py b/pyvene/data_generators/causal_model.py
index 6573edab..9ce703db 100644
--- a/pyvene/data_generators/causal_model.py
+++ b/pyvene/data_generators/causal_model.py
@@ -107,7 +107,8 @@ def generate_timesteps(self):
             step += 1
         for var in self.variables:
             assert var in timesteps
-        return timesteps, step - 1
+        # return all timesteps and timestep of root
+        return timesteps, step - 2
 
     def marginalize(self, target):
         pass
@@ -148,9 +149,12 @@ def find_live_paths(self, intervention):
         del paths[1]
         return paths
 
-    def print_setting(self, total_setting):
+    def print_setting(self, total_setting, display=None):
+        labeler = lambda var: var + ": " + str(total_setting[var]) \
+            if display is None or display[var] \
+            else var
         relabeler = {
-            var: var + ": " + str(total_setting[var]) for var in self.variables
+            var: labeler(var) for var in self.variables
         }
         G = nx.DiGraph()
         G.add_edges_from(
@@ -227,10 +231,12 @@ def sample_input(self, mandatory=None):
             total = self.run_forward(intervention=input)
         return input
 
-    def sample_input_tree_balanced(self, output_var=None):
+    def sample_input_tree_balanced(self, output_var=None, output_var_value=None):
         assert output_var is not None or len(self.outputs) == 1
         if output_var is None:
             output_var = self.outputs[0]
+        if output_var_value is None:
+            output_var_value = random.choice(self.values[output_var])
 
         def create_input(var, value, input={}):
             parent_values = random.choice(self.equiv_classes[var][value])
@@ -238,10 +244,14 @@ def create_input(var, value, input={}):
                 if parent in self.inputs:
                     input[parent] = parent_values[parent]
                 else:
-                    create_input(parent, random.choice(self.values[parent]), input)
+                    create_input(parent, parent_values[parent], input)
             return input
 
-        return create_input(output_var, random.choice(self.values[output_var]))
+        input_setting = create_input(output_var, output_var_value)
+        for input_var in self.inputs:
+            if input_var not in input_setting:
+                input_setting[input_var] = random.choice(self.values[input_var])
+        return input_setting
 
     def get_path_maxlen_filter(self, lengths):
         def check_path(total_setting):
@@ -299,24 +309,26 @@ def generate_factual_dataset(
         sampler=None,
         filter=None,
         device="cpu",
-        inputFunction=None,
-        outputFunction=None
+        return_tensors=True,
     ):
-        if inputFunction is None:
-            inputFunction = self.input_to_tensor
-        if outputFunction is None:
-            outputFunction = self.output_to_tensor
         if sampler is None:
             sampler = self.sample_input
-        X, y = [], []
-        count = 0
-        while count < size:
+
+        examples = []
+        while len(examples) < size:
+            example = dict()
             input = sampler()
             if filter is None or filter(input):
-                X.append(inputFunction(input))
-                y.append(outputFunction(self.run_forward(input)))
-                count += 1
-        return torch.stack(X).to(device), torch.stack(y).to(device)
+                output = self.run_forward(input)
+                if return_tensors:
+                    example['input_ids'] = self.input_to_tensor(input).to(device)
+                    example['labels'] = self.output_to_tensor(output).to(device)
+                else:
+                    example['input_ids'] = input
+                    example['labels'] = output
+                examples.append(example)
+
+        return examples
 
     def generate_counterfactual_dataset(
         self,
@@ -327,8 +339,7 @@ def generate_counterfactual_dataset(
         intervention_sampler=None,
         filter=None,
         device="cpu",
-        inputFunction=None,
-        outputFunction=None
+        return_tensors=True,
     ):
         maxlength = len(
             [
@@ -337,17 +348,12 @@ def generate_counterfactual_dataset(
                 if var not in self.inputs and var not in self.outputs
             ]
         )
-        if inputFunction is None:
-            inputFunction = self.input_to_tensor
-        if outputFunction is None:
-            outputFunction = self.output_to_tensor
         if sampler is None:
             sampler = self.sample_input
         if intervention_sampler is None:
             intervention_sampler = self.sample_intervention
         examples = []
-        count = 0
-        while count < size:
+        while len(examples) < size:
             intervention = intervention_sampler()
             if filter is None or filter(intervention):
                 for _ in range(batch_size):
@@ -358,24 +364,39 @@ def generate_counterfactual_dataset(
                     for var in self.variables:
                         if var not in intervention:
                             continue
-                        source = sampler()
-                        sources.append(inputFunction(source))
+                        # sample input to match sampled intervention value
+                        source = sampler(output_var=var, output_var_value=intervention[var])
+                        if return_tensors:
+                            sources.append(self.input_to_tensor(source))
+                        else:
+                            sources.append(source)
                         source_dic[var] = source
                     for _ in range(maxlength - len(sources)):
-                        sources.append(torch.zeros(self.input_to_tensor(sampler()).shape))
-                    example["labels"] = outputFunction(
-                        self.run_interchange(base, source_dic)
-                    ).to(device)
-                    example["base_labels"] = outputFunction(
-                        self.run_forward(base)
-                    ).to(device)
-                    example["input_ids"] = inputFunction(base).to(device)
-                    example["source_input_ids"] = torch.stack(sources).to(device)
-                    example["intervention_id"] = torch.tensor(
-                        [intervention_id(intervention)]
-                    ).to(device)
+                        if return_tensors:
+                            sources.append(torch.zeros(self.input_to_tensor(base).shape))
+                        else:
+                            sources.append({})
+
+                    if return_tensors:
+                        example["labels"] = self.output_to_tensor(
+                            self.run_interchange(base, source_dic)
+                        ).to(device)
+                        example["base_labels"] = self.output_to_tensor(
+                            self.run_forward(base)
+                        ).to(device)
+                        example["input_ids"] = self.input_to_tensor(base).to(device)
+                        example["source_input_ids"] = torch.stack(sources).to(device)
+                        example["intervention_id"] = torch.tensor(
+                            [intervention_id(intervention)]
+                        ).to(device)
+                    else:
+                        example['labels'] = self.run_interchange(base, source_dic)
+                        example['base_labels'] = self.run_forward(base)
+                        example['input_ids'] = base
+                        example['source_input_ids'] = sources
+                        example['intervention_id'] = [intervention_id(intervention)]
+
                     examples.append(example)
-                    count += 1
         return examples
 
 
diff --git a/tests/unit_tests/CausalModelTestCase.py b/tests/unit_tests/CausalModelTestCase.py
new file mode 100644
index 00000000..c37178c7
--- /dev/null
+++ b/tests/unit_tests/CausalModelTestCase.py
@@ -0,0 +1,208 @@
+import unittest
+import random
+import torch
+from pyvene import CausalModel
+random.seed(42)
+
+
+class CasualModelTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        print("=== Test Suite: CausalModelTestCase ===")
+        self.variables = ['A', 'B', 'C']
+        self.values = {
+            'A': [False, True],
+            'B': [False, True],
+            'C': [False, True]
+        }
+
+        self.parents = {
+            'A': [],
+            'B': [],
+            'C': ['A', 'B']
+        }
+
+        self.functions = {
+            "A": lambda: True,
+            "B": lambda: True,
+            "C": lambda a, b: a and b
+        }
+
+        self.causal_model = CausalModel(
+            self.variables, 
+            self.values, 
+            self.parents, 
+            self.functions
+        )
+
+    def test_initialization(self):
+        inputs = ['A', 'B']
+        outputs = ['C']
+        timesteps = {
+            'A': 0,
+            'B': 0,
+            'C': 1
+        }
+        equivalence_classes = {
+            'C': {
+                False: [
+                    {'A': False, 'B': False},
+                    {'A': False, 'B': True},
+                    {'A': True, 'B': False}
+                ],
+                True: [
+                    {'A': True, 'B': True}
+                ]
+            }
+        }
+
+        self.assertEqual(set(self.causal_model.inputs), set(inputs))
+        self.assertEqual(set(self.causal_model.outputs), set(outputs))
+        self.assertEqual(self.causal_model.timesteps, timesteps)
+        self.assertEqual(self.causal_model.equiv_classes, equivalence_classes)
+    
+    def test_run_forward(self):
+        # test run forward with default values (A and B set to True)
+        self.assertEqual(
+            self.causal_model.run_forward(),
+            {'A': True, 'B': True, 'C': True}
+        )
+
+        # test run forward on all possible input values
+        for a in [False, True]:
+            for b in [False, True]:
+                input_setting = {
+                    'A': a,
+                    'B': b
+                }
+                output_setting = {
+                    'A': a,
+                    'B': b,
+                    'C': a and b
+                }
+                self.assertEqual(self.causal_model.run_forward(input_setting), output_setting)
+        
+        # test run forward on fully specified setting
+        output_setting = {'A': False, 'B': False, 'C': True}
+        self.assertEqual(self.causal_model.run_forward(output_setting), output_setting)
+    
+    def test_run_interchange(self):
+        # interchange intervention on input
+        base = {'A': True, 'B': False}
+        source = {'A': False, 'B': True}
+        self.assertEqual(self.causal_model.run_forward(base)['C'], False)
+        self.assertEqual(self.causal_model.run_forward(source)['C'], False)
+        self.assertEqual(
+            self.causal_model.run_interchange(base, {'B': source})['C'],
+            True
+        )
+
+        # interchange intervention on output
+        base = {'A': False, 'B': False}
+        source = {'A': True, 'B': True}
+        self.assertEqual(self.causal_model.run_forward(base)['C'], False)
+        self.assertEqual(
+            self.causal_model.run_interchange(base, {'B': source})['C'],
+            False
+        )
+        self.assertEqual(
+            self.causal_model.run_interchange(base, {'C': source})['C'],
+            True
+        )
+
+    def test_sample_input_tree_balanced(self):
+        # NOTE: not quite sure how to test a function with random behavior
+        # right now, fixing seed and assuming approximate behavior 
+        # (taking balanced to be less than 30-70 split)
+
+        K = 100
+        # test sampling by output value
+        outputs = []
+        for _ in range(K):
+            sample = self.causal_model.sample_input_tree_balanced()
+            output = self.causal_model.run_forward(sample)
+            outputs.append(output['C'])
+        self.assertGreaterEqual(sum(outputs), 30)
+        self.assertLessEqual(sum(outputs), 70)
+
+        # test sampling by input value
+        inputs = []
+        for _ in range(K):
+            sample = self.causal_model.sample_input_tree_balanced()
+            inputs.append(sample['A'])
+        self.assertGreaterEqual(sum(outputs), 30)
+        self.assertLessEqual(sum(outputs), 70)
+    
+    def test_generate_factual_dataset(self):
+        def sampler():
+            return {'A': False, 'B': False}
+
+        size = 4
+        factual_dataset = self.causal_model.generate_factual_dataset(
+            size=size,
+            sampler=sampler,
+            return_tensors=False
+        )
+        self.assertEqual(len(factual_dataset), size)
+
+        self.assertEqual(factual_dataset[0]['input_ids'], {'A': False, 'B': False})
+        self.assertEqual(factual_dataset[0]['labels']['C'], False)
+
+        factual_dataset_tensors = self.causal_model.generate_factual_dataset(
+            size=size,
+            sampler=sampler,
+            return_tensors=True
+        )
+        self.assertEqual(len(factual_dataset_tensors), size)
+        X = torch.stack([example['input_ids'] for example in factual_dataset_tensors])
+        y = torch.stack([example['labels'] for example in factual_dataset_tensors])
+        self.assertEqual(X.shape, (size, 2))
+        self.assertEqual(y.shape, (size, 1))
+        self.assertTrue(torch.equal(X[0], torch.tensor([0., 0.])))
+        self.assertTrue(torch.equal(y[0], torch.tensor([0.])))
+    
+    def test_generate_counterfactual_dataset(self):
+        def sampler(*args, **kwargs):
+            if kwargs.get('output_var', None):
+                return {'A': True, 'B': True}
+
+            return {'A': True, 'B': False}
+        
+        def intervention_sampler(*args, **kwargs):
+            return {'B': True}
+        
+        def intervention_id(*args, **kwargs):
+            return 0
+
+        size = 4
+        counterfactual_dataset = self.causal_model.generate_counterfactual_dataset(
+            size=size,
+            batch_size=1,
+            intervention_id=intervention_id,
+            sampler=sampler,
+            intervention_sampler=intervention_sampler,
+            return_tensors=False
+        )
+        self.assertEqual(len(counterfactual_dataset), size)
+        example = counterfactual_dataset[0]
+        self.assertEqual(example['input_ids'], {'A': True, 'B': False})
+        self.assertEqual(example['source_input_ids'][0]['B'], True)
+        self.assertEqual(example['intervention_id'], [0])
+        self.assertEqual(example['base_labels']['C'], False) # T and F
+        self.assertEqual(example['labels']['C'], True) # T and T
+
+
+def suite():
+    suite = unittest.TestSuite()
+    suite.addTest(CasualModelTestCase("test_initialization"))
+    suite.addTest(CasualModelTestCase("test_run_forward"))
+    suite.addTest(CasualModelTestCase("test_run_interchange"))
+    suite.addTest(CasualModelTestCase("test_sample_input_tree_balanced"))
+    suite.addTest(CasualModelTestCase("test_generate_factual_dataset"))
+    suite.addTest(CasualModelTestCase("test_generate_counterfactual_dataset"))
+    return suite
+
+
+if __name__ == "__main__":
+    runner = unittest.TextTestRunner()
+    runner.run(suite())
diff --git a/tutorials/advanced_tutorials/DAS_Main_Introduction.ipynb b/tutorials/advanced_tutorials/DAS_Main_Introduction.ipynb
index 3bc39013..8746f243 100644
--- a/tutorials/advanced_tutorials/DAS_Main_Introduction.ipynb
+++ b/tutorials/advanced_tutorials/DAS_Main_Introduction.ipynb
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -100,16 +100,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<torch._C.Generator at 0x7fbcfc1c8470>"
+       "<torch._C.Generator at 0x15308f04db0>"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -150,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -218,14 +218,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 720x720 with 1 Axes>"
+       "<Figure size 1000x1000 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -235,7 +235,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Timesteps: {'W': 0, 'X': 0, 'Y': 0, 'Z': 0, 'WX': 1, 'YZ': 1, 'O': 3}\n"
+      "Timesteps: {'W': 0, 'X': 0, 'Y': 0, 'Z': 0, 'WX': 1, 'YZ': 1, 'O': 2}\n"
      ]
     }
    ],
@@ -255,7 +255,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -269,9 +269,9 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 720x720 with 1 Axes>"
+       "<Figure size 1000x1000 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -299,7 +299,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -312,9 +312,9 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 720x720 with 1 Axes>"
+       "<Figure size 1000x1000 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -350,14 +350,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 720x720 with 1 Axes>"
+       "<Figure size 1000x1000 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -387,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -402,7 +402,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -428,7 +428,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -459,7 +459,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -492,7 +492,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -510,22 +510,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
     "n_examples = 100000\n",
     "\n",
-    "X, y = equality_model.generate_factual_dataset(\n",
+    "examples = equality_model.generate_factual_dataset(\n",
     "    n_examples, equality_model.sample_input_tree_balanced\n",
     ")\n",
     "\n",
-    "X = X.unsqueeze(1)"
+    "X = torch.stack([example['input_ids'] for example in examples])\n",
+    "y = torch.stack([example['labels'] for example in examples])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -535,8 +536,8 @@
       "Train Results\n",
       "              precision    recall  f1-score   support\n",
       "\n",
-      "         0.0       1.00      1.00      1.00     50091\n",
-      "         1.0       1.00      1.00      1.00     49909\n",
+      "         0.0       1.00      1.00      1.00     50050\n",
+      "         1.0       1.00      1.00      1.00     49950\n",
       "\n",
       "    accuracy                           1.00    100000\n",
       "   macro avg       1.00      1.00      1.00    100000\n",
@@ -567,7 +568,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -599,7 +600,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -629,7 +630,7 @@
    "source": [
     "This dataset has the following components:\n",
     "\n",
-    "`input_ids`: a regular set of train examples\n",
+    "* `input_ids`: a regular set of train examples\n",
     "* `base_labels`: a regular set of train labels\n",
     "* `source_input_ids`: sets additional training inputs sets (here, two sets) for interchange interventions\n",
     "* `labels`: a list of labels if interchange interventions are performed with 'source_input_ids'\n",
@@ -638,7 +639,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 29,
    "metadata": {
     "scrolled": true
    },
@@ -647,22 +648,22 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([ 0.6100,  0.4000, -0.1600, -0.9400, -0.2400,  0.1000, -0.4500, -0.5500],\n",
+      "tensor([ 0.4700,  0.3500,  0.4700,  0.3500,  0.7800, -0.8300, -0.5600,  0.1800],\n",
       "       device='cuda:0')\n",
-      "tensor([[ 0.0700,  0.9500,  0.7800, -0.8300,  0.7200,  0.1500,  0.7200,  0.1500],\n",
+      "tensor([[-0.1600, -0.9400,  0.6600,  0.2400,  0.0700,  0.9500,  0.0700,  0.9500],\n",
       "        [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000]],\n",
       "       device='cuda:0')\n",
       "tensor([0.], device='cuda:0')\n",
       "tensor([1.], device='cuda:0')\n",
-      "tensor([1], device='cuda:0')\n"
+      "tensor([0], device='cuda:0')\n"
      ]
     }
    ],
    "source": [
     "print(dataset[0][\"input_ids\"])\n",
     "print(dataset[0][\"source_input_ids\"])\n",
-    "print(dataset[0][\"labels\"])\n",
     "print(dataset[0][\"base_labels\"])\n",
+    "print(dataset[0][\"labels\"])\n",
     "print(dataset[0][\"intervention_id\"])"
    ]
   },
@@ -678,7 +679,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -727,7 +728,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -743,7 +744,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
@@ -752,8 +753,8 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "         0.0       1.00      1.00      1.00       992\n",
-      "         1.0       1.00      1.00      1.00      1056\n",
+      "         0.0       1.00      1.00      1.00       997\n",
+      "         1.0       1.00      1.00      1.00      1051\n",
       "\n",
       "    accuracy                           1.00      2048\n",
       "   macro avg       1.00      1.00      1.00      2048\n",
@@ -781,7 +782,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -806,16 +807,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
     "n_examples = 1048576\n",
     "batch_size = 1024\n",
     "\n",
-    "X, y = equality_model.generate_factual_dataset(n_examples, input_sampler)\n",
+    "examples = equality_model.generate_factual_dataset(n_examples, input_sampler)\n",
+    "\n",
+    "X = torch.stack([example['input_ids'] for example in examples])\n",
+    "y = torch.stack([example['labels'] for example in examples])\n",
     "\n",
-    "X = X.unsqueeze(1)"
+    "# X = X.unsqueeze(1)"
    ]
   },
   {
@@ -827,18 +831,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(tensor([[-0.3600,  0.0400, -0.2900, -0.3400, -0.3600,  0.0400, -0.2900, -0.3400,\n",
-       "          -0.8400,  0.2000,  0.6300,  0.1000, -0.8400,  0.2000,  0.6300,  0.1000]]),\n",
-       " tensor([1.]))"
+       "(tensor([-0.7200,  0.6300,  1.0000,  0.6900, -0.7200,  0.6300,  1.0000,  0.6900,\n",
+       "          0.0800, -0.8800, -0.0400, -0.0400, -0.5200, -0.8500, -0.6400,  0.6400]),\n",
+       " tensor([0.]))"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 35,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -856,16 +860,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "False"
+       "True"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 36,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -878,16 +882,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "True"
+       "False"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -902,7 +906,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
@@ -911,7 +915,7 @@
        "0"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 38,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -929,7 +933,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 39,
    "metadata": {
     "scrolled": true
    },
@@ -959,7 +963,7 @@
        ")"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 39,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -978,7 +982,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -995,7 +999,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1033,151 +1037,170 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "267ad9a4be754be89e338aa6240214e4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3072 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/3072 [00:00<?, ?it/s]Could not estimate the number of tokens of the input, floating-point operations will not be computed\n",
-      " 16%|█▋        | 500/3072 [00:39<03:19, 12.90it/s]Checkpoint destination directory test_trainer\\checkpoint-500 already exists and is non-empty.Saving will proceed but saved results may be invalid.\n",
-      " 16%|█▋        | 501/3072 [00:39<03:23, 12.64it/s]"
+      "Could not estimate the number of tokens of the input, floating-point operations will not be computed\n",
+      "Checkpoint destination directory test_trainer\\checkpoint-500 already exists and is non-empty. Saving will proceed but saved results may be invalid.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'loss': 0.6181, 'learning_rate': 0.0008372395833333334, 'epoch': 0.49}\n"
+      "{'loss': 0.6401, 'grad_norm': 0.23116283118724823, 'learning_rate': 0.0008372395833333334, 'epoch': 0.49}\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " 33%|███▎      | 1000/3072 [01:18<02:43, 12.70it/s]Checkpoint destination directory test_trainer\\checkpoint-1000 already exists and is non-empty.Saving will proceed but saved results may be invalid.\n",
-      " 33%|███▎      | 1001/3072 [01:18<02:45, 12.53it/s]"
+      "Checkpoint destination directory test_trainer\\checkpoint-1000 already exists and is non-empty. Saving will proceed but saved results may be invalid.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'loss': 0.0998, 'learning_rate': 0.0006744791666666667, 'epoch': 0.98}\n"
+      "{'loss': 0.195, 'grad_norm': 0.18332688510417938, 'learning_rate': 0.0006744791666666667, 'epoch': 0.98}\n"
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                   \n",
-      " 33%|███▎      | 1025/3072 [02:14<4:41:24,  8.25s/it]"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6718015efcb34628b758ff359877ff36",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1024 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'eval_loss': 0.028182830661535263, 'eval_accuracy': 0.9933614730834961, 'eval_runtime': 54.3483, 'eval_samples_per_second': 19293.64, 'eval_steps_per_second': 18.841, 'epoch': 1.0}\n"
+      "{'eval_loss': 0.07157168537378311, 'eval_accuracy': 0.9790763854980469, 'eval_runtime': 37.061, 'eval_samples_per_second': 28293.236, 'eval_steps_per_second': 27.63, 'epoch': 1.0}\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " 49%|████▉     | 1500/3072 [02:52<02:09, 12.19it/s]  Checkpoint destination directory test_trainer\\checkpoint-1500 already exists and is non-empty.Saving will proceed but saved results may be invalid.\n",
-      " 49%|████▉     | 1501/3072 [02:52<02:08, 12.20it/s]"
+      "Checkpoint destination directory test_trainer\\checkpoint-1500 already exists and is non-empty. Saving will proceed but saved results may be invalid.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'loss': 0.0197, 'learning_rate': 0.00051171875, 'epoch': 1.46}\n"
+      "{'loss': 0.0472, 'grad_norm': 0.15438705682754517, 'learning_rate': 0.00051171875, 'epoch': 1.46}\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " 65%|██████▌   | 2000/3072 [03:31<01:22, 12.95it/s]Checkpoint destination directory test_trainer\\checkpoint-2000 already exists and is non-empty.Saving will proceed but saved results may be invalid.\n",
-      " 65%|██████▌   | 2001/3072 [03:31<01:24, 12.70it/s]"
+      "Checkpoint destination directory test_trainer\\checkpoint-2000 already exists and is non-empty. Saving will proceed but saved results may be invalid.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'loss': 0.0106, 'learning_rate': 0.00034895833333333334, 'epoch': 1.95}\n"
+      "{'loss': 0.025, 'grad_norm': 0.1841142624616623, 'learning_rate': 0.00034895833333333334, 'epoch': 1.95}\n"
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                   \n",
-      " 67%|██████▋   | 2049/3072 [04:29<2:20:34,  8.25s/it]"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ade15e1911a840ceb47b8c372e241568",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1024 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'eval_loss': 0.008572963066399097, 'eval_accuracy': 0.9978914260864258, 'eval_runtime': 54.2965, 'eval_samples_per_second': 19312.042, 'eval_steps_per_second': 18.859, 'epoch': 2.0}\n"
+      "{'eval_loss': 0.019501574337482452, 'eval_accuracy': 0.9946937561035156, 'eval_runtime': 37.7091, 'eval_samples_per_second': 27806.989, 'eval_steps_per_second': 27.155, 'epoch': 2.0}\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " 81%|████████▏ | 2500/3072 [05:04<00:44, 12.90it/s]  Checkpoint destination directory test_trainer\\checkpoint-2500 already exists and is non-empty.Saving will proceed but saved results may be invalid.\n",
-      " 81%|████████▏ | 2501/3072 [05:04<00:45, 12.64it/s]"
+      "Checkpoint destination directory test_trainer\\checkpoint-2500 already exists and is non-empty. Saving will proceed but saved results may be invalid.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'loss': 0.0077, 'learning_rate': 0.00018619791666666665, 'epoch': 2.44}\n"
+      "{'loss': 0.0177, 'grad_norm': 0.18471458554267883, 'learning_rate': 0.00018619791666666665, 'epoch': 2.44}\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " 98%|█████████▊| 3000/3072 [05:43<00:05, 12.53it/s]Checkpoint destination directory test_trainer\\checkpoint-3000 already exists and is non-empty.Saving will proceed but saved results may be invalid.\n",
-      " 98%|█████████▊| 3001/3072 [05:43<00:05, 12.46it/s]"
+      "Checkpoint destination directory test_trainer\\checkpoint-3000 already exists and is non-empty. Saving will proceed but saved results may be invalid.\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'loss': 0.0067, 'learning_rate': 2.34375e-05, 'epoch': 2.93}\n"
+      "{'loss': 0.0149, 'grad_norm': 0.15878142416477203, 'learning_rate': 2.34375e-05, 'epoch': 2.93}\n"
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "                                                   \n",
-      "100%|██████████| 3072/3072 [06:43<00:00,  7.61it/s]"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6611af998ca848efbcb7ad9afb3bc344",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1024 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'eval_loss': 0.006369216833263636, 'eval_accuracy': 0.9984416961669922, 'eval_runtime': 54.1017, 'eval_samples_per_second': 19381.566, 'eval_steps_per_second': 18.927, 'epoch': 3.0}\n",
-      "{'train_runtime': 403.5104, 'train_samples_per_second': 7795.903, 'train_steps_per_second': 7.613, 'train_loss': 0.12428548457683064, 'epoch': 3.0}\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
+      "{'eval_loss': 0.014224954880774021, 'eval_accuracy': 0.9962148666381836, 'eval_runtime': 42.0755, 'eval_samples_per_second': 24921.316, 'eval_steps_per_second': 24.337, 'epoch': 3.0}\n",
+      "{'train_runtime': 257.663, 'train_samples_per_second': 12208.692, 'train_steps_per_second': 11.923, 'train_loss': 0.15329135081265122, 'epoch': 3.0}\n"
      ]
     }
    ],
@@ -1189,14 +1212,22 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we create a seperate causal model with vector representations distinct from those used in training:"
+    "Next we create a separate causal model with vector representations distinct from those used in training:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 43,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hi!\n"
+     ]
+    }
+   ],
    "source": [
     "variables = [\"W\", \"X\", \"Y\", \"Z\", \"WX\", \"YZ\", \"O\"]\n",
     "\n",
@@ -1243,6 +1274,7 @@
     "    \"O\": (1.5, 3),\n",
     "}\n",
     "\n",
+    "\n",
     "test_equality_model = CausalModel(variables, values, parents, functions, pos=pos)"
    ]
   },
@@ -1255,7 +1287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
@@ -1266,11 +1298,18 @@
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 10/10 [00:00<00:00, 26.52it/s]"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "171e7809005a4020ab22e408905323ff",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/10 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
      "name": "stdout",
@@ -1278,38 +1317,32 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "         0.0       1.00      1.00      1.00      5026\n",
-      "         1.0       1.00      1.00      1.00      4974\n",
+      "         0.0       0.99      1.00      1.00      5026\n",
+      "         1.0       1.00      0.99      1.00      4974\n",
       "\n",
       "    accuracy                           1.00     10000\n",
       "   macro avg       1.00      1.00      1.00     10000\n",
       "weighted avg       1.00      1.00      1.00     10000\n",
       "\n"
      ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
     }
    ],
    "source": [
-    "X_test, y_test = test_equality_model.generate_factual_dataset(10000, input_sampler)\n",
+    "examples = test_equality_model.generate_factual_dataset(10000, input_sampler)\n",
     "print(\"Test Results\")\n",
     "\n",
     "test_ds = Dataset.from_dict(\n",
     "    {\n",
     "        \"labels\": [\n",
-    "            torch.FloatTensor([0, 1]) if i == 1 else torch.FloatTensor([1, 0])\n",
-    "            for i in y_test\n",
+    "            torch.FloatTensor([0, 1]) if example['labels'].item() == 1 else torch.FloatTensor([1, 0])\n",
+    "            for example in examples\n",
     "        ],\n",
-    "        \"inputs_embeds\": X_test,\n",
+    "        \"inputs_embeds\": torch.stack([example['input_ids'] for example in examples]),\n",
     "    }\n",
     ")\n",
     "\n",
     "test_preds = trainer.predict(test_ds)\n",
+    "y_test = [example['labels'].item() for example in examples]\n",
     "\n",
     "print(classification_report(y_test, test_preds[0].argmax(1)))"
    ]
@@ -1340,7 +1373,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 45,
    "metadata": {
     "scrolled": true
    },
@@ -1372,7 +1405,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -1393,7 +1426,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1426,13 +1459,53 @@
     "\n",
     "\n",
     "def batched_random_sampler(data):\n",
-    "    batch_indices = [_ for _ in range(int(len(train_dataset) / batch_size))]\n",
+    "    batch_indices = [_ for _ in range(int(len(data) / batch_size))]\n",
     "    random.shuffle(batch_indices)\n",
     "    for b_i in batch_indices:\n",
     "        for i in range(b_i * batch_size, (b_i + 1) * batch_size):\n",
     "            yield i"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def input_sampler(*args, **kwargs):\n",
+    "    A = randvec(4)\n",
+    "    B = randvec(4)\n",
+    "    C = randvec(4)\n",
+    "    D = randvec(4)\n",
+    "    if kwargs.get('output_var', None) is None:\n",
+    "        return random.choice([\n",
+    "            {\"W\": A, \"X\": B, \"Y\": C, \"Z\": D},\n",
+    "            {\"W\": A, \"X\": A, \"Y\": B, \"Z\": B},\n",
+    "            {\"W\": A, \"X\": A, \"Y\": C, \"Z\": D},\n",
+    "            {\"W\": A, \"X\": B, \"Y\": C, \"Z\": C}\n",
+    "        ])\n",
+    "    elif kwargs['output_var'] == 'WX' and kwargs['output_var_value']:\n",
+    "        return random.choice([\n",
+    "            {\"W\": A, \"X\": A, \"Y\": C, \"Z\": D},\n",
+    "            {\"W\": A, \"X\": A, \"Y\": C, \"Z\": C}\n",
+    "        ])\n",
+    "    elif kwargs['output_var'] == 'WX' and not kwargs['output_var_value']:\n",
+    "        return random.choice([\n",
+    "            {\"W\": A, \"X\": B, \"Y\": C, \"Z\": D},\n",
+    "            {\"W\": A, \"X\": B, \"Y\": C, \"Z\": C}\n",
+    "        ])\n",
+    "    elif kwargs['output_var'] == 'YZ' and kwargs['output_var_value']:\n",
+    "        return random.choice([\n",
+    "            {\"W\": A, \"X\": B, \"Y\": C, \"Z\": C},\n",
+    "            {\"W\": A, \"X\": A, \"Y\": C, \"Z\": C}\n",
+    "        ])\n",
+    "    else:\n",
+    "        return random.choice([\n",
+    "            {\"W\": A, \"X\": B, \"Y\": C, \"Z\": D},\n",
+    "            {\"W\": A, \"X\": A, \"Y\": C, \"Z\": D}\n",
+    "        ])"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1442,7 +1515,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 69,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1466,7 +1539,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 80,
    "metadata": {
     "scrolled": true
    },
@@ -1482,17 +1555,24 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Epoch: 0: 200it [00:38,  5.18it/s, loss=tensor(0.3494, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.928]\n",
-      "Epoch: 1: 200it [00:40,  5.00it/s, loss=tensor(0.1009, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.97] \n",
-      "Epoch: 2: 200it [00:40,  4.99it/s, loss=tensor(0.0559, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.983]\n",
-      "Epoch: 3: 200it [00:40,  5.00it/s, loss=tensor(0.0426, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.987]\n",
-      "Epoch: 4: 200it [00:40,  4.99it/s, loss=tensor(0.0284, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.989]\n",
-      "Epoch: 5: 200it [00:40,  5.00it/s, loss=tensor(0.0373, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.991]\n",
-      "Epoch: 6: 200it [00:39,  5.00it/s, loss=tensor(0.0264, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.992]\n",
-      "Epoch: 7: 200it [00:38,  5.17it/s, loss=tensor(0.0196, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.994]\n",
-      "Epoch: 8: 200it [00:39,  5.00it/s, loss=tensor(0.0287, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.993]\n",
-      "Epoch: 9: 200it [00:40,  5.00it/s, loss=tensor(0.0273, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.993]\n",
-      "Epoch: 100%|██████████| 10/10 [06:37<00:00, 39.75s/it]\n"
+      "Epoch: 0: 0it [00:00, ?it/s] [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0: 200it [01:17,  2.59it/s, loss=tensor(0.4580, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.872]\n",
+      "Epoch: 1: 200it [00:54,  3.69it/s, loss=tensor(0.4646, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.89] \n",
+      "Epoch: 2: 200it [00:53,  3.71it/s, loss=tensor(0.1925, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.962]\n",
+      "Epoch: 3: 200it [00:53,  3.71it/s, loss=tensor(0.5047, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.837]\n",
+      "Epoch: 4: 200it [00:54,  3.70it/s, loss=tensor(0.1448, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.969]\n",
+      "Epoch: 5: 200it [00:52,  3.81it/s, loss=tensor(0.1444, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.967]\n",
+      "Epoch: 6: 200it [00:58,  3.40it/s, loss=tensor(0.1562, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.97] \n",
+      "Epoch: 7: 200it [01:04,  3.09it/s, loss=tensor(0.1703, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.958]\n",
+      "Epoch: 8: 200it [01:05,  3.07it/s, loss=tensor(0.1553, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.959]\n",
+      "Epoch: 9: 200it [01:04,  3.10it/s, loss=tensor(0.1505, device='cuda:0', grad_fn=<NllLossBackward0>), acc=0.967]\n",
+      "Epoch: 100%|██████████| 10/10 [09:59<00:00, 59.91s/it]\n"
      ]
     }
    ],
@@ -1599,7 +1679,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1610,14 +1690,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Test: 100%|██████████| 2/2 [00:00<00:00, 29.50it/s]"
+      "Test:   0%|          | 0/2 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████| 2/2 [00:00<00:00, 14.01it/s]"
      ]
     },
     {
@@ -1626,12 +1713,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "         0.0       1.00      0.99      0.99      6466\n",
-      "         1.0       0.99      1.00      0.99      6334\n",
+      "         0.0       0.98      0.96      0.97      6407\n",
+      "         1.0       0.96      0.98      0.97      6393\n",
       "\n",
-      "    accuracy                           0.99     12800\n",
-      "   macro avg       0.99      0.99      0.99     12800\n",
-      "weighted avg       0.99      0.99      0.99     12800\n",
+      "    accuracy                           0.97     12800\n",
+      "   macro avg       0.97      0.97      0.97     12800\n",
+      "weighted avg       0.97      0.97      0.97     12800\n",
       "\n"
      ]
     },
@@ -1708,13 +1795,6 @@
     "        eval_preds += [torch.argmax(counterfactual_outputs[0], dim=1)]\n",
     "print(classification_report(torch.cat(eval_labels).cpu(), torch.cat(eval_preds).cpu()))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -1736,7 +1816,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.12"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/advanced_tutorials/MQNLI.ipynb b/tutorials/advanced_tutorials/MQNLI.ipynb
new file mode 100644
index 00000000..64bc1477
--- /dev/null
+++ b/tutorials/advanced_tutorials/MQNLI.ipynb
@@ -0,0 +1,1794 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Nested Heirarchical Structure with MQNLI\n",
+    "\n",
+    "In this notebook, we use `pyvene` to analyze language models on a complex heirarchical task: multiply-quantified natural language inference (MQNLI). \n",
+    "We begin by describing the causal structure that generates our data through semantic composition. Then, we analyze whether models that learn this task employ the same compositional structure to solve it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "__author__ = \"Amir Zur\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set-Up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "import pyvene"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json \n",
+    "import random\n",
+    "import copy\n",
+    "import itertools\n",
+    "import numpy as np\n",
+    "from tqdm import tqdm, trange\n",
+    "from collections import Counter\n",
+    "\n",
+    "import torch\n",
+    "from torch.nn import CrossEntropyLoss\n",
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import TrainingArguments, Trainer\n",
+    "from datasets import Dataset\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "\n",
+    "from pyvene import CausalModel\n",
+    "# from pyvene.models.configuration_intervenable_model import RepresentationConfig\n",
+    "from pyvene import (\n",
+    "    IntervenableModel,\n",
+    "    RotatedSpaceIntervention,\n",
+    "    RepresentationConfig,\n",
+    "    IntervenableConfig\n",
+    ")\n",
+    "\n",
+    "from pyvene.models.gpt2.modelings_intervenable_gpt2 import create_gpt2_lm\n",
+    "# from pyvene.models.gpt_neox.modelings_intervenable_gpt_neox import create_gpt_neox"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TRAIN_DIR = 'mqnli_factual'\n",
+    "DAS_DIR = 'mqnli_das'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x169a1e510b0>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "seed = 42\n",
+    "np.random.seed(seed)\n",
+    "random.seed(seed)\n",
+    "torch.manual_seed(seed)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The MQNLI Task\n",
+    "\n",
+    "Multiply-quantified natural language inference (MQNLI) is a variant of natural language inference (NLI) with a highly structured composition. Each datapoint is a pair of sentences, and each label is the logical relation between them (e.g., entailment, reverse entailment, no relation). Crucially, the logical relation can be computed compositionally: first compute the relation between the two sentences' nouns, then their determiners, and then combine these intermediate computations to find the relation between the sentences' noun phrases (NPs). \n",
+    "\n",
+    "In this section, we walk through the high-level causal structure of MQNLI with examples from the MQNLI dataset. We encourage first-time readers to read the original paper, [Geiger, Cases, Karttunen, and Potts (2018)](https://arxiv.org/pdf/1810.13033.pdf), before getting started."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# JSON files generated from adapting MQNLI codebase\n",
+    "# https://github.com/atticusg/MultiplyQuantifiedData\n",
+    "\n",
+    "class Hashabledict(dict):\n",
+    "    def __hash__(self):\n",
+    "        return hash(frozenset(self))\n",
+    "\n",
+    "with open('tutorial_data/mqnli_q_projectivity.json') as f:\n",
+    "    determiner_signatures = json.load(f)\n",
+    "    determiner_signatures = Hashabledict({\n",
+    "        q1: Hashabledict({\n",
+    "            q2: Hashabledict({\n",
+    "                r1: Hashabledict({\n",
+    "                    r2: determiner_signatures[q1][q2][r1][r2]  \n",
+    "                    for r2 in determiner_signatures[q1][q2][r1]\n",
+    "                })  \n",
+    "                for r1 in determiner_signatures[q1][q2]\n",
+    "            })\n",
+    "            for q2 in determiner_signatures[q1]\n",
+    "        })\n",
+    "        for q1 in determiner_signatures\n",
+    "    })\n",
+    "\n",
+    "with open('tutorial_data/mqnli_neg_signature.json') as f:\n",
+    "    negation_signature = Hashabledict(json.load(f))\n",
+    "\n",
+    "with open('tutorial_data/mqnli_empty_signature.json') as f:\n",
+    "    emptystring_signature = Hashabledict(json.load(f))\n",
+    "\n",
+    "with open('tutorial_data/mqnli_cont_signature.json') as f:\n",
+    "    compose_contradiction_signature = Hashabledict(json.load(f))\n",
+    "\n",
+    "with open('tutorial_data/mqnli_neg_cont_signature.json') as f:\n",
+    "    compose_neg_contradiction_signature = Hashabledict(json.load(f))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "parents = {\n",
+    "    \"N_P_O\": [],\n",
+    "    \"N_H_O\": [],\n",
+    "    \"N_O\": [\"N_P_O\", \"N_H_O\"],\n",
+    "    \"Adj_P_O\": [],\n",
+    "    \"Adj_H_O\": [],\n",
+    "    \"Adj_O\": [\"Adj_P_O\", \"Adj_H_O\"],\n",
+    "    \"NP_O\": [\"Adj_O\", \"N_O\"],\n",
+    "    \"Q_P_O\": [],\n",
+    "    \"Q_H_O\": [],\n",
+    "    \"Q_O\": [\"Q_P_O\", \"Q_H_O\"],\n",
+    "    \"V_P\": [],\n",
+    "    \"V_H\": [],\n",
+    "    \"V\": [\"V_P\", \"V_H\"],\n",
+    "    \"Adv_P\": [],\n",
+    "    \"Adv_H\": [],\n",
+    "    \"Adv\": [\"Adv_P\", \"Adv_H\"],\n",
+    "    \"VP\": [\"Adv\", \"V\"],\n",
+    "    \"QP_O\": [\"Q_O\", \"NP_O\", \"VP\"],\n",
+    "    \"Neg_P\": [],\n",
+    "    \"Neg_H\": [],\n",
+    "    \"Neg\": [\"Neg_P\", \"Neg_H\"],\n",
+    "    \"NegP\": [\"Neg\", \"QP_O\"],\n",
+    "    \"N_P_S\": [],\n",
+    "    \"N_H_S\": [],\n",
+    "    \"N_S\": [\"N_P_S\", \"N_H_S\"],\n",
+    "    \"Adj_P_S\": [],\n",
+    "    \"Adj_H_S\": [],\n",
+    "    \"Adj_S\": [\"Adj_P_S\", \"Adj_H_S\"],\n",
+    "    \"NP_S\": [\"Adj_S\", \"N_S\"],\n",
+    "    \"Q_P_S\": [],\n",
+    "    \"Q_H_S\": [],\n",
+    "    \"Q_S\": [\"Q_P_S\", \"Q_H_S\"],\n",
+    "    \"QP_S\": [\"Q_S\", \"NP_S\", \"NegP\"]\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "EMPTY = \"\"\n",
+    "IND = \"independence\"\n",
+    "EQV = \"equivalence\"\n",
+    "ENT = \"entails\"\n",
+    "REV = \"reverse entails\"\n",
+    "CON = \"contradiction\"\n",
+    "ALT = \"alternation\"\n",
+    "COV = \"cover\"\n",
+    "# all possible relation values from the original paper \n",
+    "# (https://arxiv.org/pdf/1810.13033.pdf)\n",
+    "RELATIONS = [IND, EQV, ENT, REV, CON, ALT, COV]\n",
+    "\n",
+    "Q_VALUES = [\n",
+    "    determiner_signatures[q1][q2]\n",
+    "    for q1 in determiner_signatures for q2 in determiner_signatures[q1]\n",
+    "]\n",
+    "\n",
+    "values = {\n",
+    "    \"N_P_O\": [\"tree\", \"rock\"],\n",
+    "    \"N_H_O\": [\"tree\", \"rock\"],\n",
+    "    \"N_O\": [EQV, IND],\n",
+    "    \"Adj_P_O\": [\"happy\", \"sad\", EMPTY],\n",
+    "    \"Adj_H_O\": [\"happy\", \"sad\", EMPTY],\n",
+    "    \"Adj_O\": [EQV, IND, ENT, REV],\n",
+    "    \"NP_O\": [EQV, IND, ENT, REV],\n",
+    "    \"Q_P_O\": [\"some\", \"every\"],\n",
+    "    \"Q_H_O\": [\"some\", \"every\"],\n",
+    "    \"Q_O\": Q_VALUES,\n",
+    "    \"V_P\": [\"climbed\", \"threw\"],\n",
+    "    \"V_H\": [\"climbed\", \"threw\"],\n",
+    "    \"V\": [EQV, IND],\n",
+    "    \"Adv_P\": [\"energetically\", \"joyfully\", EMPTY],\n",
+    "    \"Adv_H\": [\"energetically\", \"joyfully\", EMPTY],\n",
+    "    \"Adv\": [EQV, IND, ENT, REV],\n",
+    "    \"VP\": [EQV, IND, ENT, REV],\n",
+    "    \"QP_O\": [EQV, IND, ENT, REV],\n",
+    "    \"Neg_P\": [\"not\", EMPTY],\n",
+    "    \"Neg_H\": [\"not\", EMPTY],\n",
+    "    \"Neg\": [\n",
+    "        negation_signature, \n",
+    "        emptystring_signature, \n",
+    "        compose_contradiction_signature, \n",
+    "        compose_neg_contradiction_signature\n",
+    "    ],\n",
+    "    \"NegP\": RELATIONS,\n",
+    "    \"N_P_S\": [\"child\", \"dog\"],\n",
+    "    \"N_H_S\": [\"child\", \"dog\"],\n",
+    "    \"N_S\": [EQV, IND],\n",
+    "    \"Adj_P_S\": [\"little\", \"cute\", EMPTY],\n",
+    "    \"Adj_H_S\": [\"little\", \"cute\", EMPTY],\n",
+    "    \"Adj_S\": [EQV, IND, ENT, REV],\n",
+    "    \"NP_S\": [EQV, IND, ENT, REV],\n",
+    "    \"Q_P_S\": [\"some\", \"every\"],\n",
+    "    \"Q_H_S\": [\"some\", \"every\"],\n",
+    "    \"Q_S\": Q_VALUES,\n",
+    "    \"QP_S\": RELATIONS\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# adapted from original code for MQNLI:\n",
+    "# https://github.com/atticusg/MultiplyQuantifiedData/blob/master/natural_logic_model.py\n",
+    "\n",
+    "def adj_merge(adj_p, adj_h):\n",
+    "    if adj_p == adj_h:\n",
+    "        return EQV\n",
+    "    if adj_p == EMPTY:\n",
+    "        return REV\n",
+    "    if adj_h == EMPTY:\n",
+    "        return ENT\n",
+    "    return IND\n",
+    "\n",
+    "adv_merge = adj_merge\n",
+    "\n",
+    "def noun_phrase(adj, noun):\n",
+    "    #merges a noun relation with an adjective relation\n",
+    "    #or a verb relation with an adverb relation\n",
+    "    # makes sense: if the objects are the same, then adjective's relation holds\n",
+    "    # otherwise, they're independent\n",
+    "    if noun == EQV:\n",
+    "        return adj\n",
+    "    return IND\n",
+    "\n",
+    "verb_phrase = noun_phrase\n",
+    "\n",
+    "def negation_merge(neg_p, neg_h):\n",
+    "    #merges negation\n",
+    "    if neg_p == neg_h and neg_p == EMPTY:\n",
+    "        return Hashabledict(emptystring_signature)\n",
+    "    if neg_p == neg_h and neg_p != EMPTY:\n",
+    "        return Hashabledict(negation_signature)\n",
+    "    if neg_p == EMPTY:\n",
+    "        return Hashabledict(compose_contradiction_signature)\n",
+    "    if neg_p != EMPTY:\n",
+    "        return Hashabledict(compose_neg_contradiction_signature)\n",
+    "\n",
+    "negation_phrase = lambda neg, qp: neg[qp]\n",
+    "\n",
+    "noun_merge = lambda n_p, n_h: EQV if n_p == n_h else IND\n",
+    "verb_merge = noun_merge\n",
+    "\n",
+    "quantifier_merge = lambda q_p, q_h: determiner_signatures[q_p][q_h]\n",
+    "\n",
+    "quantifier_phrase = lambda q, np, vp: q[np][vp]\n",
+    "\n",
+    "functions = {\n",
+    "    \"N_P_O\": lambda: \"tree\",\n",
+    "    \"N_H_O\": lambda: \"tree\",\n",
+    "    \"N_O\": noun_merge,\n",
+    "    \"Adj_P_O\": lambda: \"happy\",\n",
+    "    \"Adj_H_O\": lambda: \"happy\",\n",
+    "    \"Adj_O\": adj_merge,\n",
+    "    \"NP_O\": noun_phrase,\n",
+    "    \"Q_P_O\": lambda: \"some\",\n",
+    "    \"Q_H_O\": lambda: \"some\",\n",
+    "    \"Q_O\": quantifier_merge,\n",
+    "    \"V_P\": lambda: \"climbed\",\n",
+    "    \"V_H\": lambda: \"climbed\",\n",
+    "    \"V\": verb_merge,\n",
+    "    \"Adv_P\": lambda: \"energetically\",\n",
+    "    \"Adv_H\": lambda: \"energetically\",\n",
+    "    \"Adv\": adv_merge,\n",
+    "    \"VP\": verb_phrase,\n",
+    "    \"QP_O\": quantifier_phrase,\n",
+    "    \"Neg_P\": lambda: \"not\",\n",
+    "    \"Neg_H\": lambda: \"not\",\n",
+    "    \"Neg\": negation_merge,\n",
+    "    \"NegP\": negation_phrase,\n",
+    "    \"N_P_S\": lambda: \"dog\",\n",
+    "    \"N_H_S\": lambda: \"dog\",\n",
+    "    \"N_S\": noun_merge,\n",
+    "    \"Adj_P_S\": lambda: \"cute\",\n",
+    "    \"Adj_H_S\": lambda: \"cute\",\n",
+    "    \"Adj_S\": adj_merge,\n",
+    "    \"NP_S\": noun_phrase,\n",
+    "    \"Q_P_S\": lambda: \"some\",\n",
+    "    \"Q_H_S\": lambda: \"some\",\n",
+    "    \"Q_S\": quantifier_merge,\n",
+    "    \"QP_S\": quantifier_phrase\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# coordinates to display the MQNLI tree\n",
+    "pos = {\n",
+    "    \"N_P_O\": (32, 0.3),\n",
+    "    \"N_H_O\": (30, 0.7),\n",
+    "    \"N_O\": (31, 1.3),\n",
+    "    \"Adj_P_O\": (28, 0),\n",
+    "    \"Adj_H_O\": (26, 0.5),\n",
+    "    \"Adj_O\": (27, 1),\n",
+    "    \"NP_O\": (29, 2),\n",
+    "    \"Q_P_O\": (24, 1.3),\n",
+    "    \"Q_H_O\": (22, 1.7),\n",
+    "    \"Q_O\": (23, 2.5),\n",
+    "    \"V_P\": (21, 0),\n",
+    "    \"V_H\": (19, 0.5),\n",
+    "    \"V\": (20, 1),\n",
+    "    \"Adv_P\": (17, -0.3),\n",
+    "    \"Adv_H\": (15, 0.2),\n",
+    "    \"Adv\": (16, 0.7),\n",
+    "    \"VP\": (18, 2),\n",
+    "    \"QP_O\": (25, 3),\n",
+    "    \"Neg_P\": (13, 2.5),\n",
+    "    \"Neg_H\": (11, 3),\n",
+    "    \"Neg\": (12, 3.5),\n",
+    "    \"NegP\": (14, 4),\n",
+    "    \"N_P_S\": (9, 2.2),\n",
+    "    \"N_H_S\": (7, 2.8),\n",
+    "    \"N_S\": (8, 3.3),\n",
+    "    \"Adj_P_S\": (5, 1.5),\n",
+    "    \"Adj_H_S\": (3, 2),\n",
+    "    \"Adj_S\": (4, 2.5),\n",
+    "    \"NP_S\": (6, 4.3),\n",
+    "    \"Q_P_S\": (2, 3.2),\n",
+    "    \"Q_H_S\": (0, 3.5),\n",
+    "    \"Q_S\": (1, 4),\n",
+    "    \"QP_S\": (10, 5)\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "variables = list(parents.keys())  # pretty sure this preserves order?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mqlni_model = CausalModel(variables, values, parents, functions, pos=pos)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We begin by visualizing the high-level structure of the MQNLI task. All leaf nodes consist of text entries (e.g., Adj_P_O might be \"fun\", N_H_O might be \"child\"), with one copy corresponding to the premise sentence (P) and the other corresponding to the hypothesis (H). All other nodes take on relation values (e.g., entailment, reverse entailment, no relation), or mappings between relations (e.g., (entailment, entailment) --> no entailment)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "mqlni_model.print_structure()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example MQNLI Input\n",
+    "\n",
+    "Here we walk through an example MQNLI input, presented below.\n",
+    "```json\n",
+    "Premise: Every dog climbed some tree.\n",
+    "Hypothesis: Some dog did not climb every tree.\n",
+    "```\n",
+    "\n",
+    "The output for this sentence pair is `contradiction`, because the premise entails that there cannot be a dog who climbed no tree. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = {\n",
+    "    # premise\n",
+    "    \"Q_P_S\": \"every\",\n",
+    "    \"Adj_P_S\": EMPTY,\n",
+    "    \"N_P_S\": \"dog\",\n",
+    "    \"Neg_P\": EMPTY,\n",
+    "    \"Adv_P\": EMPTY,\n",
+    "    \"V_P\": \"climbed\",\n",
+    "    \"Q_P_O\": \"some\",\n",
+    "    \"Adj_P_O\": EMPTY,\n",
+    "    \"N_P_O\": \"tree\",\n",
+    "    # hypothesis\n",
+    "    \"Q_H_S\": \"some\",\n",
+    "    \"Adj_H_S\": EMPTY,\n",
+    "    \"N_H_S\": \"dog\",\n",
+    "    \"Neg_H\": \"not\",\n",
+    "    \"Adv_H\": EMPTY,\n",
+    "    \"V_H\": \"climbed\",\n",
+    "    \"Q_H_O\": \"some\",\n",
+    "    \"Adj_H_O\": EMPTY,\n",
+    "    \"N_H_O\": \"tree\"\n",
+    "}\n",
+    "\n",
+    "setting = mqlni_model.run_forward(inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "every  dog   climbed some  tree\n",
+      "some  dog not  climbed some  tree\n",
+      "contradiction\n"
+     ]
+    }
+   ],
+   "source": [
+    "def print_premise(setting):\n",
+    "    print(\n",
+    "        setting[\"Q_P_S\"],\n",
+    "        setting[\"Adj_P_S\"],\n",
+    "        setting[\"N_P_S\"],\n",
+    "        setting[\"Neg_P\"],\n",
+    "        setting[\"Adv_P\"],\n",
+    "        setting[\"V_P\"],\n",
+    "        setting[\"Q_P_O\"],\n",
+    "        setting[\"Adj_P_O\"],\n",
+    "        setting[\"N_P_O\"]\n",
+    "    )\n",
+    "\n",
+    "def print_hypothesis(setting):\n",
+    "    print(\n",
+    "        setting[\"Q_H_S\"],\n",
+    "        setting[\"Adj_H_S\"],\n",
+    "        setting[\"N_H_S\"],\n",
+    "        setting[\"Neg_H\"],\n",
+    "        setting[\"Adv_H\"],\n",
+    "        setting[\"V_H\"],\n",
+    "        setting[\"Q_H_O\"],\n",
+    "        setting[\"Adj_H_O\"],\n",
+    "        setting[\"N_H_O\"]\n",
+    "    )\n",
+    "\n",
+    "print_premise(setting)\n",
+    "print_hypothesis(setting)\n",
+    "\n",
+    "print(setting[\"QP_S\"]) # the output is in the root node, QP_S"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We display the structure of the MQNLI example below. Note that the intermediate relation values compose with each other to produce the final output. For instance, since `N_O` and `Adj_O` both take on the value `equivalence`, then `NP_O` is also an equivalence relation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display = {v: not isinstance(values[v][0], dict) for v in variables}\n",
+    "mqlni_model.print_setting(setting, display=display)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### MQNLI with an Intervention\n",
+    "\n",
+    "Below is a run of the MQNLI logic model where we intervene on the object quantifier (`QP_O`) and swap its relation value from `equivalence` to `contradiction`. Note that this changes the final output from `contradiction` to `entailment`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "every  dog   climbed some  tree\n",
+      "some  dog not  climbed some  tree\n",
+      "entails\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "intervention = {**inputs, 'QP_O': 'contradiction'}\n",
+    "setting = mqlni_model.run_forward(intervention)\n",
+    "print_premise(setting)\n",
+    "print_hypothesis(setting)\n",
+    "print(setting[\"QP_S\"])\n",
+    "\n",
+    "mqlni_model.print_setting(setting, display=display)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training a Model on MQNLI\n",
+    "\n",
+    "In this section, we train a language model (GPT-2) on the MQNLI task. Importantly, we do not need to access the original MQNLI dataset to do this -- having set up our causal model earlier in this notebook, we can generate datapoints by sampling from it directly! "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = mqlni_model.generate_factual_dataset(100, sampler=mqlni_model.sample_input_tree_balanced, return_tensors=False)\n",
+    "\n",
+    "X = [example['input_ids'] for example in dataset]\n",
+    "y = [example['labels'] for example in dataset]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "some little child  energetically climbed some happy tree\n",
+      "every  child not energetically climbed some happy tree\n",
+      "alternation\n"
+     ]
+    }
+   ],
+   "source": [
+    "i = 0\n",
+    "\n",
+    "print_premise(X[i])\n",
+    "print_hypothesis(X[i])\n",
+    "print(y[i]['QP_S'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We want to make sure that we indeed sampled evenly from the causal structure. For now, we can just verify that every possible output value (i.e., the values of the root node `QP_S`) has enough datapoints. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Counter({'alternation': 16,\n",
+       "         'contradiction': 18,\n",
+       "         'reverse entails': 15,\n",
+       "         'independence': 14,\n",
+       "         'entails': 16,\n",
+       "         'equivalence': 10,\n",
+       "         'cover': 11})"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Counter([n['QP_S'] for n in y])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Time to train a language model!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    }
+   ],
+   "source": [
+    "config, tokenizer, model = create_gpt2_lm()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def premise_to_string(setting):\n",
+    "    return \\\n",
+    "        setting[\"Q_P_S\"] + ' ' + \\\n",
+    "        setting[\"Adj_P_S\"] + ' ' + \\\n",
+    "        setting[\"N_P_S\"] + ' ' + \\\n",
+    "        setting[\"Neg_P\"] + ' ' + \\\n",
+    "        setting[\"Adv_P\"] + ' ' + \\\n",
+    "        setting[\"V_P\"] + ' ' + \\\n",
+    "        setting[\"Q_P_O\"] + ' ' + \\\n",
+    "        setting[\"Adj_P_O\"] + ' ' + \\\n",
+    "        setting[\"N_P_O\"]\n",
+    "\n",
+    "def hypothesis_to_string(setting):\n",
+    "    return \\\n",
+    "        setting[\"Q_H_S\"] + ' ' + \\\n",
+    "        setting[\"Adj_H_S\"] + ' ' + \\\n",
+    "        setting[\"N_H_S\"] + ' ' + \\\n",
+    "        setting[\"Neg_H\"] + ' ' + \\\n",
+    "        setting[\"Adv_H\"] + ' ' + \\\n",
+    "        setting[\"V_H\"] + ' ' + \\\n",
+    "        setting[\"Q_H_O\"] + ' ' + \\\n",
+    "        setting[\"Adj_H_O\"] + ' ' + \\\n",
+    "        setting[\"N_H_O\"]\n",
+    "\n",
+    "def preprocess_input(setting):\n",
+    "    return f'Premise: {premise_to_string(setting)}\\nHypothesis: {hypothesis_to_string(setting)}\\nRelation: '\n",
+    "\n",
+    "def preprocess_output(setting):\n",
+    "    return setting['QP_S']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "IGNORE_INDEX = -100\n",
+    "MAX_LENGTH = 64\n",
+    "\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "def preprocess(X, y):\n",
+    "    examples = [preprocess_input(x) for x in X]\n",
+    "    labels = [preprocess_output(y) for y in y]\n",
+    "\n",
+    "    examples = tokenizer(\n",
+    "        examples, \n",
+    "        padding='max_length', \n",
+    "        max_length=MAX_LENGTH, \n",
+    "        truncation=True, \n",
+    "        return_tensors='pt'\n",
+    "    )\n",
+    "    labels = tokenizer(\n",
+    "        labels, \n",
+    "        padding='max_length', \n",
+    "        max_length=MAX_LENGTH, \n",
+    "        truncation=True, \n",
+    "        return_tensors='pt'\n",
+    "    )['input_ids'][:, 0] # get first token of label\n",
+    "    \n",
+    "    # put label at the last index\n",
+    "    examples['labels'] = torch.full_like(examples['input_ids'], IGNORE_INDEX)\n",
+    "    examples['labels'][:, -1] = labels\n",
+    "\n",
+    "    return examples\n",
+    "\n",
+    "train_dataset = preprocess(X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set the wandb project where this run will be logged\n",
+    "os.environ[\"WANDB_PROJECT\"]=TRAIN_DIR\n",
+    "\n",
+    "# save your trained model checkpoint to wandb\n",
+    "os.environ[\"WANDB_LOG_MODEL\"]=\"false\"\n",
+    "\n",
+    "def accuracy_metric(x):\n",
+    "    labels = x.label_ids[:, -1]\n",
+    "    # predictions = x.predictions[0].argmax(axis=-1)[:, -2]  # uncomment for gpt-neox\n",
+    "    predictions = x.predictions.argmax(axis=-1)[:, -2]\n",
+    "    return {\n",
+    "        'accuracy': accuracy_score(y_true=labels, y_pred=predictions),\n",
+    "    }\n",
+    "\n",
+    "train_ds = Dataset.from_dict(train_dataset)\n",
+    "\n",
+    "batch_size = 8\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=TRAIN_DIR,\n",
+    "    overwrite_output_dir=True,\n",
+    "    evaluation_strategy=\"epoch\",\n",
+    "    learning_rate=1e-05,\n",
+    "    num_train_epochs=1,\n",
+    "    per_device_train_batch_size=batch_size,\n",
+    "    per_device_eval_batch_size=batch_size,\n",
+    "    report_to=\"wandb\", # optional, remove if you don't want to log to wandb\n",
+    "    use_cpu=True,\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_ds,\n",
+    "    eval_dataset=train_ds,\n",
+    "    compute_metrics=accuracy_metric\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Train the model and log it in a Weights & Biases run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "wandb version 0.16.4 is available!  To upgrade, please run:\n",
+       " $ pip install wandb --upgrade"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "Tracking run with wandb version 0.16.3"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "Run data is saved locally in <code>c:\\Users\\amirz\\Source\\NLP\\clones\\pyvene\\tutorials\\advanced_tutorials\\wandb\\run-20240314_140315-cwmxs9sx</code>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "Syncing run <strong><a href='https://wandb.ai/amirzur1212/mqnli_factual/runs/cwmxs9sx' target=\"_blank\">derby-crumble-2</a></strong> to <a href='https://wandb.ai/amirzur1212/mqnli_factual' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       " View project at <a href='https://wandb.ai/amirzur1212/mqnli_factual' target=\"_blank\">https://wandb.ai/amirzur1212/mqnli_factual</a>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       " View run at <a href='https://wandb.ai/amirzur1212/mqnli_factual/runs/cwmxs9sx' target=\"_blank\">https://wandb.ai/amirzur1212/mqnli_factual/runs/cwmxs9sx</a>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b3008cdd19b4d1f80ef096f3d2c97ef",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/13 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3fd69497aae04b8c8a7be79b77196a5d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/13 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'eval_loss': 4.242105484008789, 'eval_accuracy': 0.17, 'eval_runtime': 12.9558, 'eval_samples_per_second': 7.719, 'eval_steps_per_second': 1.003, 'epoch': 1.0}\n",
+      "{'train_runtime': 52.4216, 'train_samples_per_second': 1.908, 'train_steps_per_second': 0.248, 'train_loss': 5.367249708909255, 'epoch': 1.0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import wandb \n",
+    "\n",
+    "_ = trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer.save_model(TRAIN_DIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We evaluate the model on the training dataset and a newly-sampled test dataset. The model generalizes, meaning it learned the MQNLI task!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "test_examples = mqlni_model.generate_factual_dataset(100, sampler=mqlni_model.sample_input_tree_balanced, return_tensors=False)\n",
+    "X = [example['input_ids'] for example in test_examples]\n",
+    "y = [example['labels'] for example in test_examples]\n",
+    "test_dataset = preprocess(X, y)\n",
+    "test_ds = Dataset.from_dict(test_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f8c92d344b674837bc7733b012829136",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/13 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'eval_loss': 4.242105484008789,\n",
+       " 'eval_accuracy': 0.17,\n",
+       " 'eval_runtime': 12.6987,\n",
+       " 'eval_samples_per_second': 7.875,\n",
+       " 'eval_steps_per_second': 1.024,\n",
+       " 'epoch': 1.0}"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = trainer.evaluate(train_ds)\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ce841fd20aad4b9fa81e502ee8fe8328",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/13 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'eval_loss': 4.242105484008789,\n",
+       " 'eval_accuracy': 0.17,\n",
+       " 'eval_runtime': 12.532,\n",
+       " 'eval_samples_per_second': 7.98,\n",
+       " 'eval_steps_per_second': 1.037,\n",
+       " 'epoch': 1.0}"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = trainer.evaluate(test_ds)\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bc294f9a84f24cbaa44ceeb6dc1e379c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Label(value='0.001 MB of 0.001 MB uploaded\\r'), FloatProgress(value=1.0, max=1.0)))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>\n",
+       "    table.wandb td:nth-child(1) { padding: 0 10px; text-align: left ; width: auto;} td:nth-child(2) {text-align: left ; width: 100%}\n",
+       "    .wandb-row { display: flex; flex-direction: row; flex-wrap: wrap; justify-content: flex-start; width: 100% }\n",
+       "    .wandb-col { display: flex; flex-direction: column; flex-basis: 100%; flex: 1; padding: 10px; }\n",
+       "    </style>\n",
+       "<div class=\"wandb-row\"><div class=\"wandb-col\"><h3>Run history:</h3><br/><table class=\"wandb\"><tr><td>eval/accuracy</td><td>▁▁▁</td></tr><tr><td>eval/loss</td><td>▁▁▁</td></tr><tr><td>eval/runtime</td><td>█▄▁</td></tr><tr><td>eval/samples_per_second</td><td>▁▅█</td></tr><tr><td>eval/steps_per_second</td><td>▁▅█</td></tr><tr><td>train/epoch</td><td>▁▁▁▁</td></tr><tr><td>train/global_step</td><td>▁▁▁▁</td></tr><tr><td>train/total_flos</td><td>▁</td></tr><tr><td>train/train_loss</td><td>▁</td></tr><tr><td>train/train_runtime</td><td>▁</td></tr><tr><td>train/train_samples_per_second</td><td>▁</td></tr><tr><td>train/train_steps_per_second</td><td>▁</td></tr></table><br/></div><div class=\"wandb-col\"><h3>Run summary:</h3><br/><table class=\"wandb\"><tr><td>eval/accuracy</td><td>0.17</td></tr><tr><td>eval/loss</td><td>4.24211</td></tr><tr><td>eval/runtime</td><td>12.532</td></tr><tr><td>eval/samples_per_second</td><td>7.98</td></tr><tr><td>eval/steps_per_second</td><td>1.037</td></tr><tr><td>train/epoch</td><td>1.0</td></tr><tr><td>train/global_step</td><td>13</td></tr><tr><td>train/total_flos</td><td>3266150400000.0</td></tr><tr><td>train/train_loss</td><td>5.36725</td></tr><tr><td>train/train_runtime</td><td>52.4216</td></tr><tr><td>train/train_samples_per_second</td><td>1.908</td></tr><tr><td>train/train_steps_per_second</td><td>0.248</td></tr></table><br/></div></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       " View run <strong style=\"color:#cdcd00\">derby-crumble-2</strong> at: <a href='https://wandb.ai/amirzur1212/mqnli_factual/runs/cwmxs9sx' target=\"_blank\">https://wandb.ai/amirzur1212/mqnli_factual/runs/cwmxs9sx</a><br/>Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "Find logs at: <code>.\\wandb\\run-20240314_140315-cwmxs9sx\\logs</code>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "wandb.finish()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Interpreting Our Model\n",
+    "\n",
+    "In this final section, we use distributed alignment search DAS from [Geiger*, Wu*, Potts, Icard, and Goodman (2024)](https://arxiv.org/pdf/2303.02536.pdf) to find an alignment between the high-level causal structure of MQNLI and our low-level language model trained on the MQNLI dataset.\n",
+    "\n",
+    "In this section, we won't search for an alignment over the entire causal structure. Instead, we will search for an alignment between the low-level model representations and the `NegP` token. Efficiently searching for a full alignment over a complex, nested causal structure is an open problem that is worth pursuing! "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    }
+   ],
+   "source": [
+    "config, tokenizer, model = create_gpt2_lm(name=TRAIN_DIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we set up our alignment. We will search for a subspace with a dimension of 128 (a fourth of our model's hidden dimension size) in the residual stream of the 10th layer of the model (out of 12 overall transformer layers)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = IntervenableConfig(\n",
+    "    model_type=type(model),\n",
+    "    representations=[\n",
+    "        RepresentationConfig(\n",
+    "            10,  # layer\n",
+    "            \"block_output\",  # intervention type\n",
+    "            \"pos\",  # intervention unit is now aligned with tokens\n",
+    "            1,  # max number of unit\n",
+    "            subspace_partition=[[0, 128]], \n",
+    "            # intervention_link_key=0,\n",
+    "        )\n",
+    "    ],\n",
+    "    intervention_types=RotatedSpaceIntervention,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:Detected use_fast=True means the intervention location will be static within a batch.\n",
+      "\n",
+      "In case multiple location tags are passed only the first one will be considered\n"
+     ]
+    }
+   ],
+   "source": [
+    "intervenable = IntervenableModel(config, model, use_fast=True)\n",
+    "# intervenable.set_device('cuda')\n",
+    "intervenable.disable_model_gradients()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Crucially, our interpretability experiments rely on a counterfactual dataset: for a given input, we want to consider what might happen had the value of `NegP` changed while all else remained the same. Fortunately, this is precisely what our causal model can provide us with! We can generate a counterfactual dataset by sampling inputs that only vary from each other on the `NegP` node."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sample_intervention(*args, **kwargs):\n",
+    "    return {\n",
+    "        'NegP' : random.choice(mqlni_model.values['NegP'])\n",
+    "    }\n",
+    "\n",
+    "def intervention_id(*args, **kwargs):\n",
+    "    return 0\n",
+    "\n",
+    "batch_size = 2 # specifies how many inputs we want per intervention that is sampled\n",
+    "\n",
+    "dataset = mqlni_model.generate_counterfactual_dataset(\n",
+    "    100, intervention_id, batch_size, \n",
+    "    sampler=mqlni_model.sample_input_tree_balanced, intervention_sampler=sample_intervention, return_tensors=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "alternation\n",
+      "independence\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(dataset[0]['base_labels']['QP_S'])\n",
+    "print(dataset[0]['labels']['QP_S'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Counter({'alternation': 23,\n",
+       "         'reverse entails': 10,\n",
+       "         'cover': 15,\n",
+       "         'equivalence': 15,\n",
+       "         'contradiction': 9,\n",
+       "         'independence': 14,\n",
+       "         'entails': 14})"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# check that base labels are diverse (should be guaranteed by sampling from balanced input tree)\n",
+    "Counter([d['base_labels']['QP_S'] for d in dataset])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Counter({'independence': 47,\n",
+       "         'reverse entails': 10,\n",
+       "         'entails': 9,\n",
+       "         'alternation': 20,\n",
+       "         'cover': 10,\n",
+       "         'contradiction': 3,\n",
+       "         'equivalence': 1})"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# check that counterfactuals labels are diverse (note that this could be skewed by the node's effect on the final output)\n",
+    "Counter([d['labels']['QP_S'] for d in dataset])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "IGNORE_INDEX = -100\n",
+    "MAX_LENGTH = 64\n",
+    "\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "def preprocess_input(setting):\n",
+    "    return f'Premise: {premise_to_string(setting)}\\nHypothesis: {hypothesis_to_string(setting)}\\nRelation: '\n",
+    "\n",
+    "def preprocess_output(setting):\n",
+    "    return setting['QP_S']\n",
+    "\n",
+    "def tokenize(x):\n",
+    "    return tokenizer(\n",
+    "        x, \n",
+    "        padding='max_length', \n",
+    "        max_length=MAX_LENGTH, \n",
+    "        truncation=True, \n",
+    "        return_tensors='pt'\n",
+    "    )\n",
+    "\n",
+    "def preprocess_counterfactual(data):\n",
+    "    preprocessed_data = []\n",
+    "    for d in data:\n",
+    "        base = preprocess_input(d['input_ids'])\n",
+    "        sources = [preprocess_input(d['source_input_ids'][0])]\n",
+    "        label = preprocess_output(d['labels'])\n",
+    "        base_label = preprocess_output(d['base_labels'])\n",
+    "\n",
+    "        preprocessed = {}\n",
+    "        preprocessed['input'] = tokenize(base)\n",
+    "        preprocessed['source'] = [tokenize(sources[0])]\n",
+    "        # place label at last index\n",
+    "        label = tokenize(label)['input_ids'][:, 0]\n",
+    "        preprocessed['label'] = torch.full_like(preprocessed['input']['input_ids'], IGNORE_INDEX)\n",
+    "        preprocessed['label'][:, -1] = label\n",
+    "        # repeat for base label\n",
+    "        base_label = tokenize(base_label)['input_ids'][:, 0]\n",
+    "        preprocessed['base_label'] = torch.full_like(preprocessed['input']['input_ids'], IGNORE_INDEX)\n",
+    "        preprocessed['base_label'][:, -1] = base_label\n",
+    "        preprocessed['intervention_id'] = torch.tensor(d['intervention_id'])\n",
+    "        preprocessed_data.append(preprocessed)\n",
+    "    return preprocessed_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dataset = preprocess_counterfactual(dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataloader = DataLoader(train_dataset, batch_size=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Set up our optimizer, loss function, and accuracy metric."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epochs = 3\n",
+    "batch_size = 8\n",
+    "gradient_accumulation_steps = 1\n",
+    "\n",
+    "optimizer_params = []\n",
+    "for k, v in intervenable.interventions.items():\n",
+    "    optimizer_params += [{\"params\": v[0].rotate_layer.parameters()}]\n",
+    "    break\n",
+    "optimizer = torch.optim.Adam(optimizer_params, lr=0.001)\n",
+    "\n",
+    "\n",
+    "def compute_metrics(eval_preds, eval_labels):\n",
+    "    accuracy = accuracy_score(\n",
+    "        y_pred=eval_preds[..., -2].squeeze().clone().detach().cpu().numpy(), \n",
+    "        y_true=eval_labels[..., -1].squeeze().clone().detach().cpu().numpy()\n",
+    "    )\n",
+    "    return {\n",
+    "        \"accuracy\": accuracy\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def compute_loss(outputs, labels):\n",
+    "    # Shift so that tokens < n predict n\n",
+    "    shift_logits = outputs[..., :-1, :].contiguous()\n",
+    "    shift_labels = labels[..., 1:].contiguous()\n",
+    "    # Flatten the tokens\n",
+    "    loss_fct = CrossEntropyLoss()\n",
+    "    loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))\n",
+    "    return loss"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run DAS to find an alignment between our high-level causal model and the language model trained on MQNLI."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "intervention trainable parameters:  589824\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch: 0: 100%|██████████| 12/12 [00:59<00:00,  4.93s/it, loss=6.88, acc=0]    \n",
+      "\n",
+      "Epoch: 1: 100%|██████████| 12/12 [00:58<00:00,  4.91s/it, loss=5.86, acc=0]   \n",
+      "\n",
+      "Epoch: 2: 100%|██████████| 12/12 [00:59<00:00,  4.98s/it, loss=6.37, acc=0]    \n",
+      "\n",
+      "Epoch: 100%|██████████| 3/3 [02:57<00:00, 59.28s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "intervenable.model.train()  # train enables drop-off but no grads\n",
+    "print(\"intervention trainable parameters: \", intervenable.count_parameters())\n",
+    "train_iterator = trange(0, int(epochs), desc=\"Epoch\")\n",
+    "\n",
+    "total_step = 0\n",
+    "for epoch in train_iterator:\n",
+    "    epoch_iterator = tqdm(\n",
+    "        DataLoader(\n",
+    "            train_dataset,\n",
+    "            batch_size=batch_size,\n",
+    "            drop_last=True\n",
+    "        ),\n",
+    "        desc=f\"Epoch: {epoch}\",\n",
+    "        position=0,\n",
+    "        leave=True\n",
+    "    )\n",
+    "    for batch in epoch_iterator:\n",
+    "        inputs = {k: v.to(intervenable.get_device()) for k, v in batch['input'].items()}\n",
+    "        sources = [{k: v.to(intervenable.get_device()) for k, v in s.items()} for s in batch['source']]\n",
+    "        _, counterfactual_outputs = intervenable(\n",
+    "            inputs,\n",
+    "            sources,\n",
+    "            {\"sources->base\": ([[[MAX_LENGTH - 2]] * batch_size], [[[MAX_LENGTH - 2]] * batch_size])},\n",
+    "            subspaces=[[[0]] * batch_size],\n",
+    "        )\n",
+    "\n",
+    "        eval_metrics = compute_metrics(\n",
+    "            counterfactual_outputs.logits.argmax(-1), batch[\"label\"].to(intervenable.get_device())\n",
+    "        )\n",
+    "\n",
+    "        # loss and backprop\n",
+    "        loss = compute_loss(\n",
+    "            counterfactual_outputs.logits, batch[\"label\"].to(intervenable.get_device())\n",
+    "        )\n",
+    "\n",
+    "        epoch_iterator.set_postfix({\"loss\": loss.item(), \"acc\": eval_metrics[\"accuracy\"]})\n",
+    "\n",
+    "        if gradient_accumulation_steps > 1:\n",
+    "            loss = loss / gradient_accumulation_steps\n",
+    "        loss.backward()\n",
+    "        if total_step % gradient_accumulation_steps == 0:\n",
+    "            optimizer.step()\n",
+    "            intervenable.set_zero_grad()\n",
+    "        total_step += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Directory 'mqnli_das' already exists.\n"
+     ]
+    }
+   ],
+   "source": [
+    "intervenable.save(DAS_DIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Evaluate DAS Alignment\n",
+    "\n",
+    "Lastly, we evaluate the accuracy of the alignment found by DAS. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:The key is provided in the config. Assuming this is loaded from a pretrained module.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    }
+   ],
+   "source": [
+    "config, tokenizer, model = create_gpt2_lm(name=TRAIN_DIR)\n",
+    "intervenable = IntervenableModel.load(DAS_DIR, model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, we evaluate the model's performance on the MQNLI factual task. As before, we expect our model to complete this task with nearly perfect accuracy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "examples = mqlni_model.generate_factual_dataset(100, sampler=mqlni_model.sample_input_tree_balanced, return_tensors=False)\n",
+    "X = [example['input_ids'] for example in examples]\n",
+    "y = [example['labels'] for example in examples]\n",
+    "test_factual_dataset = preprocess(X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def accuracy_metric(x):\n",
+    "    labels = x.label_ids[:, -1]\n",
+    "    # predictions = x.predictions[0].argmax(axis=-1)[:, -2]  # take one index before label\n",
+    "    predictions = x.predictions.argmax(axis=-1)[:, -2]\n",
+    "    return {\n",
+    "        'accuracy': accuracy_score(y_true=labels, y_pred=predictions),\n",
+    "    }\n",
+    "\n",
+    "test_factual_ds = Dataset.from_dict(test_factual_dataset)\n",
+    "\n",
+    "batch_size = 8\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"test_mqnli_trainer\",\n",
+    "    overwrite_output_dir=True,\n",
+    "    evaluation_strategy=\"epoch\",\n",
+    "    learning_rate=1e-05,\n",
+    "    num_train_epochs=1,\n",
+    "    per_device_train_batch_size=batch_size,\n",
+    "    per_device_eval_batch_size=batch_size,\n",
+    "    report_to=\"none\",\n",
+    "    use_cpu=True,\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=intervenable.model,\n",
+    "    args=training_args,\n",
+    "    compute_metrics=accuracy_metric\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ba33bc2aaff448c1bd8ef2e97ed4f74b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/13 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'eval_loss': 4.302060127258301,\n",
+       " 'eval_accuracy': 0.17,\n",
+       " 'eval_runtime': 18.8671,\n",
+       " 'eval_samples_per_second': 5.3,\n",
+       " 'eval_steps_per_second': 0.689}"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.evaluate(test_factual_ds)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we evaluate the DAS alignment on a newly-sampled counterfactual dataset. If our alignment generalizes, then we should expect a high interchange intervention accuracy (IIA) on the counterfactual dataset. We compute IIA by comparing the model's output with an interchange-intervention to the causal model's output with that same intervention applied to its high-level variables (i.e., we verify that an intervention changes the model's output in the direction that our causal model predicts). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 8\n",
+    "\n",
+    "dataset = mqlni_model.generate_counterfactual_dataset(\n",
+    "    1000, intervention_id, 1, \n",
+    "    sampler=mqlni_model.sample_input_tree_balanced, intervention_sampler=sample_intervention, return_tensors=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_cf_dataset = preprocess_counterfactual(dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_metrics(eval_preds, eval_labels):\n",
+    "    accuracy = accuracy_score(\n",
+    "        y_pred=eval_preds[..., -2].squeeze().clone().detach().cpu().numpy(), \n",
+    "        y_true=eval_labels[..., -1].squeeze().clone().detach().cpu().numpy()\n",
+    "    )\n",
+    "    return {\n",
+    "        \"accuracy\": accuracy\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "intervenable.set_device('cuda')\n",
+    "# intervenable.disable_intervention_gradients()\n",
+    "# intervenable.disable_model_gradients()\n",
+    "# intervenable.model.eval()  # train enables drop-off but no grads\n",
+    "print(\"intervention trainable parameters: \", intervenable.count_parameters())\n",
+    "\n",
+    "base_labels = None\n",
+    "counterfactual_labels = None\n",
+    "base_preds = None\n",
+    "counterfactual_preds = None\n",
+    "\n",
+    "batch_size = 8\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for batch in tqdm(DataLoader(\n",
+    "        test_cf_dataset,\n",
+    "        batch_size=batch_size,\n",
+    "        drop_last=True\n",
+    "    )):\n",
+    "        inputs = {k: v.to(intervenable.get_device()) for k, v in batch['input'].items()}\n",
+    "        sources = [{k: v.to(intervenable.get_device()) for k, v in s.items()} for s in batch['source']]\n",
+    "        _, counterfactual_outputs = intervenable(\n",
+    "            inputs,\n",
+    "            sources,\n",
+    "            {\"sources->base\": ([[[MAX_LENGTH - 2]] * batch_size], [[[MAX_LENGTH - 2]] * batch_size])},\n",
+    "            subspaces=[[[0]] * batch_size],\n",
+    "        )\n",
+    "\n",
+    "        if base_labels is None:\n",
+    "            # base_preds = base_outputs.logits.argmax(-1).clone().detach()\n",
+    "            # base_labels = batch['base_label']\n",
+    "            counterfactual_preds = counterfactual_outputs.logits.argmax(-1).clone().detach()\n",
+    "            counterfactual_labels = batch['label']\n",
+    "        else:\n",
+    "            # base_preds = torch.cat((base_preds, base_outputs.logits.argmax(-1).clone().detach()))\n",
+    "            # base_labels = torch.cat((base_labels, batch['base_label']))\n",
+    "            counterfactual_preds = torch.cat((counterfactual_preds, counterfactual_outputs.logits.argmax(-1).clone().detach()))\n",
+    "            counterfactual_labels = torch.cat((counterfactual_labels, batch['label']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'counterfactual_accuracy': 0.125}"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{\n",
+    "    # 'base_accuracy': compute_metrics(base_preds, base_labels)['accuracy'],\n",
+    "    'counterfactual_accuracy': compute_metrics(counterfactual_preds, counterfactual_labels)['accuracy']\n",
+    "}"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pyvene",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/advanced_tutorials/tutorial_data/mqnli_cont_signature.json b/tutorials/advanced_tutorials/tutorial_data/mqnli_cont_signature.json
new file mode 100644
index 00000000..3dea3991
--- /dev/null
+++ b/tutorials/advanced_tutorials/tutorial_data/mqnli_cont_signature.json
@@ -0,0 +1 @@
+{"equivalence": "contradiction", "entails": "alternation", "reverse entails": "cover", "contradiction": "equivalence", "cover": "reverse entails", "alternation": "entails", "independence": "independence"}
\ No newline at end of file
diff --git a/tutorials/advanced_tutorials/tutorial_data/mqnli_empty_signature.json b/tutorials/advanced_tutorials/tutorial_data/mqnli_empty_signature.json
new file mode 100644
index 00000000..659c5072
--- /dev/null
+++ b/tutorials/advanced_tutorials/tutorial_data/mqnli_empty_signature.json
@@ -0,0 +1 @@
+{"equivalence": "equivalence", "entails": "entails", "reverse entails": "reverse entails", "contradiction": "contradiction", "cover": "cover", "alternation": "alternation", "independence": "independence"}
\ No newline at end of file
diff --git a/tutorials/advanced_tutorials/tutorial_data/mqnli_neg_cont_signature.json b/tutorials/advanced_tutorials/tutorial_data/mqnli_neg_cont_signature.json
new file mode 100644
index 00000000..0de579e4
--- /dev/null
+++ b/tutorials/advanced_tutorials/tutorial_data/mqnli_neg_cont_signature.json
@@ -0,0 +1 @@
+{"equivalence": "contradiction", "entails": "cover", "reverse entails": "alternation", "contradiction": "equivalence", "cover": "entails", "alternation": "reverse entails", "independence": "independence"}
\ No newline at end of file
diff --git a/tutorials/advanced_tutorials/tutorial_data/mqnli_neg_signature.json b/tutorials/advanced_tutorials/tutorial_data/mqnli_neg_signature.json
new file mode 100644
index 00000000..6b258c6f
--- /dev/null
+++ b/tutorials/advanced_tutorials/tutorial_data/mqnli_neg_signature.json
@@ -0,0 +1 @@
+{"equivalence": "equivalence", "entails": "reverse entails", "reverse entails": "entails", "contradiction": "contradiction", "cover": "alternation", "alternation": "cover", "independence": "independence"}
\ No newline at end of file
diff --git a/tutorials/advanced_tutorials/tutorial_data/mqnli_q_projectivity.json b/tutorials/advanced_tutorials/tutorial_data/mqnli_q_projectivity.json
new file mode 100644
index 00000000..0de73f5b
--- /dev/null
+++ b/tutorials/advanced_tutorials/tutorial_data/mqnli_q_projectivity.json
@@ -0,0 +1 @@
+{"some": {"some": {"equivalence": {"equivalence": "equivalence", "entails": "entails", "reverse entails": "reverse entails", "contradiction": "cover", "cover": "cover", "alternation": "independence", "independence": "independence"}, "entails": {"equivalence": "entails", "entails": "entails", "reverse entails": "independence", "contradiction": "cover", "cover": "cover", "alternation": "independence", "independence": "independence"}, "reverse entails": {"equivalence": "reverse entails", "entails": "independence", "reverse entails": "reverse entails", "contradiction": "cover", "cover": "cover", "alternation": "independence", "independence": "independence"}, "independence": {"equivalence": "independence", "entails": "independence", "reverse entails": "independence", "contradiction": "independence", "cover": "independence", "alternation": "independence", "independence": "independence"}}, "every": {"equivalence": {"equivalence": "reverse entails", "entails": "independence", "reverse entails": "reverse entails", "contradiction": "contradiction", "cover": "cover", "alternation": "alternation", "independence": "independence"}, "entails": {"equivalence": "reverse entails", "entails": "independence", "reverse entails": "reverse entails", "contradiction": "alternation", "cover": "independence", "alternation": "alternation", "independence": "independence"}, "reverse entails": {"equivalence": "reverse entails", "entails": "independence", "reverse entails": "reverse entails", "contradiction": "cover", "cover": "cover", "alternation": "independence", "independence": "independence"}, "independence": {"equivalence": "independence", "entails": "independence", "reverse entails": "independence", "contradiction": "independence", "cover": "independence", "alternation": "independence", "independence": "independence"}}}, "every": {"every": {"equivalence": {"equivalence": "equivalence", "entails": "entails", "reverse entails": "reverse entails", "contradiction": "alternation", "cover": "independence", "alternation": "alternation", "independence": "independence"}, "entails": {"equivalence": "reverse entails", "entails": "independence", "reverse entails": "reverse entails", "contradiction": "alternation", "cover": "independence", "alternation": "alternation", "independence": "independence"}, "reverse entails": {"equivalence": "entails", "entails": "entails", "reverse entails": "independence", "contradiction": "alternation", "cover": "independence", "alternation": "alternation", "independence": "independence"}, "independence": {"equivalence": "independence", "entails": "independence", "reverse entails": "independence", "contradiction": "independence", "cover": "independence", "alternation": "independence", "independence": "independence"}}, "some": {"equivalence": {"equivalence": "entails", "reverse entails": "independence", "entails": "entails", "contradiction": "contradiction", "cover": "cover", "alternation": "alternation", "independence": "independence"}, "reverse entails": {"equivalence": "entails", "reverse entails": "independence", "entails": "entails", "contradiction": "alternation", "cover": "independence", "alternation": "alternation", "independence": "independence"}, "entails": {"equivalence": "entails", "reverse entails": "independence", "entails": "entails", "contradiction": "cover", "cover": "cover", "alternation": "independence", "independence": "independence"}, "independence": {"equivalence": "independence", "reverse entails": "independence", "entails": "independence", "contradiction": "independence", "cover": "independence", "alternation": "independence", "independence": "independence"}}}}
\ No newline at end of file