diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_100.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_100.txt
new file mode 100644
index 0000000..6c388a4
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_100.txt
@@ -0,0 +1,182 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```css
+<dungeon> ::= <path>
+
+<path> ::= <room> { <direction> <room> }
+
+<room> ::= <description> [<item>] [<monster>] [<quest>]
+
+<direction> ::= "north" | "south" | "east" | "west"
+
+<description> ::= <adjective> { <adjective> } <noun>
+
+<adjective> ::= "dark" | "dank" | "twisty" | "secret" | "hidden"
+
+<noun> ::= "passage" | "corridor" | "chamber" | "cavern"
+
+<item> ::= <article> { <adjective> } <noun> [<verb>]
+
+<article> ::= "a" | "an" | "the"
+
+<monster> ::= <article> { <adjective> } <noun>
+
+<quest> ::= "a quest to " <verb> <noun>
+
+<verb> ::= "slay" | "retrieve" | "rescue" | "find"
+
+<noun> ::= "dragon" | "treasure" | "princess" | "key"
+```
+This grammar defines a `dungeon` as a sequence of `room`s connected by `direction`s. Each `room` has a `description`, which can include one or more `item`s, `monster`s, and/or `quest`s. The `item`, `monster`, and `quest` non-terminals are used to generate specific objects, creatures, and tasks that may be encountered in the dungeon.
+
+You can use this grammar to generate a variety of prompts for creating different parts of the dungeon by expanding each non-terminal into a prompt template. For example, you could generate a prompt for creating a `room` like this:
+```less
+Imagine a room in the dungeon with a [description]. There is a [item] in the corner and a [monster] lurking in the shadows. The room is connected to the rest of the dungeon by a [direction] passage.
+```
+You can then use this prompt template to generate specific prompts for different rooms, items, monsters, and directions by substituting appropriate values for each non-terminal. For example:
+```vbnet
+Imagine a room in the dungeon with a dark, twisty passage leading north. There is a secret door in the east wall. The room is filled with glowing mushrooms and a small stream runs through the middle. A fierce dragon guards a hoard of treasure in the back of the room. The room is connected to the rest of the dungeon by a narrow, hidden passage to the south.
+```
+By generating a large number of prompts using this grammar, you can create a diverse and interesting dungeon that challenges players and provides plenty of opportunities for adventure.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_101.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_101.txt
new file mode 100644
index 0000000..0fa1839
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_101.txt
@@ -0,0 +1,182 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```css
+<prompt> ::= "Imagine a " <dungeon-element> " in the " <location> " of the dungeon, connected to a " <connected-element>"."
+
+<dungeon-element> ::= <type-name> | <theme> | <monster> | <treasure>
+
+<type-name> ::= "weapon" | "spell" | "artifact" | "magic item" | "quest" | "challenge" | "hero journey"
+
+<theme> ::= "drama" | "music" | "art" | "secrets" | "occult" | "reveal"
+
+<monster> ::= <simple-monster> | <complex-monster>
+
+<simple-monster> ::= "goblin" | "orc" | "troll" | "skeleton" | "zombie" | "ghost" | "witch" | "warlock"
+
+<complex-monster> ::= <simple-monster> "boss" | "giant" | "<any other complex monster>"
+
+<treasure> ::= <common-treasure> | <rare-treasure>
+
+<common-treasure> ::= "gold coins" | "silver coins" | "bronze coins" | "gemstones" | "jewelry"
+
+<rare-treasure> ::= "<legendary weapon>" | "<ancient artifact>" | "<powerful spell>"
+
+<location> ::= <simple-location> | <complex-location>
+
+<simple-location> ::= "entrance" | "corridor" | "room" | "hallway" | "vault" | "chest" | "bag" | "wallet"
+
+<complex-location> ::= "dungeon level 1" | "dungeon level 2" | "<any other complex location>"
+
+<connected-element> ::= <simple-connected-element> | <complex-connected-element>
+
+<simple-connected-element> ::= "previous room" | "next room" | "left corridor" | "right corridor"
+
+<complex-connected-element> ::= "<any other connected element>"
+```
+This grammar allows you to generate prompts for creating different elements of the dungeon in specific locations, and specify how they are connected to each other. The grammar can be easily extended with new types of elements or locations as needed.
+
+For example, a prompt generated using this grammar could look like: "Imagine a weapon in the entrance of the dungeon, connected to a goblin boss."
+
+You can use this grammar as a starting point and customize it to suit your specific needs. You may also want to add additional constraints or rules to ensure that the generated prompts are valid and make sense for your simulation.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_102.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_102.txt
new file mode 100644
index 0000000..832db3f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_102.txt
@@ -0,0 +1,174 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path = {room} end\_room
+
+room = room\_type " in " place
+
+room\_type = "a " type\_name with a " type\_modifier
+
+type\_name = ("weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey")
+
+type\_modifier = ("small" | "medium" | "large" | "powerful" | "weak" | "rare" | "common" | "unique")
+
+place = (place\_name | place\_description)
+
+place\_name = ("the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "Plato's cave" | "Garden of Eden" | "the river Styx" | "the restaurant at the end of the universe")
+
+place\_description = {adjective} noun
+
+adjective = ("dark" | "damp" | "cramped" | "twisting" | "narrow" | "ancient" | "cursed" | "haunted" | "secret" | "abandoned" | "derelict" | "dilapidated")
+
+noun = ("corridor" | "passageway" | "tunnel" | "chamber" | "crypt" | "cavern" | "maze" | "labyrinth" | "ruin" | "temple" | "shrine" | "tomb" | "vault")
+
+end\_room = "the final destination, " place
+
+This grammar allows for the generation of prompts that describe a path through a dungeon, starting at the entrance and ending at the final destination. Each room in the path is described by its type (e.g. weapon, spell, treasure) and any relevant modifiers (e.g. small, powerful, rare), as well as its location within the dungeon. The final destination is also described.
+
+Here is an example of a prompt that could be generated using this grammar:
+
+"Imagine a path through the dungeon starting at the entrance and leading all the way to the final destination. The first room is a medium-sized treasure with a rare golden sword in a dark, damp corridor. The next room is a small, cursed monster with a weak goblin in a cramped, twisting passageway. The final destination is the end of the dungeon, located in an ancient temple."
+
+This prompt can be used to generate a path through the dungeon by filling in the details for each room and the final destination. This could be done manually or using a program that generates random values for the different elements of the prompt.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_103.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_103.txt
new file mode 100644
index 0000000..c42b5f7
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_103.txt
@@ -0,0 +1,161 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+<dungeon> ::= <path>
+<path> ::= <room> | <room> "connected with" <path>
+<room> ::= <type_name> "with a" <type_term> <verb> <place>
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<type_term> ::= <noun>
+<noun> ::= "dungeon" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout" | "platos cave" | "garden of eden" | "river styx" | "restaurant at the end of the universe"
+<verb> ::= <verb_base> | <verb_base> "doing" <verb_noun>
+<verb_base> ::= "imagine" | "consider" | "draw" | "paint" | "compose" | "balance"
+<verb_noun> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-analyze"
+<place> ::= <noun>
+```
+This grammar allows for the generation of prompts that describe a path through a dungeon, starting at the entrance and going all the way to the end. Each room in the dungeon is described by its type (e.g. weapon, spell, artifact), a specific term associated with that type (e.g. sword, fireball, invisibility cloak), and a verb describing an action related to that type (e.g. imagine wielding, consider casting, design creating). The rooms are connected by paths, which can be described in terms of the rooms they connect and the verbs used to describe those connections.
+
+The grammar also includes a list of possible nouns that can be used to describe places within the dungeon, as well as a list of possible verbs that can be used to describe actions related to the types and terms. The verb\_noun section is open-ended allowing for more verb to be added in the future if needed.
+
+It's worth noting that this grammar is just an example and it could be adjusted based on specific needs of your project. It can also be extended with additional elements, such as enemies, traps or treasures, to make the dungeon more interesting.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_104.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_104.txt
new file mode 100644
index 0000000..c1b89a8
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_104.txt
@@ -0,0 +1,164 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```css
+path = [room], { room | hallway } , [room] ;
+room = <type_name> , "in" , <place> ;
+hallway = "connecting" , <place> , "to" , <place> ;
+<type_name> = "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" ;
+<place> = <proper_noun> | <article> , <adjective>* , <common_noun> ;
+<article> = "the" | "a" | "an" ;
+<adjective> = <word> ;
+<common_noun> = "country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout" ;
+<proper_noun> = "Plato's Cave" | "Garden of Eden" | "River Styx" | "Restaurant at the End of the Universe" ;
+```
+This grammar defines a path as an optional list of rooms, followed by zero or more rooms or hallways, and then an optional list of rooms. A room is defined as a type name, followed by "in", and a place. A hallway is defined as "connecting" two places. The `<type_name>` non-terminal matches any of the type terms, and the `<place>` non-terminal matches either a proper noun or an article followed by zero or more adjectives and a common noun.
+
+This grammar can be used to generate prompts for creating the dungeon by expanding the non-terminals in the path production. For example, here is a prompt that could be generated from this grammar:
+```vbnet
+Imagine you are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : specify; Type Name: treasure; Place: a dark cave connected with the entrance of the dungeon What is your response? Please generate variant array of size 3
+```
+This prompt was generated by expanding the `<path>` non-terminal to a list of two rooms, the first of which has a type name of "treasure" and a place of "a dark cave", and the second of which is connected with the entrance of the dungeon. The verb used in this prompt is "specify".
+
+You can use this grammar as a starting point to generate more complex paths through the dungeon, including branches, loops, and dead ends. You can also expand it to include other elements of the dungeon, such as traps, puzzles, and NPCs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_105.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_105.txt
new file mode 100644
index 0000000..7cdfb6b
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_105.txt
@@ -0,0 +1,210 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```css
+<prompt> ::= "Imagine" <dungeon-path>
+
+<dungeon-path> ::=
+    <path-segment>
+  | <path-segment> <dungeon-path>
+
+<path-segment> ::=
+    "a path from" <place1> "to" <place2>
+  | "a room with a" <type-name1> "<verb1>" <type-name2>
+
+<place1> ::= <place>
+
+<place2> ::= <place>
+
+<type-name1> ::= <type-term>
+
+<type-name2> ::= <type-term>
+
+<verb1> ::= <verb>
+
+<place> ::= "the entrance"
+          | "the labyrinth"
+          | "the treasure room"
+          | "the boss room"
+          | <other-place>
+
+<other-place> ::= <identifier>
+
+<type-term> ::= "weapon"
+                | "spell"
+                | "artifact"
+                | "magic item"
+                | "treasure"
+                | "monster"
+                | "quest"
+                | "challenge"
+                | "theme"
+                | "drama"
+                | "music"
+                | "art"
+                | "secret"
+                | "occult"
+                | "reveal"
+                | "hero journey"
+
+<verb> ::= "role-playing"
+          | "specifying"
+          | "encoding"
+          | "programming"
+          | "proving"
+          | "creating"
+          | "designing"
+          | "composing"
+          | "balancing"
+          | <other-verb>
+
+<other-verb> ::= <identifier>
+```
+This grammar defines a `prompt` rule, which consists of the word "Imagine" followed by a `dungeon-path`. The `dungeon-path` rule can be either a single `path-segment`, or a sequence of multiple `path-segments`.
+
+The `path-segment` rule represents a single step in the dungeon path. It can be either a path between two places, or a room with a particular type and verb. The `place1` and `place2` rules represent the starting and ending points of a path segment, respectively.
+
+The `type-name1`, `type-name2`, and `verb1` rules define the types and verbs that can be used in a room description. The `place`, `type-term`, and `verb` rules allow for custom identifiers to be used in place of specific values. This allows for more flexibility when generating prompts.
+
+Overall, this grammar provides a structure for generating prompts for creating a dungeon, starting from the entrance and moving through the labyrinth to the treasure room and boss room. It can be easily extended or modified to suit the needs of a specific application.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_106.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_106.txt
new file mode 100644
index 0000000..2a90958
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_106.txt
@@ -0,0 +1,163 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= [entrance room]+ exit
+entrance ::= "Enter the " place
+room ::= place description action
+place ::= "the " (determiner)* noun
+determiner ::= "a" | "an" | "the"
+noun ::= "dungeon" | "corridor" | "chamber" | "passage" | ...
+description ::= "with a " term
+term ::= "dark" | "lit" | "narrow" | "wide" | "twisting" | ...
+action ::= "guarding" | "hiding" | "revealing" | "protecting" | ...
+exit ::= "Exit the " place
+
+This grammar describes a dungeon as a series of rooms, each with a unique description and action. The entrance to the dungeon is also described, and the exit from the dungeon is defined as well. Each room is connected to the previous room through a shared place or location. This grammar can be used to generate prompts for creating a dungeon by randomly selecting elements from each non-terminal in the grammar and combining them into a complete prompt.
+
+For example, using this grammar, we could generate the following prompt: "Enter the dimly lit corridor guarding a secret passage. Descend into the narrow, twisting passage revealing a hidden chamber protected by a group of goblins. Exit the damp, musty chamber leading to the next level."
+
+This prompt instructs the user to imagine entering a dungeon through a dimly lit corridor that guards a secret passage. The user is then asked to descend into the narrow, twisting passage, which reveals a hidden chamber protected by a group of goblins. Finally, the user is told to exit the damp, musty chamber and move on to the next level of the dungeon.
+
+This prompt can be used as input to a language model or other AI system to generate a detailed description of the dungeon, including any monsters, treasures, or other elements that might be found there. By using this grammar to generate prompts, we can create a wide variety of unique and interesting dungeons for use in a fantasy role-playing game.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_107.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_107.txt
new file mode 100644
index 0000000..735753a
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_107.txt
@@ -0,0 +1,174 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a path through a dungeon:
+```makefile
+path = {room}* exit;
+
+room = "Enter" location, "and find", action, ", then move" direction, ";";
+
+location = identifier;
+
+action = verb, "a", object;
+
+verb = "examine" | "search" | "fight" | "interact with";
+
+object = noun;
+
+noun = "chest" | "monster" | "treasure" | "artifact" | "trap";
+
+direction = "north" | "south" | "east" | "west" | "up" | "down";
+
+exit = "Exit the dungeon through" direction ";";
+
+identifier = [a-zA-Z_]+;
+```
+This grammar describes a path through a dungeon as a series of rooms, where each room is defined by an action that the player can take and a location in which they can take it. The action is performed on an object, such as a chest or a monster. Each room is connected to the next via a direction (north, south, east, west, up, or down). The path ends with an exit statement, indicating how the player can leave the dungeon.
+
+In this example, `identifier`, `verb`, and `noun` are non-terminal symbols that correspond to words in the English language. The grammar uses them to create meaningful prompts for generating descriptions of rooms in a fantasy setting. For example, a possible prompt generated from this grammar could be:
+```vbnet
+Enter the Entrance Hall and examine a chest, then move north; Enter the Antechamber and search a monster, then move west; Enter the Guard Chamber and fight a goblin, then move south; Exit the dungeon through down;
+```
+This prompt describes a path through a dungeon with three rooms. In each room, the player can take an action on an object (examine a chest, search a monster, or fight a goblin). The direction to the next room is indicated by `north`, `west`, and `south` respectively. The path ends with an exit statement that specifies how to leave the dungeon.
+
+Note: This grammar can be further extended and modified to generate more complex prompts for creating dungeons with different themes, challenges, and other elements of a typical RPG setting.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_108.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_108.txt
new file mode 100644
index 0000000..7f18dbd
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_108.txt
@@ -0,0 +1,173 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```
+<dungeon> ::= <path>+
+<path> ::= <room> <direction> <path> | <room>
+<room> ::= <description> | <description> <interaction>
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+<description> ::= "You are in a " <place>"." | "You see a " <type_name> " here."
+<interaction> ::= "There is a " <verb> " to " <place>"." | "There is a " <verb> " door to " <place>"."
+<place> ::= <location> | <location> " with a " <feature>
+<location> ::= "dungeon" | "room" | "corridor" | "chamber" | "hallway"
+<feature> ::= <top_term> | <top_term> " of " <type_name>
+<type_name> ::= <simple_type_name> | <simple_type_name> " with a " <property>
+<simple_type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge"
+<property> ::= <adjective> | <adjective> "-infused"
+<adjective> ::= "fire" | "ice" | "lightning" | "poison" | "shadow"
+<verb> ::= "use" | "open" | "cast" | "fight" | "complete"
+```
+This grammar describes a dungeon as a collection of paths, where each path is made up of one or more rooms connected by directions. Each room can have a description and/or an interaction associated with it. The description provides information about the location, while the interaction allows for some action to be taken in that room.
+
+The grammar also includes several non-terminal symbols that are used to generate the various elements of the prompt. For example, `<location>` can be "dungeon", "room", "corridor", "chamber", or "hallway", while `<feature>` can be a top term (e.g. "Imagine" or "Consider") or a top term modified by a type name.
+
+By using this grammar, you can generate prompts that ask the language model to create different parts of the dungeon in a consistent and structured way. For example, a prompt generated from this grammar might look like this:
+```
+Imagine you are in a room with a fire-infused weapon. There is a use door to the north connected with a chamber. You see a monster here.
+```
+This prompt tells the language model to imagine a room with a fire-infused weapon, and that there is a door leading to a chamber to the north. The player can "use" the door, and there is a monster in the room.
+
+You can also use this grammar to generate prompts for different parts of the dungeon, such as the entrance or the treasure chamber, by specifying the appropriate starting non-terminal symbol. For example, to generate a prompt for the entrance of the dungeon, you would start with `<room>` and generate the rest of the prompt using the grammar rules.
+
+I hope this helps! Let me know if you have any questions or need further clarification.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_109.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_109.txt
new file mode 100644
index 0000000..2dffdf2
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_109.txt
@@ -0,0 +1,156 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+<prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+<type_name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<path> ::= <prompt> <type_name> with a <verb> doing <verb> in a <place> connected with <place>
+```
+This grammar allows you to generate prompts for creating different types of items, such as weapons or spells, using different verbs like "role-play" or "code", and connecting them to other places.
+
+You can use this grammar as a starting point and add more rules and elements as needed. For example, you may want to include more options for the `<verb>` and `<place>` non-terminals, or add new non-terminals to represent different aspects of the dungeon like enemies or traps.
+
+It is also possible to generate prompts randomly using this grammar by recursively expanding the non-terminals until all the elements are terminals, then concatenating them into a single string. This approach can be useful for generating large numbers of prompts quickly and easily.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_110.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_110.txt
new file mode 100644
index 0000000..a1970fe
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_110.txt
@@ -0,0 +1,181 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```less
+<prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+<verb>   ::= <verb_simple> | <verb_complex>
+<verb_simple> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove"
+                  | "create" | "design" | "analyse" | "lift" | "shift" | "splice"
+                  | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml"
+                  | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+                  | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+                  | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+                  | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+                  | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+                  | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act"
+                  | "meta-quote"
+<verb_complex> ::= <verb_simple> "doing" <verb_action>
+<verb_action>   ::= "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel"
+                    | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote"
+                    | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml"
+                    | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+                    | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+                    | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+                    | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+                    | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+                    | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act"
+                    | "meta-quote"
+<noun>   ::= <noun_simple> | <noun_complex>
+<noun_simple> ::= <type> | <type> "with a" <attribute> | <location> | <location> "connected with" <connection>
+<noun_complex> ::= <noun_simple> "of" <noun_simple>
+<type>   ::= "path" | "room" | "hallway" | "staircase" | "door" | "key" | "monster"
+<attribute> ::= "length" | "width" | "height" | "color" | "texture" | "material"
+<location> ::= "entrance" | "exit" | "center" | "corner" | "top" | "bottom" | "left" | "right"
+<connection> ::= "pathway" | "doorway" | "staircase" | "passage" | "tunnel"
+```
+This grammar includes rules for generating prompts using a variety of different verbs and nouns, as well as options for specifying attributes and locations. It can be used to generate prompts for creating a wide range of different elements within the dungeon, from individual rooms and pathways to more complex structures like staircases and doors.
+
+For example, using this grammar, you could generate a prompt like "Imagine creating descriptions for an artist to design a comic book panel of a long, narrow hallway with a wooden door at the end, leading from the entrance to a room with red walls and a high ceiling." This prompt provides detailed instructions for creating a specific element of the dungeon, using a variety of different nouns and verbs to convey the desired outcome.
+
+Overall, this grammar provides a flexible and extensible way to generate prompts for creating a wide range of different elements within a dungeon, making it easy to customize and adapt the prompt-generation process to suit your specific needs and goals.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_111.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_111.txt
new file mode 100644
index 0000000..479f3f3
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_111.txt
@@ -0,0 +1,159 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+dungeon_prompt = "Imagine", place, "connected with", place, "as the entrance to a dungeon. Now describe:", type_name, "at this location, where players can", verb, "and continue deeper into the dungeon." ;
+type_name = "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult";
+verb = "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyze" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote";
+place = "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "plato's cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe";
+```
+This grammar defines a `dungeon_prompt` non-terminal symbol, which can be used to generate prompts for creating different types of elements in a dungeon. The `type_name`, `verb`, and `place` non-terminal symbols are used to specify the type of element being created, the action that players can perform on it, and the location where it is found, respectively.
+
+Here's an example of how this grammar could be used to generate a prompt for creating a "treasure" at the entrance to the dungeon:
+```python
+Imagine "the entrance to the dungeon" connected with "a maze-like hallway" as the entrance to a dungeon. Now describe "treasure" at this location, where players can "find and collect" and continue deeper into the dungeon.
+```
+This prompt instructs the user to imagine the entrance to the dungeon as a specific place connected with another specific place, and then to describe a treasure that is located there, with the possibility for players to find and collect it. By varying the type of element, the action, and the location, this grammar can be used to generate a wide variety of prompts for creating different parts of a dungeon.
+
+Please note that this EBNF notation is just an example and not a standard, there are some variations in the notation between authors.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_112.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_112.txt
new file mode 100644
index 0000000..8acad9a
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_112.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon> ::= <path>+
+
+<path> ::= <room> <direction> <path> | <room>
+
+<room> ::= <description> <exit>*
+
+<description> ::= "You are in a " <place> " and you see " <items> "."
+
+<items> ::= <item> | <item> "," <items>
+
+<item> ::= <type_name> "<name>" | <verb> "a " <type_name> "<name>"
+
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult reveal" | "hero journey"
+
+<exit> ::= "<direction>" to <place>
+
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+
+<name> ::= <alpha_numeric>+
+
+<alpha_numeric> ::= [a-zA-Z0-9]
+```
+This grammar defines a dungeon as one or more paths. A path is made up of a room and an optional direction to the next path. A room is described by a description, which includes a place, some items (type\_name and name), and exits (direction, to place). Items can be either a type\_name with a name, or a verb modifying a type\_name with a name.
+
+This grammar could be used in conjunction with the code you provided to generate prompts for creating a dungeon by parsing a string of text and generating prompts based on the parsed elements.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_113.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_113.txt
new file mode 100644
index 0000000..82ea148
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_113.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```css
+<dungeon> ::= <path> | <room> | <treasure> | <monster>
+
+<path> ::= "Starting at the entrance, " <direction> " and moving through " <number_of_rooms> " rooms, you will find yourself at the end of the dungeon. Describe this path, including any notable features or obstacles along the way."
+
+<direction> ::= "north" | "south" | "east" | "west"
+
+<number_of_rooms> ::= <digit> | <digit> <number_of_rooms>
+
+<room> ::= <description_verb> " the " <room_type> " room. Describe this room in detail, including any exits and notable features."
+
+<description_verb> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+
+<room_type> ::= "throne" | "library" | "laboratory" | "prison" | "treasury"
+
+<treasure> ::= <description_verb> " the " <treasure_type>. " Describe this treasure in detail, including its appearance and any special properties it may have."
+
+<treasure_type> ::= "gemstone" | "golden chalice" | "ancient tome" | "magic sword"
+
+<monster> ::= <description_verb> " the " <monster_type>. " Describe this monster in detail, including its appearance and any special abilities it may have."
+
+<monster_type> ::= "dragon" | "goblin" | "orc" | "troll" | "lich"
+```
+This grammar generates prompts for creating a dungeon by starting with a path through the dungeon and then adding rooms, treasures, and monsters. Each prompt is generated by using one of the specified verbs (e.g. "Imagine", "Consider") and including the necessary context (e.g. type name, place) in the prompt string.
+
+You can use this grammar to generate a large number of prompts for creating your dungeon. For example, using the `make_args` function from the code you provided, you could generate prompts like this:
+```css
+dune exec ./bin/simple.exe --openai -m mixtral -s dungeon1Imagine the entrance room connected with a path north 2 -u https://dev-hub.agentartificial.com "Starting at the entrance, moving north and through two rooms, you will find yourself at the end of the dungeon. Describe this path, including any notable features or obstacles along the way."
+
+dune exec ./bin/simple.exe --openai -m mixtral -s dungeon2Consider the throne room connected with a library. Describe this room in detail, including any exits and notable features. -u https://dev-hub.agentartificial.com "Imagine the throne room connected with a library. Describe this room in detail, including any exits and notable features."
+```
+You can use the grammar to generate as many prompts as you need, by creating different paths through the dungeon, adding rooms, treasures and monsters. The `make_args` function will help you to create the command line arguments for your program.
+
+Please note that this is just an example and you might want to adjust it according to your needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_114.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_114.txt
new file mode 100644
index 0000000..b3ef8ad
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_114.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+<prompt> ::= "Imagine" <type\_name> "with a" <term2> "in" <place1> "connected with" <place2>
+
+<type\_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<term2> ::= <type\_name> | "random"
+
+<place1> ::= <place> | "entrance"
+
+<place2> ::= <place> | "exit"
+
+<place> ::= "country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout"
+
+This grammar can generate prompts for creating various types of elements in the dungeon, such as weapons or monsters, and place them in specific locations within the dungeon. The <type\_name> non-terminal symbol allows for a variety of different types to be generated, while the <term2> non-terminal symbol allows for the option of specifying a random type. The <place1> and <place2> non-terminal symbols allow for specifying the location of the element within the dungeon, with the entrance and exit being special cases. Finally, the <place> non-terminal symbol allows for a variety of different locations to be generated.
+
+Here is an example of how this grammar could be used to generate a prompt:
+
+Imagine weapon with a treasure in dungeon connected with exit
+
+This prompt would instruct the language model to generate a description of a weapon that is located in a dungeon and connected to the exit, with the type of weapon being a treasure.
+
+It's worth noting that this grammar is just an example and can be modified or extended as needed to suit the specific requirements of the dungeon generator.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_115.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_115.txt
new file mode 100644
index 0000000..4d25f5b
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_115.txt
@@ -0,0 +1,195 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an EBNF grammar for generating prompts for creating a dungeon:
+```ruby
+<prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+<verb> ::= <verb_simple> | <verb_complex>
+<verb_simple> ::= "creating" | "designing" | "writing" | "building"
+<verb_complex> ::= "creating a description for an artist to design a comic book panel of"
+                  | "analyzing" | "lifting" | "shifting" | "splice" | "quoting"
+                  | "quasi-quoting" | "quasi-quine-quoting"
+                  | "quasi-quine-quoting-in-ocaml"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+                  | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-act"
+                  | "meta-quoting"
+<type_name> ::= <simple_type_name> | <complex_type_name>
+<simple_type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+                     | "monster" | "quest" | "challenge" | "theme" | "drama"
+                     | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey"
+<complex_type_name> ::= <simple_type_name> "with a" <additional_feature>
+<additional_feature> ::= <additional_feature_simple> | <additional_feature_complex>
+<additional_feature_simple> ::= "small" | "large" | "red" | "blue" | "green"
+                                | "powerful" | "weak" | "rare" | "common"
+<additional_feature_complex> ::= <noun_simple> | <noun_complex>
+<noun_simple> ::= "sword" | "staff" | "ring" | "gem" | "beast" | "dragon" | "riddle"
+                  | "palace" | "temple" | "maze" | "forest" | "mountain" | "river"
+<noun_complex> ::= <simple_noun> "of" <location>
+<location> ::= <location_simple> | <location_complex>
+<location_simple> ::= "the entrance" | "the middle" | "the end"
+                     | "the beginning" | "the exit" | "the summit" | "the depths"
+<location_complex> ::= <preposition> <location>
+<preposition> ::= "at" | "in" | "on" | "over" | "under" | "near" | "far from"
+                  | "next to" | "surrounded by" | "connected with"
+<place> ::= <simple_place> | <complex_place>
+<simple_place> ::= "the entrance" | "the middle" | "the end"
+                   | "the beginning" | "the exit" | "the summit" | "the depths"
+<complex_place> ::= <preposition> <place> | <preposition> <location>
+<verb_object> ::= <simple_type_name> | <complex_type_name>
+<preposition> ::= "at" | "in" | "on" | "over" | "under" | "near" | "far from"
+                  | "next to" | "surrounded by" | "connected with"
+```
+This grammar can be used to generate prompts for creating different elements of the dungeon, such as weapons, spells, artifacts, monsters, quests, and challenges. The `<verb>` non-terminal allows for a variety of actions to be performed on the `<type_name>`, while the `<place>` non-terminal specifies where in the dungeon the element is located.
+
+Here are some examples of prompts that can be generated using this grammar:
+
+* "Imagine creating a weapon with a sharp blade and a powerful enchantment at the entrance of the dungeon."
+* "Consider designing a monster with eight legs and a venomous bite in the middle of the maze."
+* "Draw a treasure chest overflowing with gold coins and precious gems connected with the exit of the dungeon."
+* "Paint a riddle that reveals the location of the hidden passageway at the summit of the mountain."
+* "Compose a challenge that requires the player to solve a complex puzzle in order to progress through the depths of the dungeon."
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_116.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_116.txt
new file mode 100644
index 0000000..60542ad
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_116.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```
+<path> ::= <room> | <path> <connector> <room>
+<room> ::= "the" <room-name>
+<room-name> ::= <type-name> | <type-name> "with a" <attribute>
+<type-name> ::= "dungeon" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout" | "cave" | "swamp" | "labyrinth"
+<attribute> ::= <simple-term> | <attribute> "and" <attribute>
+<simple-term> ::= "dark" | "lit" | "treacherous" | "twisting" | "spiral" | "deadly" | "secret"
+<connector> ::= "connected to" | "leading to" | "adjacent to" | "opening onto" | "hiding behind"
+```
+This grammar allows for the generation of prompts that describe a path through a dungeon, starting at the entrance and ending at the final room. Each room on the path is described by its type (e.g. "dungeon", "room", "hallway") and any attributes it may have (e.g. "dark", "lit"). The rooms are connected to each other using a connector keyword, such as "connected to" or "leading to".
+
+For example, a path through the dungeon might be generated as follows:
+```
+<path>
+  -> <room>
+  -> <connector>
+  -> <room>
+  -> <connector>
+  -> ...
+  -> <room>
+```
+This would result in a series of rooms, each with its own type and attributes, connected to each other by connectors. The final room on the path would be the goal or objective of the dungeon crawl.
+
+To generate different variations of the path, you can use different combinations of types, attributes, and connectors, as well as adding more rooms to the path. This allows for a great deal of flexibility in generating prompts that can be used to create a diverse range of dungeons.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_117.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_117.txt
new file mode 100644
index 0000000..67e5cf6
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_117.txt
@@ -0,0 +1,158 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+
+<prompt> ::= "Imagine" <verb\_phrase> <type\_name> <place>"
+
+<verb\_phrase> ::= "consider" <verb> | "draw" | "paint" | "compose" | "balance"
+
+<verb> ::= "role-playing" | "specifying" | "encoding" | "coding" | "programming" | "proving" | "creating" | "designing" | "analyzing" | "lifting" | "shifting" | "splicing" | "quoting" | "quasi-quoting" | "meta-quoting"
+
+<type\_name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "Plato's cave" | "Garden of Eden" | "the river Styx" | "the restaurant at the end of the universe"
+
+An example prompt generated from this grammar would be: "Imagine considering a weapon with a magic spell in the entrance connected with the hallway."
+
+This grammar can be used to generate prompts for creating different elements of the dungeon, starting from the entrance and going all the way to the end. The verbs, type names, and places can be varied as needed to create prompts for specific elements of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_118.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_118.txt
new file mode 100644
index 0000000..aba41eb
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_118.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```
+<prompt> ::= "Imagine" <path>
+
+<path> ::= <path_segment>* <exit>
+
+<path_segment> ::= <verb> <type_name> <place>
+
+<exit> ::= "to the exit" | "to the boss room"
+
+<verb> ::= "walk through" | "fight your way through"
+
+<type_name> ::= "a corridor" | "a room" | "a puzzle"
+
+<place> ::= "the dungeon" | "the next level" | "the final boss room"
+```
+This grammar defines a prompt as a path through the dungeon, which is made up of one or more path segments. Each path segment consists of a verb, a type name, and a place. The path ends at an exit, which can be either the exit of the dungeon or the boss room. The verbs, type names, and places are defined as non-terminals with specific values.
+
+Here is an example of how this grammar could be used to generate a prompt:
+```
+Imagine walk through a corridor the dungeon to the exit
+```
+This prompt asks the user to imagine walking through a corridor in the dungeon, leading to the exit. The grammar allows for more complex prompts to be generated as well, such as one that includes multiple path segments and an exit to the boss room:
+```
+Imagine fight your way through a puzzle the next level to the boss room
+```
+This prompt asks the user to imagine fighting their way through a puzzle on the next level of the dungeon, leading to the boss room. The grammar can be used to generate many different prompts for creating a dungeon, allowing for a wide variety of scenarios and challenges to be imagined.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_119.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_119.txt
new file mode 100644
index 0000000..8859b06
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_119.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a path through a dungeon:
+```css
+prompt -> "Imagine" "a path from the entrance" "to the end" 
+           {type_term}
+           [{verb} {place}]
+
+type_term -> "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+verb -> "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | 
+          "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | 
+          "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | 
+          "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | 
+          "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | 
+          "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | 
+          "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | 
+          "meta-quote"
+
+place -> "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | 
+         "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+```
+In this grammar, a prompt is composed of an "Imagine" statement followed by "a path from the entrance to the end" and one or more type\_terms. The type\_term can be optionally followed by a verb and a place. This allows for a wide variety of prompts to be generated, such as:
+
+* Imagine a path from the entrance to the end, with weapons and monsters role-played along the way in a dungeon connected with a labyrinth.
+* Specify a path from the entrance to the end, with artifacts and music programmed in a building connected with a street.
+* Design a path from the entrance to the end, with magic items and drama coded in a vault connected with a keep.
+
+This grammar can be further expanded or modified as needed to generate prompts for other parts of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_120.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_120.txt
new file mode 100644
index 0000000..2958f3b
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_120.txt
@@ -0,0 +1,185 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= path\_segment | empty
+
+path\_segment ::= "move" direction "through" room\_description
+
+direction ::= "north" | "south" | "east" | "west"
+
+room\_description ::= adjective noun
+
+adjective ::= "dark" | "damp" | "musty" | "cramped"
+
+noun ::= "corridor" | "chamber" | "passageway" | "cave"
+
+empty ::= ε
+
+This grammar can be used to generate prompts such as:
+
+* "move north through dark corridor"
+* "move east through damp chamber"
+* "move south through musty passageway"
+* "move west through cramped cave"
+
+You could also extend the grammar to include other elements like monsters, treasures, or puzzles in the rooms. This way you can generate prompts for creating a more interesting and dynamic dungeon path.
+
+For example:
+```css
+path_segment ::= "move" direction "through" room_description "and encounter" monster | "move" direction "through" room_description "and find" treasure
+direction ::= "north" | "south" | "east" | "west"
+room_description ::= adjective noun
+adjective ::= "dark" | "damp" | "musty" | "cramped"
+noun ::= "corridor" | "chamber" | "passageway" | "cave"
+monster ::= "goblin" | "troll" | "skeleton" | "dragon"
+treasure ::= "gold" | "jewels" | "magic sword" | "ancient map"
+empty ::= ε
+```
+This way you can generate prompts such as:
+
+* "move north through dark corridor and encounter goblin"
+* "move east through damp chamber and find gold"
+* "move south through musty passageway and encounter troll"
+* "move west through cramped cave and find magic sword"
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_121.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_121.txt
new file mode 100644
index 0000000..a992dca
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_121.txt
@@ -0,0 +1,219 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= "Imagine" "a" dungeon\_path
+
+dungeon\_path ::= dungeon\_segment*
+
+dungeon\_segment ::= room | corridor | chamber
+
+room ::= "room" ["with a"] type\_name ["connected to" place]
+
+corridor ::= "corridor" ["leading from" place "to" place]
+
+chamber ::= "challenge" challenge\_type
+
+type\_name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+challenge\_type ::= "trap" | "puzzle" | "riddle" | "boss fight"
+
+place ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+
+This grammar generates a dungeon by specifying a series of connected segments, such as rooms, corridors, and challenges. Each segment can have an optional type name and place associated with it. The challenge type is used to specify different types of obstacles that the player must overcome in order to progress through the dungeon.
+
+The grammar uses the following non-terminals:
+
+* `dungeon`: represents the overall structure of the dungeon.
+* `dungeon_path`: represents a sequence of connected segments that make up the dungeon.
+* `dungeon_segment`: represents a single segment in the dungeon, which can be a room, corridor, or challenge.
+* `room`: represents a room in the dungeon.
+* `corridor`: represents a corridor connecting two places in the dungeon.
+* `chamber`: represents a challenge that the player must overcome in order to progress through the dungeon.
+* `type_name`: represents a type of object that can be found in the dungeon, such as a weapon or spell.
+* `challenge_type`: represents a type of challenge that the player must overcome in order to progress through the dungeon, such as a trap or boss fight.
+* `place`: represents a location in the dungeon where a segment can be found, such as a room or hallway.
+
+The grammar uses the following terminals:
+
+* `Imagine`: a command that instructs the user to imagine something.
+* `a`: an article used to introduce the dungeon path.
+* `with a`: a phrase used to specify a type name for a room.
+* `connected to`: a phrase used to specify a place connected to a room.
+* `leading from`: a phrase used to specify the starting place of a corridor.
+* `to`: a preposition used to specify the ending place of a corridor.
+* `trap`: a type of challenge that the player must overcome in order to progress through the dungeon.
+* `puzzle`: a type of challenge that the player must overcome in order to progress through the dungeon.
+* `riddle`: a type of challenge that the player must overcome in order to progress through the dungeon.
+* `boss fight`: a type of challenge that the player must overcome in order to progress through the dungeon.
+* `the country`: a place in the dungeon.
+* `the region`: a place in the dungeon.
+* `the city`: a place in the dungeon.
+* `the street`: a place in the dungeon.
+* `the house`: a place in the dungeon.
+* `the building`: a place in the dungeon.
+* `the dungeon`: a place in the dungeon.
+* `the labyrinth`: a place in the dungeon.
+* `the cave`: a place in the dungeon.
+* `the swamp`: a place in the dungeon.
+* `the room`: a place in the dungeon.
+* `the hallway`: a place in the dungeon.
+* `the chest`: a place in the dungeon.
+* `the bag`: a place in the dungeon.
+* `the wallet`: a place in the dungeon.
+* `the vault`: a place in the dungeon.
+* `the keep`: a place in the dungeon.
+* `the hideout`: a place in the dungeon.
+* `platos cave`: a place in the dungeon.
+* `garden of eden`: a place in the dungeon.
+* `the river styx`: a place in the dungeon.
+* `the restaurant at the end of the universe`: a place in the dungeon.
+
+This grammar can be used to generate a variety of different dungeons by specifying different combinations of segments, types, and places. For example, the following prompt could be generated by this grammar:
+
+Imagine a room with a weapon connected to the country leading from platos cave to the garden of eden.
+
+This prompt instructs the user to imagine a room in the dungeon that contains a weapon and is connected to two places: platos cave and the garden of eden. The room is reached by following a corridor that starts at platos cave and ends at the garden of eden. This prompt could be used as input to a system that generates dungeons based on user prompts.
+
+I hope this helps! Let me know if you have any other questions.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_122.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_122.txt
new file mode 100644
index 0000000..a3767d1
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_122.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+dungeon-prompt ::= "Imagine", place, path
+
+place ::= "the entrance" | "a room" | "a hallway" | "a treasure chest"
+
+path ::= path-segment*
+
+path-segment ::= place, verb, place | action
+
+verb ::= "connected to" | "leading to"
+
+action ::= "a monster guarding the way" | "a puzzle to solve"
+```
+This grammar defines a `dungeon-prompt` which is composed of an initial `place`, followed by one or more `path-segment`s. Each `path-segment` can be either two connected `place`s via a `verb`, or a standalone `action`. The `place` and `verb` non-terminals are defined in terms of specific options, while the `action` non-terminal is left open-ended to allow for flexibility in creating prompts.
+
+You can use this grammar to generate prompts such as:
+
+* Imagine the entrance leading to a room with a monster guarding the way.
+* Imagine a room connected to a treasure chest leading to a puzzle to solve.
+* Imagine the entrance connected to a room with a monster guarding the way, and that room leading to another room with a puzzle to solve.
+
+This is just one possible grammar for generating dungeon prompts. You can modify or expand it as needed to suit your specific use case.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_123.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_123.txt
new file mode 100644
index 0000000..cf8d831
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_123.txt
@@ -0,0 +1,198 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```less
+<prompt> ::= "Imagine" "a" <type_name> "<verb>" <place1>
+             | "Consider" "a" <type_name> "<verb>" <place1>
+             | "Draw" "a" <type_name> "<verb>" <place1>
+             | "Paint" "a" <type_name> "<verb>" <place1>
+             | "Compose" "a" <type_name> "<verb>" <place1>
+             | "Balance" "a" <type_name> "<verb>" <place1>
+
+<type_name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure"
+              | "monster" | "quest" | "challenge" | "theme" | "drama"
+              | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<verb> ::= <verb_list1> | <verb_list2> | <verb_list3>
+
+<verb_list1> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove"
+
+<verb_list2> ::= "create" | "design" | "create descriptions for an artist"
+                | "create descriptions for an artist to design a comic book panel"
+                | "analyse" | "lift" | "shift" | "splice" | "quote"
+                | "quasi-quote" | "quasi-quine-quote"
+                | "quasi-quine-quote-in-ocaml"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+                | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-connect"
+                | "meta-program" | "generate"
+
+<verb_list3> ::= <verb_path1> | <verb_path2>
+
+<verb_path1> ::= "move through" | "traverse" | "navigate" | "explore"
+
+<verb_path2> ::= "find your way to" | "reach" | "get to"
+
+<place1> ::= <place_list1> | <place_list2> | <place_list3>
+
+<place_list1> ::= "the entrance of the dungeon" | "the starting room"
+                | "the first chamber"
+
+<place_list2> ::= "a mysterious hallway" | "a narrow passageway"
+                 | "a winding staircase" | "an underground tunnel"
+
+<place_list3> ::= <place_path1> | <place_path2>
+
+<place_path1> ::= "the next room" | "the next chamber"
+                 | "the next level"
+
+<place_path2> ::= "the end of the dungeon" | "the final boss" | "the treasure room"
+```
+This grammar allows for generating prompts that can be used to create a variety of different elements in the dungeon, including weapons, spells, artifacts, magic items, treasure, monsters, quests, challenges, themes, drama, music, art, secrets, occult, and reveal. The verb section of the prompt allows for various actions to be taken on these elements, such as role-playing, specifying, encoding, programming, proving, creating, designing, analyzing, lifting, shifting, splicing, quoting, traversing, finding your way to, reaching, getting to, moving through, and navigating. The place section of the prompt allows for generating prompts that can be used to create a variety of different locations in the dungeon, including the entrance, a mysterious hallway, a narrow passageway, a winding staircase, an underground tunnel, the next room, the next chamber, the next level, the end of the dungeon, the final boss, and the treasure room.
+
+It's important to note that this is just one example of how you could structure your grammar, and it may need to be adjusted based on the specific requirements of your project. But I hope this gives you a good starting point for generating prompts for creating your dungeon using your knowledge!
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_124.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_124.txt
new file mode 100644
index 0000000..3ed0972
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_124.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= path\_segment | ε
+
+path\_segment ::= "From" place\_name "to" place\_name "with" type\_name
+
+place\_name ::= any valid name of a place in the dungeon (e.g. "entrance", "treasure room")
+
+type\_name ::= any valid name of a type of terrain or obstacle in the dungeon (e.g. "river", "maze")
+
+ε ::= the empty string, representing an empty path segment (i.e. no movement)
+
+This grammar defines a path as a sequence of path segments, where each path segment is a movement from one place to another through a particular type of terrain or obstacle. The grammar also allows for an empty path, represented by the empty string. This can be useful in cases where there are multiple valid paths between two places in the dungeon, and you want to generate prompts for each possible path.
+
+Here is an example of how this grammar could be used to generate a prompt for creating a path through a dungeon:
+
+* "From entrance to treasure room with river"
+* "From treasure room to boss room with maze"
+* "From boss room to exit with empty"
+
+Note that in the last example, the type\_name is "empty", which represents an empty path segment (i.e. no movement). This can be useful in cases where you want to generate prompts for multiple paths between two places in the dungeon, and some of those paths may involve moving through no terrain or obstacles at all.
+
+Overall, this grammar provides a flexible way to generate prompts for creating a path through a dungeon, and can be easily extended to include additional elements (e.g. monsters, traps, treasure) as needed.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_125.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_125.txt
new file mode 100644
index 0000000..0c2d468
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_125.txt
@@ -0,0 +1,179 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+dungeon-path ::= (room | hallway | chamber)*, treasure-chamber, (room | hallway | chamber)*
+
+room ::= "the" "room" ["with a" <type-name>]
+       | "the" place
+
+hallway ::= "the" "hallway" ["connected to the" place]
+           | "the" path
+
+chamber ::= "the" "chamber" ["containing" <type-name>]
+          | "the" area
+
+treasure-chamber ::= "the treasure chamber"
+                   | "the final chamber"
+
+path ::= <direction-word> ("room" | "hallway")+
+
+<type-name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+               | "monster" | "quest" | "challenge" | "theme" | "drama"
+               | "music" | "art" | "secret" | "occult" | "reveal"
+               | "hero journey"
+
+<direction-word> ::= "north" | "south" | "east" | "west"
+                   | "up" | "down"
+
+place ::= "entrance" | <location>
+
+<location> ::= "city" | "region" | "country" | "building" | "dungeon"
+              | "keep" | "hideout" | "vault" | "chest" | "bag"
+              | "wallet" | "garden of eden" | "river styx"
+              | "restaurant at the end of the universe" | "platos cave"
+```
+This grammar defines a structure for generating prompts that describe a path through a dungeon, starting at the entrance and ending at the treasure chamber. The grammar includes elements such as rooms, hallways, chambers, and treasures which can be further specified using type names. The grammar also includes direction words to specify movement through the dungeon and location words to describe different areas within the dungeon.
+
+You could use this grammar to generate prompts by randomly selecting elements from each category and concatenating them together according to the structure defined in the grammar. This would allow you to generate a wide variety of prompts for creating dungeons with different layouts, challenges, and treasures.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_126.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_126.txt
new file mode 100644
index 0000000..c321748
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_126.txt
@@ -0,0 +1,181 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon-prompt> ::= "Imagine a path through a dungeon from the entrance to the end, with:"
+                     <type-name> "s:" <type-list>
+                     <place-name> "s:" <place-list>
+                     <verb-name> "s:" <verb-list>
+
+<type-name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+                | "monster" | "quest" | "challenge" | "theme" | "drama"
+                | "music" | "art" | "secrets" | "occult" | "reveal"
+
+<type-list> ::= <type-name> { "," <type-name> }
+
+<place-name> ::= "country" | "region" | "city" | "street" | "house"
+                 | "building" | "dungeon" | "labyrinth" | "cave"
+                 | "swamp" | "room" | "hallway" | "chest" | "bag"
+                 | "wallet" | "vault" | "keep" | "hideout"
+                 | "Plato's cave" | "Garden of Eden" | "River Styx"
+                 | "Restaurant at the end of the universe"
+
+<place-list> ::= <place-name> { "," <place-name> }
+
+<verb-name> ::= "role-play" | "specify" | "encode" | "code" | "program"
+                 | "prove" | "create" | "design" | "analyze" | "lift"
+                 | "shift" | "splice" | "quote" | "quasi-quote"
+                 | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml"
+                 | "quasi-quine-quote-in-ocaml-coq-metacoq"
+                 | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+                 | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+                 | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+                 | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-analyze"
+                 | "meta-program"
+
+<verb-list> ::= <verb-name> { "," <verb-name> }
+```
+This grammar defines a `dungeon-prompt`, which is made up of a list of `type-names`, `place-names`, and `verb-names`. Each type, place, or verb name can be followed by a comma-separated list of additional names. The `<type-name>` nonterminal includes all the possible types that could be included in the dungeon, while the `<place-name>` nonterminal includes all the different locations that could be included. Finally, the `<verb-name>` nonterminal includes a variety of different actions that could be performed as part of creating the dungeon.
+
+This grammar is just one example and can be adjusted to suit specific use cases. Additionally, it can be used to generate prompts for other parts of the dungeon such as treasure rooms, monster dens, etc.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_127.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_127.txt
new file mode 100644
index 0000000..d5caca9
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_127.txt
@@ -0,0 +1,181 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a path through a dungeon:
+
+Path ::= PathElement*
+
+PathElement ::= "Enter" Room | "Exit" Room | "Move" Direction
+
+Room ::= Place
+
+Direction ::= "North" | "South" | "East" | "West"
+
+Place ::= "the country" | "the region" | "the city" | "the street" |
+"the house" | "the building" | "the dungeon" | "the labyrinth" |
+"the cave" | "the swamp" | "the room" | "the hallway" | "the chest" |
+"the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" |
+"platos cave" | "garden of eden" | "the river styx" |
+"the restaurant at the end of the universe"
+
+Verb ::= "role-play" | "specify" | "encode" | "code" | "program" |
+"prove" | "create" | "design" | "create descriptions for an artist" |
+"create descriptions for an artist to design a comic book panel" |
+"analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" |
+"quasi-quine-quote" | "quasi-quine-quote-in-ocaml" |
+"quasi-quine-quote-in-ocaml-coq-metacoq" |
+"quasi-quine-quote-in-ocaml-coq-metacoq-introspector" |
+"quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" |
+"quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" |
+"quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" |
+"quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" |
+"quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" |
+"meta-quote"
+
+TypeName ::= "weapon" | "spell" | "artifacts" | "magic items" |
+"treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" |
+"path" | "room"
+
+This grammar defines a path as a sequence of path elements. Each path element can be an action that takes place in a room, such as entering or exiting a room, or moving in a direction. Rooms are defined by places, and paths can connect multiple rooms together. The verb, type name, and place can all be combined in various ways to create different types of prompts for creating the dungeon.
+
+This is just one example of how you could create a grammar for generating prompts for creating a dungeon. You may want to adjust or expand upon this grammar depending on your specific needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_128.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_128.txt
new file mode 100644
index 0000000..6426918
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_128.txt
@@ -0,0 +1,177 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```ruby
+dungeon-prompt ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+                   PLACE START_CONNECTOR TYPE END_CONNECTOR PLACE
+
+PLACE ::= "the country" | "the region" | "the city" | "the street" | "the house"
+        | "the building" | "the dungeon" | "the labyrinth" | "the cave"
+        | "the swamp" | "the room" | "the hallway" | "the chest"
+        | "the bag" | "the wallet" | "the vault" | "the keep"
+        | "the hideout" | "platos cave" | "garden of eden"
+        | "the river styx" | "the restaurant at the end of the universe"
+
+START_CONNECTOR ::= "entering from" | "coming from" | "approaching from"
+                    | "arriving from" | "exiting from" | "leaving from"
+
+TYPE ::= "a" WORD TYPE_SPECIFIC
+
+WORD ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure"
+        | "monster" | "quest" | "challenge" | "theme" | "drama"
+        | "music" | "art" | "secrets" | "occult" | "reveal"
+        | "hero journey"
+
+TYPE_SPECIFIC ::= "encounter" | "guardian" | "challenge" | "puzzle"
+                  | "riddle" | "treasure" | "gateway"
+
+END_CONNECTOR ::= "leading to" | "opening to" | "connecting with"
+                 | "revealing" | "unlocking" | "guarded by"
+```
+This grammar can be used to generate prompts for creating different elements of a dungeon, such as weapons, spells, monsters, and treasures. The `dungeon-prompt` nonterminal specifies the starting word of the prompt, while the `PLACE`, `START_CONNECTOR`, `TYPE`, `WORD`, `TYPE_SPECIFIC`, and `END_CONNECTOR` nonterminals specify different elements that can be combined to create a prompt.
+
+Here is an example of a prompt that could be generated using this grammar:
+```vbnet
+Imagine entering from the city leading to a weapon encounter guarded by a monster in the dungeon.
+```
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_129.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_129.txt
new file mode 100644
index 0000000..cbd8999
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_129.txt
@@ -0,0 +1,194 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```less
+<dungeon> ::= <path>+
+
+<path> ::= <room> <direction> <room> | <entrance> <direction> <room> | <room> <direction> <exit>
+
+<room> ::= <description> <contents>
+
+<description> ::= "You are in a" <place>"."
+
+<contents> ::= <monsters> <treasure> <artifacts>
+
+<monsters> ::= ( "<monster1>" | "<monster2>" | ... )?
+
+<treasure> ::= ( "<treasure1>" | "<treasure2>" | ... )?
+
+<artifacts> ::= ( "<artifact1>" | "<artifact2>" | ... )?
+
+<monsterN> ::= "There is a" <monster_description>"."
+
+<treasureN> ::= "You see a" <treasure_description>"."
+
+<artifactN> ::= "You notice a" <artifact_description>"."
+
+<entrance> ::= "You enter the dungeon through the" <entrance_description>"."
+
+<exit> ::= "The way out is to the" <exit_direction>"."
+
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+
+<place> ::= "country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+
+<monster_description> ::= "<monster_name1>" | "<monster_name2>" | ...
+
+<treasure_description> ::= "<treasure_name1>" | "<treasure_name2>" | ...
+
+<artifact_description> ::= "<artifact_name1>" | "<artifact_name2>" | ...
+
+<monster_nameN> ::= "goblin" | "orc" | "troll" | "dragon" | "skeleton" | "zombie" | "ghost" | "witch" | "warlock" | "demon"
+
+<treasure_nameN> ::= "gold" | "silver" | "bronze" | "gemstone" | "coin" | "jewel" | "artifact"
+
+<artifact_nameN> ::= "sword" | "shield" | "armor" | "scroll" | "potion" | "key" | "map"
+
+<entrance_description> ::= "entrance" | "gate" | "portal" | "door" | "hole" | "passage"
+
+<exit_direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+```
+This grammar allows for the generation of a dungeon as a series of connected rooms, with each room containing monsters, treasure, and artifacts. The entrance to the dungeon is also defined, along with the direction in which the exit can be found. Additionally, the grammar includes definitions for the different types of monsters, treasure, and artifacts that may be encountered within the dungeon.
+
+It's worth noting that this is just an example of what a grammar for generating prompts for creating a dungeon might look like. The actual grammar used would depend on the specific requirements and constraints of the simulation or game in which it is being used.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_130.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_130.txt
new file mode 100644
index 0000000..5a1631c
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_130.txt
@@ -0,0 +1,204 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```css
+<prompt> ::= "Imagine" <verb_phrase> "<type_name>" "<place>"
+
+<verb_phrase> ::= "Consider" <verb> | "Draw" | "Paint" | "Compose" | "Balance"
+
+<verb> ::= "role-playing" | "specifying" | "encoding" | "programming" | "proving" | "creating" | "designing" | "analyzing" | "lifting" | "shifting" | "splice" | "quoting" | "quasi-quoting" | "quasi-quine-quoting" | "quasi-quine-quoting-in-ocaml" | "quasi-quine-quoting-in-ocaml-coq-metacoq" | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "meta-quoting"
+
+<type_name> ::= <term> | <term_with_artifact> | <magic_item> | <treasure> | <monster> | <quest> | <challenge> | <theme> | <drama> | <music> | <art> | <secrets> | <occult> | <reveal> | <hero_journey>
+
+<term> ::= "weapon" | "spell" | "magic items"
+
+<term_with_artifact> ::= <term> "with a" <artifact>
+
+<artifact> ::= <artifact_name> | <description>
+
+<artifact_name> ::= "sword" | "staff" | "shield" | "armor" | "ring" | "amulet" | "gem" | "scroll" | "book" | "map" | "chest" | "key" | "tool"
+
+<description> ::= <adjective_phrase> <artifact_name>
+
+<magic_item> ::= <item> with magical properties
+
+<item> ::= <object> | <creature>
+
+<object> ::= "statue" | "urn" | "vase" | "painting" | "tapestry" | "mosaic"
+
+<creature> ::= "golem" | "homunculus" | "familiar" | "construct"
+
+<treasure> ::= <valuable_item>
+
+<valuable_item> ::= "gold" | "silver" | "gemstone" | "jewel" | "coin"
+
+<monster> ::= <creature> with malevolent intentions
+
+<quest> ::= a task or mission to be completed
+
+<challenge> ::= a difficult obstacle to overcome
+
+<theme> ::= a recurring idea or element in the dungeon
+
+<drama> ::= a narrative or plot device used in the dungeon
+
+<music> ::= background music or ambient sound for the dungeon
+
+<art> ::= visual art or decorations present in the dungeon
+
+<secrets> ::= hidden rooms, passages, or items
+
+<occult> ::= supernatural or magical elements present in the dungeon
+
+<reveal> ::= an event or discovery that occurs during exploration
+
+<hero_journey> ::= a narrative arc or progression for the player character
+
+<place> ::= <location> | <region>
+
+<location> ::= "entrance" | "corridor" | "chamber" | "staircase" | "dead-end" | "secret passage" | "treasure room" | "boss room"
+
+<region> ::= <location> connected with another location or region
+```
+This grammar can be used to generate prompts for creating different elements of a dungeon, from weapons and magic items to monsters and quests. It can also be expanded or modified as needed to suit the specific needs of a project.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_131.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_131.txt
new file mode 100644
index 0000000..24801c6
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_131.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```makefile
+path = {room}* exit;
+
+room = room_type room_description;
+
+room_type = "normal" | "boss";
+
+room_description = "A dark and damp room with " {feature}+ ";"
+
+feature = "a hidden door on the north wall" | 
+          "a chest in the corner" | 
+          "a monster lurking in the shadows" ;
+
+exit = "You see a bright light at the end of the hallway. You have reached the exit.";
+```
+This grammar defines a `path` as a sequence of one or more `room`s, followed by an `exit`. A `room` is defined as a combination of a `room_type` and a `room_description`, where the `room_type` can be either "normal" or "boss". The `room_description` is a string that includes one or more `feature`s, such as a hidden door or a chest. Finally, the `exit` is defined as a string describing the end of the path.
+
+You could use this grammar to generate prompts for creating the rooms and features in your dungeon by parsing the grammar rules and inserting them into the prompt template you provided. For example, you might use the following prompt to create a "normal" room with a hidden door on the north wall:
+```vbnet
+"We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : create; Type Name: room; Place: a normal room connected with a hidden door on the north wall What is your response? Please generate a description for this room."
+```
+You could then repeat this process for each of the rules in the grammar, using different combinations of `room_type`, `feature`, and `exit` to create a diverse set of rooms and paths through your dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_132.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_132.txt
new file mode 100644
index 0000000..d3d40fb
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_132.txt
@@ -0,0 +1,160 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon-prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+<type-name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<path> ::= <dungeon-prompt> <type-name> with a <verb> doing <verb> in a <place> connected with <place> through the dungeon from the entrance to the end
+```
+This grammar can be used to generate prompts for creating different elements of the dungeon, such as weapons or monsters, by specifying the appropriate `<type-name>`. The `<verb>` and `<place>` elements can also be customized to fit the desired level of detail or type of prompt.
+
+For example, a prompt for creating a weapon in a dungeon could be: "Imagine a weapon with a program doing create in a vault connected with the entrance through the dungeon."
+
+A prompt for creating a monster in a region could be: "Consider a monster with a design doing draw in a region connected with the city through the country."
+
+You can also use this grammar to generate prompts that go all the way from the entrance to the end of the dungeon by using the `<path>` non-terminal.
+
+Please note that this is just an example, you could modify and add more elements to the grammar depending on your needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_133.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_133.txt
new file mode 100644
index 0000000..df59e88
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_133.txt
@@ -0,0 +1,173 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+<dungeon> ::= <path> | <room> | <monster> | <treasure>
+<path> ::= "From the entrance, you walk through a " <place> " and arrive at a " <place>. "What do you see?"
+<room> ::= "You enter a " <place> ". Describe what you see."
+<monster> ::= "A " <type_name> ", named " <name> ", attacks! What do you do?"
+<treasure> ::= "You find a " <type_name> ". What is it and what does it do?"
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+<place> ::= "dark hallway" | "dimly lit room" | "ancient door" | "hidden passage"
+<name> ::= "Grimfang" | "Shadowstrike" | "Frostbite"
+```
+This grammar allows for the generation of prompts that describe a path through the dungeon, individual rooms, monsters, and treasures. The `<place>` non-terminal can be expanded to include more specific locations within the dungeon. Similarly, the `<type_name>` non-terminal could be expanded to include additional types of items that might be found in a fantasy role-playing game.
+
+To generate a prompt using this grammar, you would start with the `<dungeon>` non-terminal and expand it according to the rules until you reach terminal symbols (i.e., strings surrounded by quotes). For example, here is one possible expansion of the `<dungeon>` non-terminal:
+```python
+<dungeon>
+-> <path>
+-> "From the entrance, you walk through a dark hallway and arrive at a dimly lit room. What do you see?"
+```
+This prompt describes a path from the entrance of the dungeon to a dimly lit room, and asks the player to describe what they see in that room.
+
+You could use this grammar to generate multiple prompts by randomly expanding different non-terminals. For example, here is another possible expansion of the `<dungeon>` non-terminal:
+```python
+<dungeon>
+-> <monster>
+-> "A weapon, named Grimfang, attacks! What do you do?"
+```
+This prompt describes an encounter with a weapon-wielding monster, and asks the player to describe their response.
+
+By combining different expansions of the non-terminals in this grammar, you can generate a wide variety of prompts that can be used to create a rich and immersive dungeon experience.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_134.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_134.txt
new file mode 100644
index 0000000..6009113
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_134.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= (path | room | object | NPC)*
+
+path ::= "starting at the entrance, proceed through" path\_element+ "and arrive at the end"
+
+path\_element ::= "a corridor leading to" room | "a door to" room | "a stairway to" level
+
+room ::= "a room named" room\_name
+
+room\_name ::= ID
+
+level ::= "the next level" | level\_name
+
+level\_name ::= ID
+
+object ::= "an object named" object\_name
+
+object\_name ::= ID
+
+NPC ::= "a non-player character named" NPC\_name
+
+NPC\_name ::= ID
+
+ID ::= [a-zA-Z\_][a-zA-Z0-9\_]*
+
+This grammar allows for the generation of prompts that can be used to create a dungeon by specifying a sequence of paths, rooms, objects, and non-player characters (NPCs). The `path` production describes how to proceed through the dungeon from the entrance to the end, using various path elements such as corridors, doors, and stairways. The `room`, `object`, and `NPC` productions allow for the inclusion of specific rooms, objects, and NPCs in the dungeon, while the `ID` production allows for the use of identifiers to name these elements.
+
+For example, a prompt generated using this grammar might look like:
+
+starting at the entrance, proceed through a corridor leading to a room named "the guardhouse" and arrive at the end; in the guardhouse, there is an object named "the keyring"; a non-player character named "the captain" guards the keyring.
+
+This prompt describes a path from the dungeon entrance to a room named "the guardhouse," where there is an object named "the keyring" that is guarded by a non-player character named "the captain."
+
+Note that this is just one example of how such a grammar could be defined, and it can be adjusted based on specific requirements or preferences.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_135.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_135.txt
new file mode 100644
index 0000000..b567b7e
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_135.txt
@@ -0,0 +1,167 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```makefile
+path ::= room (corridor room)* corridor? exit
+room ::= "You are in a " place "."
+       | "You enter a " place " with " feature " and see " features ."
+       | "You step into a " place " with " feature " containing " treasure ."
+corridor ::= "You follow the corridor and reach a " place "."
+exit ::= "You exit the dungeon through a " exit_description "."
+
+place ::= "small room" | "large room" | "dark room" | "lit room"
+       | "deserted room" | "crowded room"
+feature ::= "a chest" | "a pedestal" | "an altar" | "a fountain"
+treasure ::= "gold coins" | "magic potion" | "rare gem"
+exit_description ::= "doorway" | "staircase" | "secret passage"
+```
+This grammar defines a path as a series of rooms connected by corridors, ending with an exit. Each room can have different descriptions and features, such as a chest or pedestal containing treasure. The corridors connect the rooms and lead to the next room in the path. The exit is described using a specific exit\_description. This grammar can be used to generate prompts for creating the dungeon by expanding each non-terminal symbol into a prompt template, which can then be filled in with specific values.
+
+For example, a prompt for generating a room could be:
+```makefile
+"Generate a description of a {feature} containing {treasure} in a {place}."
+```
+This prompt can be generated by replacing the non-terminal symbols in the `room` production with specific values. The resulting prompt can then be used to generate text descriptions of rooms using a language model. By generating multiple prompts for each non-terminal symbol, we can create a large variety of descriptions and features for our dungeon.
+
+Overall, this EBNF grammar provides a flexible and extensible way to generate prompts for creating a dungeon with a language model. It allows us to specify the structure and content of the dungeon while also enabling us to easily modify or expand the grammar as needed.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_136.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_136.txt
new file mode 100644
index 0000000..44a13dc
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_136.txt
@@ -0,0 +1,175 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```ruby
+<dungeon> ::= <path>+
+
+<path> ::= <room> <direction> <path> | <room>
+
+<room> ::= "Enter" <description>
+
+<direction> ::= "go" <direction_name>
+
+<direction_name> ::= "north" | "south" | "east" | "west"
+
+<description> ::= <adjective> <noun>
+
+<adjective> ::= "dark" | "damp" | "musty" | "creaky"
+
+<noun> ::= "corridor" | "chamber" | "passageway" | "tunnel"
+```
+This grammar describes a dungeon as one or more paths, where each path consists of a room followed by an optional direction and another path. A room is described by an adjective and a noun. A direction consists of the word "go" followed by a direction name. The adjectives and nouns used to describe the rooms can be selected from the lists provided in the code.
+
+Here is an example of a prompt that could be generated using this grammar:
+```vbnet
+"We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : go; Type Name: corridor; Place: dark connected with creaky 
+What is your response? Please generate variant array of size 3"
+```
+This prompt asks the model to generate three variations of a description for a dark, creaky corridor that the player can go through. The model could respond with something like this:
+```vbnet
+1. "Enter a dark, creaky corridor. Go north into a damp, musty chamber."
+2. "Enter a dark, creaky corridor. Go south into a damp, musty passageway."
+3. "Enter a dark, creaky corridor. Go east into a damp, musty tunnel."
+```
+These descriptions could then be used to create the dungeon using the model's output as input for a text generator or other program. The grammar can be easily extended and modified to generate different types of prompts, such as those for creating treasure, monsters, quests, or other elements of a typical RPG setting.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_137.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_137.txt
new file mode 100644
index 0000000..b57ecd3
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_137.txt
@@ -0,0 +1,156 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```lua
+<prompt> ::= "Imagine a " <type_name> " in " <place> ", where " <verb> "<br>"Please generate variant array of size " <count >
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyze" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<place> ::= <location> | <container>
+<location> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest"
+<container> ::= "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "plato's cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<count> ::= 1 | 2 | 3 | 4 | 5
+```
+This grammar allows for generating prompts that specify a type of element (such as weapon or monster), a verb describing an action to take with that element, and a location or container for the element in the dungeon. The `<count>` nonterminal is used to generate prompts requesting a specific number of variants on the generated prompt.
+
+This grammar can be used to generate many different prompts for creating various elements of a dungeon, allowing for a great deal of customization and flexibility in the final product.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_138.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_138.txt
new file mode 100644
index 0000000..5f12be4
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_138.txt
@@ -0,0 +1,193 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```markdown
+<dungeon-prompt> ::= "Imagine" <path-description>
+
+<path-description> ::= 
+  <path-segment> { "-and->" <path-segment> }
+
+<path-segment> ::= 
+  ( "<from>" <place> "-to>" <place2> )
+  | ( "<from>" <place> ">" <room-description> )
+
+<room-description> ::= 
+  ( "<in>" <place> "<is>" <room-features> )
+  | ( "<in>" <place> "are" <room-features> )
+
+<room-features> ::= 
+  [ <monster-description> ]
+  [ <treasure-description> ]
+  [ <challenge-description> ]
+
+<monster-description> ::= 
+  ( "<there is>" <monster-name> )
+  | ( "A" <monster-name> "is" <monster-features> )
+
+<treasure-description> ::= 
+  ( "<there is a>" <treasure-name> )
+  | ( "<laying around>" <artifact-name> )
+
+<challenge-description> ::= 
+  ( "The room is" <challenge-type> )
+  | ( "There is a" <challenge-name> )
+
+<monster-name> ::= 
+  "goblin" | "troll" | "dragon" | ...
+
+<treasure-name> ::= 
+  "gold" | "gem" | "artifact" | ...
+
+<challenge-type> ::= 
+  "trap" | "puzzle" | "riddle" | ...
+
+<challenge-name> ::= 
+  "spike pit" | "locked door" | "hidden passage" | ...
+
+<place> ::= 
+  "entrance" | "corridor" | "room" | "treasure chamber" | ...
+```
+This grammar defines a `dungeon-prompt` which is made up of a series of connected `path-segment`s, each of which describes a connection between two places or a room with its features. A room can have monster(s), treasure(s) and challenges present in it. The grammar also includes some sample terms for the different elements but they can be extended as per your requirement.
+
+Note: This is just an example, you can modify and expand this grammar to fit your needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_139.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_139.txt
new file mode 100644
index 0000000..539841d
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_139.txt
@@ -0,0 +1,205 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```rust
+dungeon_prompt ::= "Imagine a path through a fantasy dungeon, starting at the entrance and ending at the treasure."
+                    [path_segment]
+                    [obstacle]
+                    [trap]
+                    [monster]
+                    [secret_door]
+                    [dungeon_feature]*
+                    "What does this path look like?"
+
+path_segment ::= ("heading" | "turning") ("left" | "right" | "straight")
+
+heading ::= "heading" ("north" | "south" | "east" | "west")
+
+turning ::= "turning" ("left" | "right")
+
+obstacle ::= "Imagine a large boulder blocking the path."
+           | "Imagine a deep chasm crossing the path."
+           | "Imagine a narrow bridge spanning a river on the path."
+
+trap ::= "Imagine a pitfall trap in the middle of the path."
+      | "Imagine a swinging blade trap at the entrance to a tunnel."
+      | "Imagine a falling rock trap at the top of a staircase."
+
+monster ::= "Imagine a fearsome dragon guarding the treasure."
+         | "Imagine a cunning goblin lurking in the shadows."
+         | "Imagine a ferocious troll blocking the path."
+
+secret_door ::= "Imagine a secret door hidden behind a tapestry."
+              | "Imagine a hidden passage leading off the main path."
+              | "Imagine a concealed staircase descending into darkness."
+
+dungeon_feature ::= "Imagine a grand throne room at the heart of the dungeon."
+                   | "Imagine a winding maze of corridors and chambers."
+                   | "Imagine a dark and ominous fortress looming overhead."
+```
+This grammar includes rules for generating prompts for different elements that might be encountered on a path through a dungeon, such as obstacles, traps, monsters, secret doors, and other features. It also includes rules for generating prompts for different types of path segments, such as headings and turns.
+
+To generate a prompt using this grammar, you would start with the `dungeon_prompt` rule and then apply the various rules for the different elements that you want to include in the prompt. For example, here is a prompt that includes a heading, a turn, an obstacle, and a trap:
+```less
+Imagine a path through a fantasy dungeon, starting at the entrance and ending at the treasure. Heading north, turning left, imagine a large boulder blocking the path. Imaging finding a way around it, you come across a pitfall trap in the middle of the path. What does this path look like?
+```
+You can customize the prompt further by adding or removing different elements from the grammar rule, as needed. For example, to add a monster to the prompt, you could include the `monster` rule in the list of optional elements:
+```rust
+dungeon_prompt ::= "Imagine a path through a fantasy dungeon, starting at the entrance and ending at the treasure."
+                    [path_segment]
+                    [obstacle]
+                    [trap]
+                    [monster]
+                    [secret_door]
+                    [dungeon_feature]*
+                    "What does this path look like?"
+
+monster ::= "Imagine a fearsome dragon guarding the treasure."
+         | "Imagine a cunning goblin lurking in the shadows."
+         | "Imagine a ferocious troll blocking the path."
+```
+This would generate prompts that include a monster, such as:
+```less
+Imagine a path through a fantasy dungeon, starting at the entrance and ending at the treasure. Heading north, turning left, imagine a fearsome dragon guarding the treasure. What does this path look like?
+```
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_14.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_14.txt
new file mode 100644
index 0000000..4761b49
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_14.txt
@@ -0,0 +1,181 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon = {room | corridor}*
+
+room = "You are in a room with exits leading to the " exit {exit} "."
+
+corridor = "You are in a corridor with exits leading to the " exit {exit} "."
+
+exit = "north" / "south" / "east" / "west"
+
+This grammar generates prompts for a series of rooms and corridors, where each room or corridor has exits leading to other rooms or corridors. The grammar allows for any number of rooms and corridors to be generated, as indicated by the {room | corridor}\* syntax. Each room or corridor prompt includes information about which exits are available.
+
+To use this grammar to generate prompts, you could expand it to include additional details about each room or corridor, such as its size, appearance, and any special features it may have. You could also add rules for generating other elements of the dungeon, such as monsters, treasures, and quests.
+
+For example, here is an expanded version of the grammar that includes rules for generating monsters and treasures in each room:
+
+dungeon = {room | corridor}*
+
+room = "You are in a room with exits leading to the " exit {exit} "."
+       "There is a " monster " in the room, and you see a " treasure " in the corner."
+
+corridor = "You are in a corridor with exits leading to the " exit {exit} "."
+
+exit = "north" / "south" / "east" / "west"
+
+monster = <monster\_name>
+
+treasure = <treasure\_name>
+
+This grammar generates prompts for rooms that include information about the exits, a monster that is present in the room, and a treasure that can be found there. The <monster\_name> and <treasure\_name> symbols represent non-terminal symbols that could be expanded to generate specific names for monsters and treasures. For example, you could define these symbols as follows:
+
+monster\_name = "goblin" / "troll" / "dragon"
+
+treasure\_name = "gold coin" / "magic sword" / "rare gemstone"
+
+This would allow the grammar to generate prompts for rooms with goblins, trolls, or dragons, and treasures such as gold coins, magic swords, or rare gemstones. You could add more rules to the grammar to include other elements of the dungeon, such as quests, challenges, themes, and music.
+
+Overall, this EBNF grammar provides a simple way to generate prompts for creating a dungeon with rooms, corridors, monsters, treasures, and other elements. You can customize and expand the grammar to suit your specific needs and requirements.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_140.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_140.txt
new file mode 100644
index 0000000..31431ce
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_140.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```sql
+<dungeon-prompt> ::= "Imagine a path through the dungeon starting at the entrance and going all the way to the end, with:"
+                      <path-elements>+
+                      "What is your response?"
+
+<path-elements> ::= <path-element> | <path-element> <path-elements>
+
+<path-element> ::= <room-description> <direction-connection>*
+
+<room-description> ::= <room-name> "has" <room-features> "."
+
+<room-features> ::= <feature> | <feature> <feature>
+
+<feature> ::= <object-description> | <monster-description> | <trap-description>
+
+<object-description> ::= <object-name> <object-location>
+
+<object-location> ::= "on the floor" | "on the wall" | "in the corner"
+
+<monster-description> ::= "<monster-name>" <monster-size>
+
+<monster-size> ::= "tiny" | "small" | "medium" | "large" | "huge"
+
+<trap-description> ::= "There is a trap in the" <trap-location>
+
+<trap-location> ::= "floor" | "wall" | "ceiling"
+
+<direction-connection> ::= "<direction> leads to" <room-name> "."
+
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+```
+This grammar defines a `dungeon-prompt` which is a sequence of `path-elements`, where each `path-element` consists of a `room-description` followed by zero or more `direction-connection`. The `room-description` includes the room name and one or more `feature` (objects, monsters, or traps). Each feature has its own set of properties such as location for objects, size for monster, and location for traps. Finally, each path element is connected to next room through a direction.
+
+You can use this grammar to generate different prompts by expanding the non-terminals with your desired values, then using that to query the model, and repeat this process until you get the desired output.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_15.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_15.txt
new file mode 100644
index 0000000..2a7472c
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_15.txt
@@ -0,0 +1,160 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= "Imagine" "a" path
+path ::= ["Consider"] place ("connected with" place)* "all the way to" place
+place ::= type\_name | determinant place
+determinant ::= "the" | "a" | "an"
+type\_name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey"
+
+This grammar allows for the creation of prompts that describe a path through the dungeon, starting at the entrance and leading to the final destination. The path consists of one or more places, each of which can be described by a type name or modified with a determinant (such as "the", "a", or "an").
+
+For example, using this grammar, we could generate the following prompt:
+
+Imagine a path through the dungeon, starting at the entrance and leading all the way to the final boss battle. The first place is a dark, damp cave connected with an eerie, abandoned shrine. The final destination is a massive, ominous door guarded by a powerful monster, the hero journey's greatest challenge yet.
+
+This prompt could be used to generate text describing the path through the dungeon, including descriptions of each place along the way and how they are connected.
+
+I hope this helps! Let me know if you have any questions or need further clarification.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_16.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_16.txt
new file mode 100644
index 0000000..e1bd4f6
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_16.txt
@@ -0,0 +1,172 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<prompt> ::= "Imagine" <type_name> "with a" <subtype_name> "in" <place> "connected with" <connected_place>
+
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<subtype_name> ::= <adjective>* <noun>
+
+<adjective> ::= "ancient" | "mysterious" | "powerful" | "cursed" | "rare" | "legendary"
+
+<noun> ::= "sword" | "shield" | "staff" | "orb" | "ring" | "scroll" | "tome" | "creature" | "beast" | "demon" | "ghost" | "dragon" | "lich" | "boss" | "puzzle" | "riddle" | "temple" | "tomb" | "labyrinth"
+
+<place> ::= <location> | <room>
+
+<connected_place> ::= <location> | <room> | <hallway>
+
+<location> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the vault" | "the keep" | "the hideout"
+
+<room> ::= <location> | "the library" | "the treasure room" | "the throne room" | "the prison" | "the barracks" | "the kitchen" | "the alchemy lab" | "the crypt"
+
+<hallway> ::= "the hallway" | "the corridor" | "the tunnel" | "the passage" | "the staircase"
+```
+This grammar allows for the generation of prompts that describe a specific type of object or event in a particular place, and how it is connected to another place. The `<type_name>` non-terminal can be one of many different types of objects or events found in a typical RPG setting, such as weapons, spells, artifacts, monsters, quests, and challenges. The `<subtype_name>` non-terminal allows for the addition of adjectives to describe the object or event further.
+
+The `<place>` non-terminal can be a location or a room in the dungeon, while the `<connected_place>` non-terminal describes how the place is connected to another place.
+
+This grammar can be used to generate prompts for creating the dungeon by starting at the entrance and generating a path through the dungeon all the way to the end, with each step in the path described by a prompt generated from this grammar. By varying the `<type_name>` non-terminal, you can also use this grammar to generate prompts for creating other elements of the RPG setting, such as NPCs, items, and events.
+
+It's important to note that this is just an example of how a prompt generating grammar could look like, it might need some adjustments depending on the actual context and requirements of your application.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_17.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_17.txt
new file mode 100644
index 0000000..9c4de72
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_17.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```rust
+<path> ::= <room> { <direction> <room> }
+
+<room> ::= "entrance" | "end" | <description>
+
+<direction> ::= "north" | "south" | "east" | "west"
+
+<description> ::= <adjective> <noun>
+
+<adjective> ::= "dark" | "dank" | "twisting" | "secret"
+
+<noun> ::= "hallway" | "corridor" | "chamber" | "passage"
+```
+This grammar defines a path as starting at the entrance and moving through one or more rooms connected by directions. Rooms can be either the entrance, the end, or a described room consisting of an adjective and a noun. The directions are "north", "south", "east", and "west". The adjectives and nouns used to describe rooms can be chosen from a set of predefined options.
+
+You can use this grammar to generate prompts for creating the dungeon by expanding the non-terminals into natural language sentences. For example, a path might look like:
+```vbnet
+entrance
+north dank hallway
+east secret chamber
+south twisting passage
+end
+```
+This can be turned into a prompt such as: "Generate a variant array of paths from the entrance to the end, where each path consists of a sequence of rooms connected by directions. Each room should be either the entrance, the end, or a described room consisting of an adjective and noun (e.g. 'dark hallway'). The directions connecting the rooms are 'north', 'south', 'east', and 'west'."
+
+You can further expand this grammar by adding more non-terminals for other elements of the dungeon, such as treasures, monsters, quests, etc. You can also add more options for the adjectives, nouns, and directions to create a wider variety of descriptions.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_18.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_18.txt
new file mode 100644
index 0000000..5ee937c
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_18.txt
@@ -0,0 +1,161 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```less
+<prompt> ::= "Imagine a " <type_name> " in " <place> ", where " <verb> "."
+<type_name> ::= "dungeon" | "monster" | "treasure" | "quest" | "artifact"
+<place> ::= <location> | <connected_location>
+<location> ::= "the entrance" | "a room" | "a hallway" | "a chest"
+<connected_location> ::= <location1> " connected to " <location2>
+<verb> ::= "entering" | "fighting" | "searching" | "completing"
+```
+This grammar allows for the generation of prompts that describe a specific type of object or event in a particular place within the dungeon, with an action verb indicating what is happening. The `<place>` non-terminal can either refer to a single location (e.g. "the entrance"), or two locations connected by some means (e.g. "a room connected to a hallway"). This allows for the creation of prompts that describe paths through the dungeon, starting at the entrance and leading all the way to the end.
+
+For example, using this grammar, we could generate the following prompt:
+```vbnet
+Imagine a treasure in a chest connected to a room, where searching.
+```
+This prompt describes a scenario in which the player is searching for treasure in a chest that is located in a room that is connected to some other location. The specifics of what the room and connected location are (e.g. "the entrance", "a hallway") would be generated randomly based on the current state of the dungeon.
+
+By using this grammar as a starting point, we can generate a wide variety of prompts that describe different aspects of the dungeon and encourage the player to engage with it in different ways. This will help to create a more dynamic and engaging experience for players, and make the dungeon feel like a real place with its own unique challenges and rewards.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_19.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_19.txt
new file mode 100644
index 0000000..9266178
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_19.txt
@@ -0,0 +1,163 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```makefile
+<path> ::= <room> { <connection> <room> }
+<room> ::= <description>
+<connection> ::= "connected to" | "leading to"
+<description> ::= <type_name> [<adjective>] [<detail>]
+<type_name> ::= "a" ["small" | "large" | "secret"] <noun>
+<noun> ::= "room" | "passage" | "chamber" | "hallway"
+<adjective> ::= "dark" | "lit" | "twisting" | "narrow"
+<detail> ::= <preposition> <place>
+<preposition> ::= "with" | "containing" | "filled with"
+<place> ::= <location> | <item>
+<location> ::= "water" | "slime" | "rats" | "bats"
+<item> ::= "<type_name>"
+```
+This grammar defines the structure of a path as a series of connected rooms, where each room has a type name and optional adjective and detail. The connections between rooms are specified using either "connected to" or "leading to". The `<description>` non-terminal can be used to generate more detailed descriptions for each room.
+
+To use this grammar to generate prompts, you could write a program that recursively expands the non-terminals in the grammar, using the type\_terms, verbs, and places lists from your code as inputs for generating the different elements of the path. For example, to generate a `<type_name>`, the program might randomly select an item from the type\_terms list and append it with "room", "passage", "chamber", or "hallway" to form a complete type name. The same approach could be used for generating the other elements of the path.
+
+Overall, this grammar provides a structured way to generate prompts for creating a dungeon in a fantasy role-playing game. By defining the different components of the dungeon and their relationships to each other, you can create a rich and varied dungeon environment that is engaging for players to explore.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_20.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_20.txt
new file mode 100644
index 0000000..ef60a85
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_20.txt
@@ -0,0 +1,198 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```css
+<path> ::= <segment>*
+
+<segment> ::= <direction> <description>?
+
+<direction> ::= "go" | "move" | "travel"
+
+<description> ::= "towards" <place>
+
+<place> ::= "the entrance" | "the exit" | <room> | <hallway> | <chest> | <bag> | <wallet> | <vault> | <keep> | <hideout> | <cave> | <swamp> | <dungeon> | <labyrinth> | <staircase> | <corridor>
+
+<room> ::= "the" <adjective>? <noun>
+
+<adjective> ::= "dark" | "lit" | "cold" | "warm" | "damp" | "dry"
+
+<noun> ::= "room" | "chamber" | "cell" | "hall" | "library" | "throne room"
+
+<hallway> ::= "the" <adjective>? <noun>
+
+<corridor> ::= "the" <adjective>? <noun>
+
+<staircase> ::= "the" <adjective>? <noun>
+
+<chest> ::= "the" <adjective>? <noun>
+
+<bag> ::= "the" <adjective>? <noun>
+
+<wallet> ::= "the" <adjective>? <noun>
+
+<vault> ::= "the" <adjective>? <noun>
+
+<keep> ::= "the" <adjective>? <noun>
+
+<hideout> ::= "the" <adjective>? <noun>
+
+<cave> ::= "the" <adjective>? <noun>
+
+<swamp> ::= "the" <adjective>? <noun>
+
+<dungeon> ::= "the" <adjective>? <noun>
+
+<labyrinth> ::= "the" <adjective>? <noun>
+```
+This grammar describes a path through the dungeon as a sequence of segments. Each segment consists of a direction (such as "go" or "move") and an optional description that specifies where the player is going. The place they are going can be the entrance, the exit, or a more specific location such as a room or hallway. Rooms, hallways, and other locations can have adjectives that describe their characteristics, such as being dark or lit.
+
+To generate prompts for creating the dungeon, you can use this grammar to randomly select segments and concatenate them together into a complete path. You can then modify the prompt by adding additional information about the current location, any obstacles or enemies that the player might encounter, and any treasures or rewards that they might find. For example:
+```vbnet
+Prompt 1: "You are standing at the entrance of the dungeon. Go towards the lit room. Inside, you see a chest. What do you want to do?"
+
+Prompt 2: "You have moved through the winding corridors and arrived at a damp cave. There is a goblin guarding the entrance. Do you want to fight or sneak past it?"
+
+Prompt 3: "After descending the staircase, you find yourself in a cold, dark room with a chest in the corner. What do you want to do?"
+```
+By generating prompts using this grammar, you can create a diverse and interesting dungeon experience for the player.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_21.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_21.txt
new file mode 100644
index 0000000..efd9f55
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_21.txt
@@ -0,0 +1,179 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= entrance room+ end
+
+entrance ::= "the entrance"
+
+room ::= path\_element
+
+path\_element ::= corridor | chamber
+
+corridor ::= "a corridor leading to" room
+
+chamber ::= "a chamber with" description
+
+description ::= (feature | prop)+
+
+feature ::= "a" feature\_name
+
+feature\_name ::= "statue" | "fountain" | "mural"
+
+prop ::= "containing" item
+
+item ::= "a chest" | "a vase" | "a scroll"
+
+This grammar defines a path as starting with an entrance, followed by one or more room elements, and ending at the final room. Each room can be either a corridor or a chamber, and chambers have a description that consists of one or more features or props. A feature is a specific object found in the room, such as a statue or mural, while a prop is an item that is contained within the room, such as a chest or scroll.
+
+Here is an example of how this grammar could be used to generate a prompt for creating a path:
+
+* Entrance: the entrance
+* Path element 1: a corridor leading to a chamber with a mural
+* Path element 2: a chamber with containing a chest
+* End: the final room
+
+This prompt instructs the user to create a path that starts at the entrance, leads to a chamber with a mural, and then leads to another chamber that contains a chest. The final room is the end of the path.
+
+Of course, this is just one possible grammar for generating prompts for creating a dungeon path. There are many other ways that the grammar could be structured, and it can be customized based on the specific needs and requirements of the dungeon generator.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_22.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_22.txt
new file mode 100644
index 0000000..fe85942
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_22.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```less
+<path> ::= <room> | <path> <corridor> <path> | <path> <staircase> <path>
+
+<room> ::= "Enter the" <description> <room_name>
+
+<corridor> ::= "Walk down the" <description> <corridor_name>
+
+<staircase> ::= "Descend the" <description> <staircase_name>
+
+<description> ::= <adjective> <noun> | <description> <conjunction> <description>
+
+<room_name> ::= <noun> | <adjective> <noun>
+
+<corridor_name> ::= <noun> | <adjective> <noun>
+
+<staircase_name> ::= <noun> | <adjective> <noun>
+
+<adjective> ::= "dark" | "twisting" | "narrow" | "low-ceilinged" | "secret" | ...
+
+<noun> ::= "passage" | "tunnel" | "hallway" | "stairwell" | "door" | ...
+
+<conjunction> ::= "and" | "or" | "but"
+```
+This grammar allows for the generation of a variety of paths through a dungeon, with each room, corridor, and staircase described using adjectives and nouns. The `<description>` non-terminal can be recursively expanded to include multiple adjectives and nouns, connected by conjunctions. The `<room_name>`, `<corridor_name>`, and `<staircase_name>` non-terminals allow for the generation of more specific names for each type of location. The `<adjective>` and `<noun>` non-terminals can be expanded to include a variety of different words, allowing for even more variation in the generated descriptions.
+
+For example, using this grammar, we could generate the following prompt:
+```less
+Enter the dark entrance hall, walk down the twisting passage and descend the narrow stairwell to reach the dimly-lit basement.
+```
+Or
+```less
+Enter the secret door, walk down the low-ceilinged hallway and descend the secret stairwell to reach the treasure room.
+```
+This is just an example grammar, you can modify it as per your requirement and add more non terminals or expand existing one to make it more complex and detailed .
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_23.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_23.txt
new file mode 100644
index 0000000..b73a092
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_23.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path = path-segment | empty
+
+path-segment = "move" direction room
+
+direction = "north" | "south" | "east" | "west"
+
+room = room-description | empty
+
+room-description = "enter" room-name room-details
+
+room-name = "the entrance" | "room 1" | "room 2" | ...
+
+room-details = "you see" description | empty
+
+description = <any text describing the room>
+
+empty = ""
+
+This grammar defines a path as a series of path-segments, where each path-segment consists of moving in a certain direction and entering a room. A room can have an optional room-description, which includes a name for the room and some details about what the player sees when they enter it. The | symbol indicates that either the thing on its left or the thing on its right can be chosen.
+
+For example, using this grammar, you could generate the following prompt:
+
+move north the entrance you see a dark and ominous hallway with torches lining the walls
+
+This prompt tells the player to move north into a room called "the entrance," which has a description of a dark and ominous hallway with torches. You can use this grammar as a starting point and modify it to fit your specific needs for generating prompts for your dungeon generator.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_24.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_24.txt
new file mode 100644
index 0000000..63105ce
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_24.txt
@@ -0,0 +1,164 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```vbnet
+<dungeon> ::= <path> | <room>
+<path> ::= "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " <verb> "; Type Name: " <type_name> "; Place: " <place>   " What is your response?" ^  " Please generate variant array of size " <try_n>    "<dungeon>"
+<room> ::= "Imagine"; "Consider"; "Draw"; "Paint"; "Compose"; "Balance" <description> "; in the " <place> ". "
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<description> ::= <type_name> with a <description2>
+<description2> ::= <adjective> <noun> | <noun> <verb> | <noun> and <noun> | <noun> or <noun>
+<adjective> ::= "beautiful" | "ugly" | "powerful" | "weak" | "large" | "small" | "angry" | "happy" | "sad" | "scary" | "funny" | "fast" | "slow"
+<noun> ::= <type_name> | <place>
+<try_n> ::= 1 | 2 | 3 | 4 | 5
+<place> ::= "entrance" | "exit" | "corridor" | "room" | "hallway" | "staircase" | "dead-end" | "intersection" | "gate" | "portal" | "maze"
+```
+This grammar defines a `<dungeon>` as either a `<path>` or a `<room>`. A `<path>` is a prompt that asks the language model to generate variants of the next part of the dungeon, while a `<room>` prompt asks the language model to imagine a specific type of thing (such as a weapon) in a specific place.
+
+The grammar also defines various non-terminals such as `<type_name>`, `<verb>`, and `<description2>` that can be used to generate different types of prompts. For example, the `<description2>` non-terminal can be used to generate prompts that describe a type of thing in terms of an adjective and a noun, or as two nouns related by a verb, or as two nouns joined by a conjunction.
+
+The `<try_n>` non-terminal is used to specify the number of variants that should be generated for each prompt. The `<place>` non-terminal can be used to specify different locations in the dungeon, such as the entrance or a corridor.
+
+Overall, this grammar provides a flexible way to generate prompts for creating different parts of the dungeon, and can be easily extended with new types of prompts, places, and things.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_25.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_25.txt
new file mode 100644
index 0000000..5905ef5
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_25.txt
@@ -0,0 +1,172 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path = path\_segment, { path\_segment }
+
+path\_segment = move | room | obstacle | event
+
+move = "move" SP verb SP direction
+
+room = "enter" SP room\_name
+
+obstacle = "encounter" SP obstacle\_type
+
+event = "trigger" SP event\_type
+
+SP = " "
+
+verb = "walk" | "run" | "sneak" | "jump" | "climb" | "swim"
+
+direction = "north" | "south" | "east" | "west" | "up" | "down"
+
+room\_name = "entrance" | "lobby" | "corridor" | "library" | "throne room" | "exit"
+
+obstacle\_type = "trap" | "locked door" | "monster" | "puzzle"
+
+event\_type = "random encounter" | "treasure find" | "boss battle" | "secret passage"
+
+This grammar defines a path as a sequence of path segments, which can be a move, room, obstacle, or event. Each path segment has specific keywords and syntax to describe it. The SP symbol represents a space character. The verb in the move segment can have different values such as "walk", "run", etc. The direction in the move segment can also have different values such as "north", "south", etc. Room names, obstacle types, and event types are defined as specific words.
+
+You could use this grammar to generate prompts by randomly selecting elements from each non-terminal symbol and concatenating them together with the appropriate syntax. For example, a prompt generated using this grammar might look like: "move north, enter lobby, encounter locked door, trigger random encounter"
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_26.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_26.txt
new file mode 100644
index 0000000..8c043d1
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_26.txt
@@ -0,0 +1,182 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon := {room}
+
+room := "Enter" room\_name "and find:" | room\_description
+
+room\_name := VERB\_NAME "room with a" TYPE\_NAME
+
+room\_description := QUANTITY verb\_phrase object\_phrase
+
+verb\_phrase := TOP\_TERM "doing" VERB\_NAME | TOP\_TERM "connected to" PLACE
+
+object\_phrase := ARTICLE NOUN\_PHRASE | ADJECTIVE NOUN\_PHRASE
+
+noun\_phrase := {NOUN}
+
+VERB\_NAME := "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+TOP\_TERM := "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+
+QUANTITY := "There are" NUMBER | "A few" | "Several" | "Many" | "Countless"
+
+ARTICLE := "a" | "an" | "the"
+
+ADJECTIVE := "magical" | "dangerous" | "powerful" | "ancient" | "rusty" | "shiny" | "dark"
+
+NOUN := VERB\_NAME | PLACE | CHARACTER
+
+PLACE := "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "Plato's cave" | "Garden of Eden" | "the river Styx" | "the restaurant at the end of the universe"
+
+CHARACTER := "guard" | "monster" | "trapper" | "shopkeeper" | "questgiver"
+
+NUMERAL := [0-9]+
+
+NUMBER := NUMERAL | "few" | "several" | "many" | "countless"
+
+In this grammar, a dungeon is made up of one or more rooms. Each room can be entered and will contain an object or a description of the room. The object in the room is specified by a verb phrase, which consists of a top term (such as "imagine" or "consider") followed by a verb and a type of object. The description of the room is specified by a quantity followed by a verb phrase and an object phrase. The object phrase can be a single noun, or it can be made up of multiple nouns modified by adjectives.
+
+This grammar allows for a lot of flexibility in generating prompts for creating a dungeon, as it includes many different elements that can be combined in various ways to create unique and interesting rooms. It is also easily extensible, so new types of objects or room descriptions can be added as needed.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_27.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_27.txt
new file mode 100644
index 0000000..612cc84
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_27.txt
@@ -0,0 +1,172 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```
+path            = (room | corridor | intersection)*, treasure_room? end_room;
+room            = "the room" "connected with" other_room;
+corridor        = "the hallway" "connected with" other_room;
+intersection    = "the crossroads" "connecting" room ("," room)*;
+treasure_room   = "the treasure room" "containing" treasure*;
+end_room        = "the final room";
+other_room      = room | corridor | intersection;
+treasure        = "a chest with" loot;
+loot            = weapon | spell | artifact | magic_item;
+weapon          = "a sword" | "a bow" | "a staff";
+spell           = "a fireball scroll" | "a healing potion";
+artifact        = "the holy grail" | "the one ring";
+magic_item      = "a cloak of invisibility" | "a pair of magic boots";
+```
+This grammar defines a `path` through the dungeon, which consists of a series of `room`, `corridor`, and `intersection` elements. Each `room` is connected to another room via a `corridor`, while an `intersection` connects multiple rooms together. A `treasure_room` may be encountered along the path, containing one or more `treasure` items. The `path` ends with a final `end_room`.
+
+Each `room`, `corridor`, and `intersection` element is defined in terms of other elements, allowing for recursive generation of complex dungeon layouts. The `treasure` element consists of one or more `loot` items, which are specified as either a `weapon`, `spell`, `artifact`, or `magic_item`. Each of these loot types is defined with a specific example item.
+
+This grammar can be used to generate prompts for creating the various elements of the dungeon by recursively expanding the non-terminal symbols until only terminal symbols remain. For example, to generate a prompt for creating a `path`, the following expansion could be used:
+```
+path -> room corridor intersection treasure_room end_room
+```
+This would expand to:
+```
+the room connected with the hallway connected with the crossroads connecting the room, the treasure room containing a chest with a sword, a fireball scroll, and the one ring end_room
+```
+This prompt could then be used as input for the language model to generate a description of the dungeon path. The grammar can also be extended to include other elements such as monsters, quests, or challenges that the player may encounter in the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_28.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_28.txt
new file mode 100644
index 0000000..c23729f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_28.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```lua
+<prompt> ::= "Imagine" <sentence> ";" <sentence> ";" <sentence> ";"
+<sentence> ::= <subject> <verb_phrase> <object> ";"
+<subject> ::= "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture."
+<verb_phrase> ::= "with the following context:" <context>
+<context> ::= "Verb" ":" <verb> "|" "Type Name" ":" <type_name> "|" "Place" ":" <place>
+<object> ::= "What is your response?"
+<variant_array_size> ::= <positive_integer>
+<positive_integer> ::= "1" "2" "3" ...
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<type_name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "place"
+<place> ::= <path_element> | <room_name> | <region_name>
+<path_element> ::= "entrance" | "exit" | "hallway" | "stairs" | "door" | "passage" | "tunnel" | "bridge" | "corridor" | "dead-end" | "intersection"
+<room_name> ::= "throne room" | "armory" | "library" | "laboratory" | "kitchen" | "dining hall" | "bedchamber" | "ballroom" | "treasure room" | "prison cell" | "guest quarters"
+<region_name> ::= "outer wall" | "inner wall" | "keep" | "courtyard" | "dungeon" | "tower" | "castle gate" | "bailey" | "curtain wall" | "gatehouse"
+```
+This grammar can be used to generate prompts for creating different parts of a dungeon, including the entrance, exit, rooms, and regions. The `<variant_array_size>` non-terminal can be used to specify the size of a variant array, which can be useful for generating multiple variations of a room or region.
+
+Here is an example of a prompt generated using this grammar:
+```vbnet
+Imagine We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. with the following context: Verb: create | Type Name: quest | Place: entrance connected with hallway; What is your response?
+```
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_29.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_29.txt
new file mode 100644
index 0000000..2772d1d
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_29.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+Path ::= PathPart | Empty
+
+PathPart ::= "From" Place "GoTo" Place Verb
+
+Place ::= Identifier | "Entrance" | "Exit"
+
+Verb ::= "Walking" | "Running" | "Crawling" | "Sneaking" | "Fighting"
+
+Identifier ::= [a-zA-Z\_][a-zA-Z0-9\_]*
+
+Empty ::= ""
+
+This grammar defines a path as a series of connected path parts, each of which specifies a verb for moving between two places. The place where the path starts can be specified as the "Entrance" and the place where it ends can be specified as the "Exit". Other places in the dungeon can be identified using identifiers that are unique within the context of the prompt.
+
+For example, a path through the dungeon could be generated using the following prompt:
+
+Path: From Entrance GoTo Room1 Walking; PathPart: From Room1 GoTo Room2 Running; PathPart: From Room2 GoTo EnemyArea Fighting; PathPart: From EnemyArea GoTo Exit Sneaking
+
+This prompt specifies a path that starts at the entrance, goes to a room labeled "Room1" while walking, then goes to another room labeled "Room2" while running, and so on. The final step in the path is to go from an area with enemies to the exit while sneaking.
+
+It's important to note that this grammar is just one example of how prompts for creating a dungeon path could be generated. There are many other possible ways to define the grammar and generate prompts using it. The key is to create a grammar that is flexible enough to generate a wide variety of paths, while also being easy to understand and use.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_30.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_30.txt
new file mode 100644
index 0000000..fa9f6f7
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_30.txt
@@ -0,0 +1,183 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a path through a dungeon:
+
+path ::= entrance room* exit
+
+entrance ::= "the entrance"
+
+room ::= place description? action*
+
+place ::= "a" | "the" identifer
+
+identifier ::= [A-Za-z\_]+
+
+description ::= "which is" adjective+
+
+adjective ::= "dark" | "damp" | "cold" | "wet" | "deserted" | "lonely" | ...
+
+action ::= verb object?
+
+verb ::= "has" action\_verb | "contains" action\_verb
+
+action\_verb ::= "a" | "the" identifer
+
+object ::= "hidden" treasure | "guarding" monster
+
+treasure ::= "chest" | "pile of gold" | "magic artifact" | ...
+
+monster ::= "goblin" | "troll" | "dragon" | ...
+
+exit ::= "the exit" | "a secret passage" | "a hidden door" | ...
+
+This grammar can be used to generate prompts like:
+
+* Generate a variant array of 3 paths starting at the entrance and going all the way to the ends. Each path should consist of a sequence of rooms, where each room has a place, may have a description, and has one or more actions.
+* The first path starts at the entrance, then goes to "a dark room which is cold and damp" and has "a chest hidden in the corner". The second path starts at the entrance, then goes to "the troll-guarded chamber" and contains "a pile of gold". The third path starts at the entrance, then goes to "a secret passage" and has "a magic artifact".
+* Generate a variant array of 3 paths starting at the entrance and going all the way to the ends. Each path should consist of a sequence of rooms, where each room has a place, may have a description, and has one or more actions.
+* The first path starts at "the entrance", then goes to "a dark and damp room" which is guarded by "a goblin". The second path starts at the entrance, then goes to "a treasure-filled chamber" and contains "a magic artifact". The third path starts at the entrance, then goes to "a hidden door" and has "a troll".
+* Generate a variant array of 3 paths starting at the entrance and going all the way to the ends. Each path should consist of a sequence of rooms, where each room has a place, may have a description, and has one or more actions.
+* The first path starts at the entrance, then goes to "a cold room" which contains "a chest". The second path starts at the entrance, then goes to "a dark chamber" and has "a dragon guarding a magic artifact". The third path starts at the entrance, then goes to "a damp room" and has "a hidden pile of gold".
+
+This is just an example, you can customize it according to your need.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_31.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_31.txt
new file mode 100644
index 0000000..874747e
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_31.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+
+dungeon\_prompt ::= "Imagine" "a" dungeon\_type "with" theme "in" place "from" entrance "to" exit
+
+dungeon\_type ::= "dungeon" | "maze" | "cave"
+
+theme ::= "horror" | "fantasy" | "adventure"
+
+place ::= "the" (location | landmark)
+
+entrance ::= "the" entrance\_type
+
+exit ::= "the" exit\_type
+
+location ::= "city" | "village" | "castle"
+
+landmark ::= "mountain" | "river" | "forest"
+
+entrance\_type ::= "gate" | "door" | "portal"
+
+exit\_type ::= "treasure room" | "boss chamber" | "throne room"
+
+This grammar can be used to generate prompts for creating a dungeon with a specific theme, location, entrance, and exit. For example, the prompt "Imagine a maze with a horror theme in a forest from a gate to the treasure room" could be generated using this grammar.
+
+To generate more complex prompts, you can add additional rules to the grammar. For example, you could add rules for generating prompts that include monsters, traps, and puzzles. You could also add rules for generating prompts that describe different parts of the dungeon, such as rooms, corridors, and chambers.
+
+It is important to note that this is just one possible grammar for generating prompts for creating a dungeon. There are many other ways you could design a grammar to generate prompts, depending on your specific needs and requirements. The key is to create a grammar that is flexible and expressive enough to generate the types of prompts you need, while also being easy to use and understand.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_32.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_32.txt
new file mode 100644
index 0000000..453efc7
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_32.txt
@@ -0,0 +1,179 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an EBNF grammar for generating prompts to create a dungeon:
+```scss
+<prompt> ::= "Imagine" "a" <type_name> "in" <place>
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey"
+<place> ::= <building> | <room> | <hallway> | <chest> | <bag> | <wallet> | <vault> | <keep> | <hideout> | <location>
+<building> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<room> ::= "the room" | "a room"
+<hallway> ::= "the hallway" | "a hallway"
+<chest> ::= "the chest" | "a chest"
+<bag> ::= "the bag" | "a bag"
+<wallet> ::= "the wallet" | "a wallet"
+<vault> ::= "the vault" | "a vault"
+<keep> ::= "the keep" | "a keep"
+<hideout> ::= "the hideout" | "a hideout"
+<location> ::= <building> | <room> | <hallway> | <chest> | <bag> | <wallet> | <vault> | <keep> | <hideout> | <place_modifier> <place>
+<place_modifier> ::= "the" | "a" | "another" | "this" | "that" | "every" | "each" | "my" | "your" | "his" | "her" | "our" | "their" | "some" | "any"
+```
+You can use this grammar to generate prompts for creating different types of elements in the dungeon, such as weapons, spells, artifacts, etc. Each prompt will include a type name and a place where the element is located or found. You can also modify the grammar to include additional elements, such as NPCs, traps, puzzles, etc.
+
+Here are some examples of prompts generated using this grammar:
+
+* Imagine a weapon in the entrance hall of the castle
+* Imagine a spell in the witch's hut in the forest
+* Imagine an artifact in the hidden chamber of the pyramid
+* Imagine a magic item in the enchanted grove of the elves
+* Imagine a treasure in the dragon's lair in the mountains
+* Imagine a monster in the dark alley of the city
+* Imagine a quest in the tavern of the village
+* Imagine a challenge in the ruins of the ancient civilization
+* Imagine a theme in the festival of the kingdom
+* Imagine a drama in the theater of the capital
+* Imagine a music in the ball of the aristocrats
+* Imagine an art in the gallery of the museum
+* Imagine a secret in the secret passage of the fortress
+* Imagine an occult in the cult's temple in the jungle
+* Imagine a hero journey in the epic saga of the legends
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_33.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_33.txt
new file mode 100644
index 0000000..b900558
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_33.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```
+<dungeon-prompt> ::= "Imagine" <path> <event-sequence>
+<path> ::= "<place1> connected with <place2>"
+<event-sequence> ::= <event> {"," <event>}
+<event> ::= "<verb> doing <type>"
+<type> ::= <type-name> [<type-modifier>]
+<type-name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult reveal" | "hero journey"
+<type-modifier> ::= "of the <quality>"
+<quality> ::= "light" | "dark" | "fire" | "water" | "air" | "earth"
+<place1> ::= <place>
+<place2> ::= <place>
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "draw" | "paint" | "compose" | "balance"
+```
+This grammar describes a dungeon prompt as an "Imagine" statement followed by a path through the dungeon and a sequence of events. The path is defined as two connected places, while the event sequence is made up of one or more events separated by commas. An event is defined as a verb and a type, where the type can optionally have a quality modifier.
+
+This grammar allows for a lot of flexibility in generating prompts for creating a dungeon. The path through the dungeon can be varied by changing the places and their connections. The events can also be modified by changing the verbs and types, as well as adding or removing quality modifiers. This allows for a wide range of possible dungeons to be generated using this grammar.
+
+For example, here is a prompt that could be generated using this grammar:
+```
+Imagine a path through the dungeon from the entrance connected with the first room, where a hero journey doing a quest of the light is role-played, and an artifact of the dark is specified, and a challenge of the fire is coded.
+```
+This prompt describes a dungeon with a path from the entrance to the first room, where the hero will be on a quest of light and there will be a role-play event, as well as events for specifying an artifact of darkness and coding a challenge of fire. This is just one example of the many possible prompts that can be generated using this grammar.
+
+It's also possible to extend this grammar with more elements such as NPCs or other elements you would like to include in your dungeon.
+
+Please let me know if you have any question or need further clarification.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_34.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_34.txt
new file mode 100644
index 0000000..7a26e0e
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_34.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+path ::= (room | hallway) "\n"
+
+room ::= "Enter room " room\_name "\n"
+room\_name ::= "the " [a-zA-Z] +
+
+hallway ::= "Walk down the " hall\_name "\n"
+hall\_name ::= "the " [a-zA-Z] +
+
+This grammar defines a path through a dungeon as a series of rooms and hallways, represented by the non-terminals `path`, `room`, and `hallway`. A room is defined as entering a room with a name consisting of "the" followed by one or more letters (e.g., "the entrance"). A hallway is defined as walking down a hallway with a name consisting of "the" followed by one or more letters (e.g., "the corridor").
+
+This grammar can be used to generate prompts for creating a dungeon by recursively expanding the non-terminals until a sequence of text is generated. For example, the following prompt could be generated using this grammar:
+
+Enter room the entrance
+Walk down the hallway
+Enter room the first room
+Walk down the hallway
+Enter room the second room
+Walk down the hallway
+Enter room the treasure room
+
+This prompt describes a path through a dungeon with three rooms, each connected by a hallway. The final room is the "treasure room," indicating that it might contain some valuable items or rewards for the player to discover.
+
+Of course, this grammar is just one possible way of generating prompts for creating a dungeon, and there are many other ways it could be designed. It could be expanded to include more complex elements, such as branching paths, secret rooms, or puzzles for the player to solve. It could also be modified to generate prompts for other aspects of the dungeon, such as its layout, decorations, or encounters with monsters. The possibilities are endless!
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_35.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_35.txt
new file mode 100644
index 0000000..b9a6085
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_35.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+prompt ::= "Imagine" starter_sentence context
+starter_sentence ::= "You are building a dungeon for a fantasy role-playing game."
+                     | "Consider the following prompt for generating a part of the dungeon."
+context ::= type_name location action
+type_name ::= "a" ("weapon" | "spell" | "artifact" | "magic item" | "treasure"
+                  | "monster" | "quest" | "challenge" | "theme" | "drama"
+                  | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey")
+location ::= "the" ("country" | "region" | "city" | "street" | "house" | "building"
+                | "dungeon" | "labyrinth" | "cave" | "swamp" | "room"
+                | "hallway" | "chest" | "bag" | "wallet" | "vault"
+                | "keep" | "hideout" | "Plato's cave" | "Garden of Eden"
+                | "River Styx" | "restaurant at the end of the universe")
+action ::= verb ("with a" attribute | ("connected with" location))
+verb ::= ("create" | "design" | "describe" | "analyze" | "lift" | "shift"
+          | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote"
+          | "meta-quote")
+attribute ::= ("beautiful" | "majestic" | "dark" | "spooky" | "ancient"
+              | "magical" | "mysterious" | "powerful" | "evil"
+              | "forgotten" | "hidden")
+```
+This grammar allows for the generation of prompts that describe different parts of a dungeon, such as weapons, spells, and monsters, in different locations and with different attributes. The starter\_sentence and context fields can be customized to fit the specific needs of your application. Additionally, you can extend or modify this grammar to include other elements of a fantasy RPG setting that you would like to generate prompts for.
+
+Note: This is just one example of an EBNF grammar that could be used for generating prompts for creating a dungeon, and it might not cover all the use cases you need. You can modify or extend this grammar according to your requirements.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_36.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_36.txt
new file mode 100644
index 0000000..735d6c4
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_36.txt
@@ -0,0 +1,179 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= (path | room | description | object | monster | quest)*
+
+path ::= "From" place "to" place
+room ::= "Inside" place "is" description
+description ::= (element | theme | drama | music | art | secret | occult | reveal | hero\_journey)+
+object ::= "There is a(n)" type\_name (attribute)*
+monster ::= "A" type\_name (attribute)*
+quest ::= "The quest to" (action | defeat) type\_name
+
+element ::= "element of" type\_name
+theme ::= "theme of" type\_name
+drama ::= "drama in the style of" type\_name
+music ::= "music in the style of" type\_name
+art ::= "art in the style of" type\_name
+secret ::= "secret about" type\_name
+occult ::= "occult knowledge of" type\_name
+reveal ::= "a reveal of" type\_name
+hero\_journey ::= "the hero's journey through" type\_name
+
+attribute ::= "with" (attribute\_name | attribute\_value)*
+attribute\_name ::= "name" | "description" | "power" | "weakness" | "appearance"
+attribute\_value ::= "value" | "color" | "size" | "shape" | "texture"
+
+action ::= "find" | "slay" | "defeat" | "retrieve" | "unlock" | "discover"
+
+place ::= (place\_name | place\_description)
+place\_name ::= "the entrance" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+place\_description ::= "a dark and damp room" | "a maze-like series of tunnels" | "a hidden chamber" | "a mysterious forest" | "a haunted castle" | "a treacherous mountain pass"
+
+type\_name ::= (type\_terms | type\_terms\_custom)
+type\_terms ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challege" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+type\_terms\_custom ::= "a special weapon" | "an ancient spell" | "powerful artifacts" | "rare magic items" | "valuable treasure" | "fearsome monster" | "epic quest" | "dangerous challenge" | "unique theme" | "captivating drama" | "inspiring music" | "beautiful art" | "hidden secret" | "mysterious occult" | "shocking reveal" | "legendary hero journey"
+
+This grammar can be used to generate a wide variety of prompts for creating different aspects of the dungeon, such as paths, rooms, descriptions, objects, monsters, and quests. The attributes allow further customization of each element in the dungeon. Place names can be chosen from a list of predefined names or created using a place description. Type names can also be chosen from a list of predefined terms or customized with more specific details.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_37.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_37.txt
new file mode 100644
index 0000000..d5ae888
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_37.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon> ::= <path>*
+
+<path> ::= <room>+
+
+<room> ::= <description> <connections>
+
+<description> ::= "A" (adjective | "dark") "room"
+
+<connections> ::= "with connections to" (<direction> | "none") ("," <direction> | "")*
+
+<adjective> ::= "small" | "large" | "dimly-lit" | "brightly-lit"
+
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+```
+In this grammar, a dungeon is made up of one or more paths. A path is made up of one or more rooms. Each room has a description and a list of connections to other rooms in the form of directions. The description of the room can be modified by an adjective. The connections list is optional and if present, it lists the directions that lead out of the current room.
+
+For example, using this grammar, one possible prompt for creating a dungeon could be:
+```vbnet
+A small room with connections to north, east, A dimly-lit room with connections to west
+```
+This prompt describes a small room that is connected to the north and east, and another room that is dimly lit and connected to the west.
+
+You could also add other elements such as monsters, treasures, quests, etc. in the same way using this grammar or extending it.
+
+Let me know if you have any question or need further help.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_38.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_38.txt
new file mode 100644
index 0000000..c7d7949
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_38.txt
@@ -0,0 +1,160 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+Entrance ::= "the entrance"
+End ::= "the end"
+Room ::= "a room" | "the room"
+Corridor ::= "a corridor" | "the corridor"
+Door ::= "a door" | "the door"
+Path ::= Entrance PathStep* End
+PathStep ::= Room | Corridor Door
+
+Example prompt using the grammar:
+
+"We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : navigate; Type Name: Path; Place: the dungeon What is your response? Please generate variant array of size 3"
+
+This prompt would instruct the model to generate three different paths through a dungeon, starting at the entrance and ending at the end. Each path step would be a room or corridor, with an optional door connecting it to the next step. The model could then use this information to create a detailed description of the dungeon for the game.
+
+Note: This is just one possible grammar that could be used for generating prompts for creating a dungeon. There are many other ways to approach this problem, and you may want to experiment with different grammars to find the one that works best for your specific use case.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_39.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_39.txt
new file mode 100644
index 0000000..fc2c859
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_39.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= path-segment | empty
+
+path-segment ::= "move" direction "through" description "and then"
+
+direction ::= "north" | "south" | "east" | "west"
+
+description ::= room-description | corridor-description
+
+room-description ::= "enter" room-name
+
+corridor-description ::= "traverse" corridor-name
+
+room-name ::= "the entrance chamber" | "a small storeroom" | ...
+
+corridor-name ::= "the winding passageway" | "a long straight corridor" | ...
+
+This grammar defines a path as a sequence of one or more path segments, where each segment represents moving in a certain direction through a described location. The direction can be north, south, east, or west, and the description can be either a room or a corridor. Rooms have specific names, such as "the entrance chamber" or "a small storeroom," while corridors also have descriptive names like "the winding passageway" or "a long straight corridor."
+
+By using this grammar to generate prompts, we can create a variety of different paths through the dungeon, each with its own unique sequence of rooms and corridors. These prompts could then be used as input to the language model to generate descriptions for each location, resulting in a richly detailed and immersive dungeon environment.
+
+Of course, this is just one possible example of how such a grammar might be structured. Depending on the specific needs and requirements of the project, other variations or extensions of this grammar might be more appropriate. The key is to design a grammar that can generate prompts that are both varied and relevant to the task at hand, in order to maximize the creativity and expressiveness of the language model.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_40.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_40.txt
new file mode 100644
index 0000000..1052d63
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_40.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```r
+<prompt> ::= "Imagine a " <type_name> " named " <type_name> " in " <place> ", doing " <verb> ". Generate variant array of size " <try_n> "."
+
+<type_name> ::= <term> { " with a " <term2> }
+
+<term> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<term2> ::= <type_name> | "randomly generated"
+
+<verb> ::= <top_verb> { " doing " <verb2> }
+
+<top_verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "describe" | "analyze" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+
+<verb2> ::= <type_name> | "randomly generated"
+
+<place> ::= <place_part> { " connected with " <place_part> }
+
+<place_part> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the room" | "randomly generated"
+
+<try_n> ::= <number>
+
+<number> ::= [0-9]+
+```
+This grammar allows for the generation of prompts that include a type of thing (such as a weapon or spell), an action to be taken with that thing, and a location for that thing. The type name can include additional attributes such as being randomly generated. The verb can also include additional actions to be taken with the thing. The place can include multiple connected locations, each of which can be specified in more detail. Finally, the size of the variant array can be specified with a number.
+
+This is just one example of how a grammar for generating prompts could be defined. Depending on the specific requirements of your application, you may want to adjust this grammar or define a new one that better meets those needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_41.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_41.txt
new file mode 100644
index 0000000..0f908ed
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_41.txt
@@ -0,0 +1,174 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<path> ::= <room> { <path-segment> }
+
+<path-segment> ::= "move" <direction> "to" <room>
+
+<room> ::= <room-name> [ "with" <room-description> ]
+
+<room-name> ::= <identifier>
+
+<room-description> ::= { <feature> }
+
+<feature> ::= <feature-name> [ "connected to" <feature-name> ]
+
+<direction> ::= "north" | "south" | "east" | "west"
+
+<identifier> ::= <letter> { <letter> | <digit> }
+
+<letter> ::= 'a' .. 'z' | 'A' .. 'Z'
+
+<digit> ::= '0' .. '9'
+```
+This grammar defines a `path` as a sequence of `room`s connected by `path-segment`s. Each `room` has a name and may optionally have a description, which consists of one or more `feature`s. A `feature` can be connected to another `feature`, allowing for the creation of complex dungeon layouts.
+
+The `direction` element is used in the `path-segment` production to indicate the direction of movement between rooms. The `identifier` element is used to define room names and feature names, while the `letter` and `digit` elements are used to define specific characters that can be included in these identifiers.
+
+This grammar can be used to generate a variety of different prompts for creating a dungeon, depending on the specific elements that are included in each production. For example, the following prompt could be generated using this grammar:
+```vbnet
+We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : move; Type Name: room; Place: connected to the entrance What is your response? Please generate variant array of size 3 for "Entrance Hallway with a large wooden door leading into the next area" connected to "the entrance".
+```
+This prompt asks the language model to generate three different descriptions for an `Entrance Hallway` that is connected to the `entrance`. The `path-segment` production is used to indicate the direction of movement between the two rooms, and the `room-description` production is used to provide additional details about the `Entrance Hallway`. By using this grammar to generate a variety of different prompts, it is possible to create a wide range of different dungeon layouts and descriptions.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_42.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_42.txt
new file mode 100644
index 0000000..900c8e9
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_42.txt
@@ -0,0 +1,163 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<path> ::= <room> | <path> <corridor> <room>
+<room> ::= "the" <place_name>
+<corridor> ::= "a corridor leading from" <room> "to" <room>
+<place_name> ::= <type_term> | <specific_place>
+<type_term> ::= "dungeon" | "room" | "corridor" | "entrance" | "exit"
+<specific_place> ::= "cave" | "keep" | "hideout" | "platos cave" | "garden of eden" | "river styx" | <etc.>
+```
+This grammar defines a path through the dungeon as a series of rooms connected by corridors. Each room is a specific type of place (e.g., a cave, keep, etc.) or a more general type of place (e.g., a dungeon room). The corridors connecting the rooms are also specified as a certain type of place (e.g., a dungeon corridor).
+
+This grammar can be used to generate prompts for creating different parts of the dungeon by using different production rules. For example, to generate a prompt for creating the entrance of the dungeon, you could use the following production:
+```rust
+<path> ::= "the" <type_term> "entrance"
+```
+To generate a prompt for creating a corridor connecting two rooms, you could use the following production:
+```css
+<corridor> ::= "a" <type_term> "corridor leading from" <room> "to" <room>
+```
+And so on. By using different combinations of production rules, you can generate a wide variety of prompts for creating different parts of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_43.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_43.txt
new file mode 100644
index 0000000..38702e2
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_43.txt
@@ -0,0 +1,162 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+```makefile
+prompt -> "Imagine a path from the entrance to the end of the dungeon with the following features: " feature\_list
+
+feature\_list -> feature | feature "," feature\_list
+
+feature -> room | corridor | obstacle | monster
+
+room -> "a room" | "an intersection"
+
+corridor -> "a straight corridor" | "a winding corridor"
+
+obstacle -> "a pit" | "a locked door" | "a trapped chest"
+
+monster -> "a goblin ambush" | "a giant spider web" | "a dragon's lair"
+```
+This grammar defines a prompt as a list of features that the path should have. Each feature can be a room, a corridor, an obstacle, or a monster. Rooms and corridors are further defined as either a simple version or a more complex one. Obstacles and monsters are also defined as specific types of challenges that the players might encounter on their path through the dungeon.
+
+This is just an example grammar, you could easily add more features or make it more complex to suit your needs. The important thing is to define the structure of a prompt in a way that makes it easy for the language model to generate the desired output.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_44.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_44.txt
new file mode 100644
index 0000000..1581ad6
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_44.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= "Imagine" "a" path
+path ::= place ( ("connected" | "leading") place )* "to" place
+place ::= type\_name with\_modifier?
+type\_name ::= "the" ( "entrance" | "exit" | room | corridor | chamber | "labyrinth" | "dungeon" | "keep" | "hideout" | "vault" | "chest" | "bag" | "wallet" )
+with\_modifier ::= "with" ( "a" type\_name | "filled" with\_contents | "guarded" by\_guardian | "locked" lock\_description )?
+with\_contents ::= "of" type\_name ( "," type\_name )*
+by\_guardian ::= "by" guardian\_type
+guardian\_type ::= "a" monster | "the" NPC
+lock\_description ::= "locked" lock\_difficulty
+lock\_difficulty ::= "simple" | "moderate" | "hard" | "impossible"
+NPC ::= name\_of\_person
+monster ::= name\_of\_monster
+name\_of\_person ::= "guard" | "keeper" | "clerk" | "shopkeeper" | "merchant" | "innkeeper" | "barkeep" | "proprietor" | "squire" | "lord" | "lady" | "king" | "queen" | "prince" | "princess"
+name\_of\_monster ::= "goblin" | "orc" | "troll" | "ogre" | "dragon" | "demon" | "devil" | "vampire" | "werewolf" | "zombie" | "skeleton" | "ghost" | "mummy" | "frankenstein's monster"
+room ::= "the" ( "inn" | "tavern" | "library" | "armory" | "throne room" | "ballroom" | "bedroom" | "kitchen" | "dining room" | "study" | "laboratory" | "workshop" | "garage" | "barn" | "stable" | "greenhouse" | "garden" | "park" | "square" | "plaza" | "market" | "street" | "avenue" | "square" | "neighborhood" | "district" | "city" | "region" | "country" | "province" | "kingdom" | "empire" )
+corridor ::= "the" ( "hallway" | "corridor" | "passage" | "alley" | "tunnel" | "cave" | "mine" | "sewer" | "catacomb" | "burial chamber" )
+chamber ::= "the" ( "prison" | "dungeon" | "cellar" | "basement" | "attic" | "tower" | "keep" | "citadel" | "fortress" | "castle" | "palace" | "mansion" | "manor" | "villa" | "cottage" | "hut" | "shack" )
+
+This grammar allows for the generation of prompts that describe a path through a dungeon, starting at the entrance and ending at the exit. Each place along the path is described using a type name (such as "room", "corridor", or "chamber"), which may be modified with additional information such as its contents, guardian, or lock difficulty.
+
+For example, the following prompt could be generated using this grammar:
+
+Imagine a path from the entrance to the exit, starting with the inn, which is connected to a hallway leading to the library, which is locked with a simple lock and filled with books. The library is guarded by a clerk. The path continues through a corridor connected to the armory, which is filled with weapons and guarded by a squire. The armory leads to the throne room, which is locked with an impossible lock and filled with treasures. The throne room is guarded by a king. Finally, the path ends at the exit, which is the castle gate.
+
+This prompt describes a dungeon with a number of different rooms and corridors, each with its own contents, guardian, and lock difficulty. By following this path, the player can explore the dungeon and eventually reach the treasure hidden within the throne room.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_45.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_45.txt
new file mode 100644
index 0000000..56262d1
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_45.txt
@@ -0,0 +1,158 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```less
+<prompt> ::= "Imagine" <place> <type_name> <verb> <direction>
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<direction> ::= <place> "connected with" <place> | "towards the" <place> | "away from the" <place> | "into the" <place> | "out of the" <place>
+```
+This grammar can be used to generate prompts such as:
+
+* "Imagine a weapon role-play towards the city"
+* "Create a spell design into the dungeon connected with the labyrinth"
+* "Imagine a treasure analyse away from the region"
+
+You can add or remove rules and elements to fit your specific needs. Also, you can use this grammar as a base for other grammars that generate prompts for other parts of the simulation.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_46.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_46.txt
new file mode 100644
index 0000000..a26a97e
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_46.txt
@@ -0,0 +1,162 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```css
+<dungeon-prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+<type-name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<path-segment> ::= <dungeon-prompt> " a " <type-name> " with a " <verb> " doing " <place>
+<path-segment> ::= <dungeon-prompt> " in " <place>
+<path> ::= <path-segment> { "- and then" <path-segment> }
+```
+This grammar allows you to generate a path through the dungeon by specifying a series of `path-segment`s, each of which is introduced with a `dungeon-prompt`, followed by a `type-name`, and either an action to be performed or a location. You can string these segments together using the "and then" keyword to create a coherent path through the dungeon.
+
+For example, you might generate a prompt like this:
+```vbnet
+Imagine a weapon with a role-play doing the city - and then consider a spell with a program doing the dungeon - and then paint an artifact with a code doing platos cave
+```
+This prompt instructs the AI to imagine a weapon that is used in the city, followed by a spell that is programmed in the dungeon, and finally an artifact that is coded in Plato's cave. The path segments are connected using the "and then" keyword, creating a coherent path through the dungeon.
+
+You can customize this grammar to fit your specific needs by adding or removing types of path segments, adjusting the prompts used, and modifying the available verbs and places. With this grammar, you can generate a wide variety of prompts for creating a dungeon that are tailored to your desired level of detail and complexity.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_47.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_47.txt
new file mode 100644
index 0000000..b59f583
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_47.txt
@@ -0,0 +1,177 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```
+<prompt> ::= "Imagine" <verb_phrase> ";" <type_name> <determiner> <place>"."
+<verb_phrase> ::= <verb> ("doing" | "with") <verb>
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove"
+          | "create" | "design" | "analyse" | "lift" | "shift" | "splice"
+          | "quote" | "quasi-quote" | "quasi-quine-quote"
+          | "quasi-quine-quote-in-ocaml"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act"
+          | "meta-quote"
+<type_name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure"
+              | "monster" | "quest" | "challenge" | "theme" | "drama"
+              | "music" | "art" | "secrets" | "occult" | "reveal"
+<determiner> ::= "a" | "an" | "the"
+<place> ::= <location> | <connection>
+<location> ::= "country" | "region" | "city" | "street" | "house"
+             | "building" | "dungeon" | "labyrinth" | "cave"
+             | "swamp" | "room" | "hallway" | "chest" | "bag"
+             | "wallet" | "vault" | "keep" | "throne room"
+<connection> ::= <location> "connected with" <location>
+```
+This grammar allows for prompts that include a verb phrase, a type of item or event in the dungeon, and a place. The verb phrase can be one of several different actions, such as "role-play" or "specify". The type of item or event can be things like "weapon", "spell", "monster", or "quest". The place can be a specific location or a connection between two locations.
+
+For example, a prompt generated from this grammar might look like:
+
+Imagine role-playing specifying a weapon with a magical sword in the entrance connected with the great hall.
+
+This prompt is asking the user to imagine a scenario where they are role-playing as someone who is specifying a magical sword in the entrance of the dungeon, which is connected to the great hall. The user can then use this prompt as inspiration to create that part of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_48.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_48.txt
new file mode 100644
index 0000000..0c6b733
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_48.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```less
+dungeon_prompt ::= "Imagine" "a" path
+path ::= entrance room* exit
+entrance ::= "the entrance" | "an entrance" | "entering the dungeon"
+room ::= place description? action?
+place ::= "room" | "area" | "chamber"
+description ::= "with a" type_name
+action ::= "containing" verb | "guarding" verb
+type_name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge"
+verb ::= "trap" | "puzzle" | "riddle" | "obstacle" | "enemy"
+exit ::= "the exit" | "a way out" | "the end of the dungeon"
+```
+This grammar defines a `dungeon_prompt` which is composed of a `path`. A path consists of an `entrance`, followed by one or more `rooms`, and ending with an `exit`. The entrance can be described using various phrases, and each room is made up of a `place`, optionally followed by a `description` and/or an `action`. The place can also be described in different ways. A description consists of the word "with" followed by a `type_name`, while an action consists of either "containing" or "guarding" followed by a `verb`. The type\_names and verbs are predefined terms, such as "weapon", "spell", "trap", etc.
+
+This grammar can be used to generate prompts in the following format:
+
+* Imagine a path from the entrance to the exit of the dungeon
+* Consider an entrance connected with a room containing a trap
+* Draw a room with a treasure guarding a riddle
+* Paint a chamber with a monster and a puzzle
+
+You can use this grammar as a starting point and modify it according to your specific needs. You can also add more terms and phrases to make the prompts more diverse and interesting.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_49.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_49.txt
new file mode 100644
index 0000000..7b9d9e9
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_49.txt
@@ -0,0 +1,155 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```makefile
+prompt -> "Imagine" "a" type_name "that" verb "in" place
+type_name -> "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+verb -> "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyze" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+place -> "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+```
+This grammar can be used to generate prompts by expanding the non-terminals in the `prompt` production. For example, one possible prompt would be:
+```vbnet
+Imagine a treasure that role-play in the country
+```
+By varying the values of `type_name`, `verb`, and `place`, you can generate many different prompts to use for creating the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_50.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_50.txt
new file mode 100644
index 0000000..dd4723c
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_50.txt
@@ -0,0 +1,163 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+dungeon-prompt ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+type-name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+type-modifier ::= "random" | "specific"
+type-name-with-modifier ::= type-modifier " " type-name
+verb ::= "create" | "generate" | "design" | "program" | "prove"
+place ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "plato's cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+path-element ::= type-name-with-modifier " in" place
+path-segment ::= path-element {"," path-element} "; and then"
+path ::= path-segment {path-segment} "; finally arriving at the" type-name
+prompt ::= dungeon-prompt " a path through the dungeon from the entrance to the" path
+```
+This grammar allows for a variety of different prompts to be generated, with options for specifying random or specific types, adding modifiers to the type names, and using different verbs. The `place` non-terminal can be expanded to include more specific locations within each type of place (e.g. "the throne room" instead of just "the castle").
+
+For example, here are a few possible prompts that could be generated using this grammar:
+
+* "Consider creating a path through the dungeon from the entrance to the treasure, with a random artifact in the dark cavern and a specific monster in the dragon's lair."
+* "Imagine designing a path through the labyrinth from the entrance to the challenge, with a magic item in the enchanted forest and a random spell in the wizard's tower."
+* "Paint a path through the dungeon from the entrance to the treasure, with a specific weapon in the armory and a random monster in the goblin cave."
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_51.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_51.txt
new file mode 100644
index 0000000..7262c3f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_51.txt
@@ -0,0 +1,163 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```vbnet
+<prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+<path_segment> ::= <prompt> " an artist to design a comic book panel for a " <type_name> " in a " <verb> " style with a " <type_name2> "<path_segment>*
+<path> ::= <path_segment>+
+<dungeon> ::= "Create a path through the dungeon starting at the entrance and going all the way to the end: " <path> "\n"
+```
+This grammar allows for generating prompts that start with one of several verbs, followed by a type of item or feature in the dungeon (such as a weapon or a monster), which is then further described with additional details (such as being designed in a certain style or having a specific ability). The path through the dungeon is made up of multiple segments, each describing a different part of the dungeon.
+
+Here's an example of how this grammar might be used to generate a prompt:
+```less
+Create a path through the dungeon starting at the entrance and going all the way to the end:
+Imagine an artist to design a comic book panel for a treasure in a role-play style with a magical artifact,
+Consider a challenge with an obstacle course to overcome,
+Paint a scene of a hero journey with a final boss fight.
+```
+This prompt instructs the user to create a path through the dungeon that starts at the entrance and ends with a final boss fight. Along the way, the user will encounter a treasure guarded by a magical artifact, a challenging obstacle course, and a scene depicting the hero's journey to reach the end. Each segment of the path is described with a different verb (Imagine, Consider, Paint), type name (treasure, challenge, scene), and additional details (magical artifact, obstacle course, hero journey).
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_52.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_52.txt
new file mode 100644
index 0000000..a89db22
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_52.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+Path ::= PathComponent+
+
+PathComponent ::= Room | Corridor | Entrance | Exit
+
+Room ::= "Enter the room with " TypeName " and " Description
+
+Corridor ::= "Walk down the " Description " corridor until you reach a fork"
+
+Entrance ::= "You enter the dungeon through the " Description
+
+Exit ::= "You leave the dungeon through the " Description
+
+TypeName ::= Weapon | Spell | Artifact | MagicItem | Treasure | Monster | Quest | Challenge | Theme | Drama | Music | Art | Secret | Occult | Reveal | HeroJourney
+
+Description ::= (Adjective | Noun)+
+
+Adjective ::= "dark" | "narrow" | "twisting" | "damp" | "ancient" | "secret"
+
+Noun ::= "passageway" | "doorway" | "chamber" | "tunnel" | "cave" | "labyrinth" | "room" | "corridor"
+
+Weapon, Spell, Artifact, MagicItem, Treasure, Monster, Quest, Challenge, Theme, Drama, Music, Art, Secret, Occult, Reveal, HeroJourney ::= [a-zA-Z0-9\_]+
+
+This grammar generates a path through the dungeon by specifying a series of rooms and corridors that lead from the entrance to the exit. Each room is described using a type name (such as "weapon" or "spell") and a description, while each corridor has a description but no type name. The entrance and exit are also described using a description, but they do not have a type name or any further connections.
+
+By using this grammar to generate prompts for the language model, we can create a variety of different paths through the dungeon that include a wide range of different elements. This will help us to create an engaging and diverse game experience for players.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_53.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_53.txt
new file mode 100644
index 0000000..6d2df1e
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_53.txt
@@ -0,0 +1,167 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a path through a dungeon:
+
+path ::= path\_segment | ε
+
+path\_segment ::= "From" place\_name "go" direction\_name "to" place\_name
+
+place\_name ::= [a-zA-Z]+
+
+direction\_name ::= "north" | "south" | "east" | "west" | "up" | "down"
+
+ε ::= empty string
+
+This grammar defines a path as one or more path segments, where each segment consists of a starting place, a direction to move, and an ending place. The direction can be north, south, east, west, up, or down. Place names are made up of one or more alphabetic characters.
+
+Here is an example of how this grammar could be used to generate prompts:
+
+* From the entrance go north to the hallway
+* From the hallway go west to the chest
+* From the chest go up to the attic
+* From the attic go east to the treasure room
+
+This path starts at the entrance and goes through a hallway, a chest, an attic, and ends in a treasure room. The directions taken are north, west, up, and east.
+
+Of course, this is just one possible way to design a grammar for generating prompts for creating a dungeon. There are many other ways to do it, depending on the specific requirements and constraints of your project.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_54.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_54.txt
new file mode 100644
index 0000000..ba1d6f1
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_54.txt
@@ -0,0 +1,176 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon\_prompt ::= "Imagine", place, "is the entrance of a dungeon."
+path ::= path\_segment*
+path\_segment ::= room | hallway | staircase | elevator
+room ::= "Consider", place, "as a room with", description
+description ::= object, verb, object | action
+object ::= noun | prop
+noun ::= weapon | spell | artifact | magic\_item | treasure | monster
+prop ::= adjective | condition
+adjective ::= "magical" | "cursed" | "blessed"
+condition ::= "damaged" | "locked" | "hidden"
+action ::= verb, place | verb, noun
+verb ::= "contains" | "blocks" | "leads to" | "guards" | "protects"
+hallway ::= "Consider", place, "as a hallway with", description
+staircase ::= "Consider", place, "as a staircase leading up or down."
+elevator ::= "Consider", place, "as an elevator leading up or down."
+place ::= noun | room\_name | hallway\_name | staircase\_name | elevator\_name
+room\_name ::= "room" number
+hallway\_name ::= "hallway" number
+staircase\_name ::= "staircase" number
+elevator\_name ::= "elevator" number
+number ::= one\_digit | two\_digits
+one\_digit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+two\_digits ::= one\_digit, one\_digit
+
+In this grammar, a dungeon prompt consists of an initial instruction to imagine a place as the entrance of the dungeon. The path through the dungeon is represented as a series of path segments, which can be rooms, hallways, staircases, or elevators. Each room has a description, which consists of one or more objects (nouns or props) with associated actions. Objects can be weapons, spells, artifacts, magic items, treasure, or monsters, and props can have adjectives such as "magical", "cursed", or "blessed", and conditions such as "damaged" or "hidden". Actions consist of verbs followed by places or objects.
+
+For example, a prompt generated from this grammar might look like:
+
+Imagine the entrance of the dungeon is room 1. Consider room 1 as a room with a sword containing magic energy that blocks the doorway to hallway 2. Consider hallway 2 as a hallway with a cursed chest locked at the end, leading to staircase 3. Consider staircase 3 as a staircase leading down to room 2. Consider room 2 as a room with a magical barrier protecting it from intruders.
+
+This prompt instructs the user to imagine the entrance of the dungeon as room 1, and then describes the path through the dungeon starting at room 1 and ending in room 2. Along the way, the user encounters various objects and props with associated actions, which help to flesh out the details of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_55.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_55.txt
new file mode 100644
index 0000000..708cfbb
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_55.txt
@@ -0,0 +1,172 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+<prompt> ::= "Imagine" <verb\_phrase> ";" <type\_name> <article> <place>"."
+
+<verb\_phrase> ::= <verb> ("doing" | "to create" | "for creating") <infinitive\_verb>
+
+<type\_name> ::= "a" (<adjective>)? ("weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult reveal" | "hero journey")
+
+<article> ::= ("the" | "a" | "an")
+
+<place> ::= <noun> (("of" | "in the") <place>) | <preposition> <place>
+
+<adjective> ::= ("interesting" | "magical" | "dangerous" | "mysterious" | "powerful" | "ancient" | "rare" | "unique" | "cursed" | "blessed")
+
+<verb> ::= ("draw" | "paint" | "compose" | "balance" | "design" | "role-play" | "specify" | "encode" | "program" | "prove" | "create" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote")
+
+<infinitive\_verb> ::= ("path" | "room" | "corridor" | "door" | "entrance" | "exit" | "trap" | "puzzle" | "enemy" | "reward" | "obstacle" | "event")
+
+<noun> ::= ("path" | "room" | "corridor" | "door" | "entrance" | "exit" | "trap" | "puzzle" | "enemy" | "reward" | "obstacle" | "event" | "dungeon")
+
+<preposition> ::= ("in" | "at" | "near" | "by" | "through" | "past" | "under" | "over" | "above" | "below" | "between" | "around" | "behind" | "next to" | "outside of" | "inside of")
+
+This grammar generates prompts that start with the word "Imagine", followed by a verb phrase, a type name, and a place. The verb phrase is made up of a verb followed by an infinitive verb. The type name is modified by an optional adjective, and the place is made up of a noun or a preposition followed by a place.
+
+For example, a prompt generated from this grammar might look like:
+
+Imagine drawing a dangerous treasure hidden in a secret room connected with a door in the dungeon.
+
+This prompt can be used to generate one element of the dungeon, a dangerous treasure hidden in a secret room that is connected to a door. By generating many prompts and combining the elements they describe, we can create a complete dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_56.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_56.txt
new file mode 100644
index 0000000..eabb03e
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_56.txt
@@ -0,0 +1,183 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon = "Dungeon" newline "{" room+ "}" newline
+
+room = "Room" identifier newline "{" path* "}" newline
+
+path = "Path" identifier (entrance | exit) direction
+
+entrance = "Entrance:" description
+
+exit = "Exit:" description
+
+direction = "North" | "South" | "East" | "West"
+
+identifier = [a-zA-Z\_]+
+
+description = "\"" text "\""
+
+text = (character)*
+
+character = any Unicode character except double quote or newline
+
+The grammar defines a dungeon as a collection of rooms, where each room has one or more paths leading to other rooms. Each path has an entrance and an exit, represented by the entrance and exit rules, respectively. The entrance and exit both have a description, which is enclosed in double quotes. The direction of each path is specified using one of the four cardinal directions: North, South, East, or West.
+
+This grammar can be used to generate prompts for creating a dungeon by expanding the non-terminals into specific values. For example, the following prompt could be generated using this grammar:
+```
+Dungeon {
+  Room1 {
+    Path Entrance: "A dark and ominous entrance" North
+    Path Exit: "A dimly lit corridor" South
+  }
+  Room2 {
+    Path Entrance: "A dimly lit corridor" East
+    Path Exit: "A large chamber with a roaring fire" West
+  }
+}
+```
+This prompt describes a dungeon with two rooms, connected by a path leading from the entrance of the first room to the exit of the second room. The entrance and exit of each path have a description that helps set the scene for the player. This is just one example of a prompt that could be generated using this grammar; there are many other possible combinations of rooms, paths, entrances, and exits that could be created using this grammar.
+
+Overall, this grammar provides a flexible way to generate prompts for creating a dungeon, allowing for a wide variety of different layouts and descriptions to be generated. It can be easily extended or modified to suit the specific needs of a particular application or use case.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_57.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_57.txt
new file mode 100644
index 0000000..d6d0242
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_57.txt
@@ -0,0 +1,171 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+<dungeon> ::= <path> | <room> | <treasure> | <monster>
+<path> ::= "From the entrance, you follow a winding corridor until you reach" <place> <action>
+<action> ::= "and encounter" | "."
+<room> ::= <description> "In this room," <event>
+<event> ::= "you find" | "there is"
+<treasure> ::= <description> "Hidden in a corner, you find a" <type_name>
+<monster> ::= <description> "A ferocious" <type_name> "jumps out at you!"
+<description> ::= <adjective> <noun>
+<adjective> ::= "dark" | "dank" | "musty" | "cold" | "slimy"
+<noun> ::= "corridor" | "room" | "passageway" | "chamber" | "cavern"
+<type_name> ::= <simple_type> | <complex_type>
+<simple_type> ::= "rat" | "goblin" | "troll" | "skeleton" | "zombie"
+<complex_type> ::= <simple_type> "with a" <special_quality>
+<special_quality> ::= <material> | <color> | <shape> | <ability>
+<material> ::= "of adamantium" | "made of mithril" | "forged from iron"
+<color> ::= "red" | "green" | "blue" | "black" | "white"
+<shape> ::= "with three heads" | "twisted into a knot" | "wrapped in chains"
+<ability> ::= "that can fly" | "that breathes fire" | "that is invisible"
+```
+This grammar defines the structure of a dungeon as a sequence of paths, rooms, treasures, and monsters. Each of these elements is further defined by a set of rules that specify what they consist of. For example, a `<path>` consists of a description of the path followed by an action taken at the end of the path. An `<action>` can be either "and encounter" or just ".", indicating whether there is anything interesting at the end of the path.
+
+A `<room>` consists of a description of the room, followed by an event that occurs in the room. An `<event>` can be "you find" or "there is", indicating whether something is found or just present in the room. A `<treasure>` and `<monster>` are similar to each other, both consisting of a description followed by the type of treasure or monster that is encountered.
+
+A `<description>` consists of an adjective and a noun, where the adjective describes some quality of the noun. For example, "dark corridor" or "musty room". A `<type_name>` can be either a simple type such as "rat" or "goblin", or a complex type that includes an additional special quality. A `<special_quality>` can be a material, color, shape, or ability, each of which adds more detail to the type name.
+
+Overall, this grammar provides a structured way to generate prompts for creating a dungeon, with a consistent format and plenty of opportunities for variation and customization.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_58.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_58.txt
new file mode 100644
index 0000000..b7a3a0f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_58.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+Path ::= PathElement*
+
+PathElement ::= Room | Corridor | Entrance | Exit
+
+Room ::= "Enter the room named " Name
+
+Corridor ::= "Follow the corridor leading to " (Name | Direction)
+
+Entrance ::= "Start at the entrance of the dungeon"
+
+Exit ::= "Exit through the exit leading to " Location
+
+Name ::= [a-zA-Z]+
+
+Direction ::= "north" | "south" | "east" | "west"
+
+Location ::= "the surface" | "another level of the dungeon"
+
+This grammar defines a path as one or more elements, where each element can be a room, corridor, entrance, or exit. Rooms and corridors have names, while the entrance and exit refer to specific points in the dungeon. The direction and location elements help describe how to get from one part of the dungeon to another.
+
+This is just an example grammar, and it can be expanded or modified as needed to generate more complex prompts for creating a dungeon. For example, you could add elements for traps, monsters, treasures, and other features that might be found in a dungeon. You could also include more detailed descriptions of the rooms, corridors, and other elements to help create a more immersive experience for players.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_59.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_59.txt
new file mode 100644
index 0000000..53edfef
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_59.txt
@@ -0,0 +1,175 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```ruby
+<prompt> ::= "Imagine you are building a dungeon with the following context:"
+             "<context>"
+             "Generate " <number> " variants."
+
+<context> ::= "Verb: " <verb> "; Type Name: " <type_name> "; Place: " <place>
+
+<number> ::= <digit> { <digit> }
+
+<digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+
+<verb> ::= "explore" | "search" | "battle" | "avoid" | "solve"
+
+<type_name> ::= "room" | "corridor" | "chamber" | "passage"
+
+<place> ::= <location> { " connected to " <location> }
+
+<location> ::= "the entrance" | "a dead end" | "a secret door" |
+                "a treasure chest" | "a monster den" | "a puzzle room"
+```
+This grammar describes the structure of a prompt, which consists of an initial sentence followed by the context for generating variants. The context includes a verb that describes the action being taken in the dungeon, a type name that specifies what kind of location is being created, and a place that indicates where the location is in relation to other locations in the dungeon. The prompt ends with a request to generate a specific number of variant descriptions.
+
+The grammar also includes productions for generating the various elements of the context, such as verbs, type names, and places. These productions can be used to generate different values for each context element, resulting in a wide range of possible prompts.
+
+For example, using this grammar, you could generate a prompt like this:
+```vbnet
+Imagine you are building a dungeon with the following context:
+Verb: explore; Type Name: corridor; Place: the entrance connected to a secret door
+Generate 3 variants.
+```
+This prompt instructs the language model to generate three variant descriptions of a corridor that can be explored from the entrance and leads to a secret door. The language model could use its knowledge of dungeons, fantasy role-playing games, and other relevant concepts to generate creative and diverse descriptions of this location.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_60.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_60.txt
new file mode 100644
index 0000000..2fec185
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_60.txt
@@ -0,0 +1,184 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```
+<prompt> ::= "Imagine" <dungeon_path> <verbs>
+
+<dungeon_path> ::= "a path through the dungeon from the entrance to the end"
+                 | "<dungeon_path> and then through a <place>"
+
+<place> ::= "corridor"
+          | "room"
+          | "chamber"
+          | "labyrinth"
+          | "maze"
+          | "passageway"
+          | "tunnel"
+
+<verbs> ::= <verb_phrase>
+           | <verbs> <verb_phrase>
+
+<verb_phrase> ::= "where you will" <verb>
+                  | "where you encounter" <verb>
+                  | "where you meet" <verb>
+
+<verb> ::= "fight"
+         | "battle"
+         | "confront"
+         | "explore"
+         | "discover"
+         | "search"
+         | "navigate"
+```
+This grammar defines a prompt as a combination of a dungeon path and a series of verbs that describe actions taken along the path. The dungeon path is defined recursively, with each place on the path being followed by another place, until the end of the dungeon is reached. Places include corridors, rooms, chambers, labyrinths, mazes, passageways, and tunnels.
+
+The verbs that describe actions taken along the path are defined as a series of verb phrases, each of which consists of a verb followed by one of several prepositional phrases (e.g., "where you will fight", "where you encounter battle", etc.). The verbs themselves include fight, battle, confront, explore, discover, search, and navigate.
+
+This grammar can be used to generate prompts for creating a dungeon by recursively expanding the <dungeon\_path> nonterminal using the production rules defined above. For example, the following prompt could be generated:
+```
+Imagine a path through the dungeon from the entrance to the end where you will fight in a corridor and then explore in a room and then confront in a chamber and then search in a labyrinth and then navigate in a maze and then battle in a passageway and then discover in a tunnel and then meet at the end.
+```
+This prompt describes a path through the dungeon that includes several places where different actions can be taken, such as fighting in a corridor or navigating in a maze. The language model can use this prompt to generate descriptions of each place on the path and the actions that take place there, creating a rich and detailed dungeon.
+
+Note that this is just one example of an EBNF grammar for generating prompts for creating a dungeon, and many other grammars are possible. The key is to define a set of rules that can be used to generate prompts that describe a path through the dungeon and the actions that take place along the way. These prompts can then be used to guide the language model in generating descriptions of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_61.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_61.txt
new file mode 100644
index 0000000..1541c73
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_61.txt
@@ -0,0 +1,167 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```css
+prompt ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+type_name ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+type_modifier ::= "simple" | "complex" | "rare" | "epic" | "boss"
+adjective ::= any descriptive word
+verb ::= "create" | "design" | "describe" | "draw" | "paint" | "compose" | "balance"
+place ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+place_modifier ::= "dark" | "lit" | "secret" | "hidden" | "locked" | "trapped"
+direction ::= "north" | "south" | "east" | "west" | "up" | "down"
+connective ::= "connected to" | "leading to" | "opening into" | "exiting into"
+
+prompt_template ::= prompt " a " type_name (type_modifier | "") (adjective | "") " " verb " in the " place (place_modifier | "") (direction | "") " " connective " the " place (place_modifier | "");
+```
+This grammar allows for the generation of prompts that ask the user to imagine, consider, draw, paint, compose or balance a specific type of thing with certain properties in a given place, connected to another place. The type of thing can be modified by an adjective and a type modifier, such as "simple" or "epic". The place can also be modified by a place modifier, such as "hidden" or "trapped", and the direction indicates the relative location of the next place in the dungeon.
+
+Here is an example of how this grammar could be used to generate a prompt for creating a simple, glowing weapon in a dark cave connected to a hidden room:
+```vbnet
+Imagine a simple, glowing weapon create in the dark cave connected to the hidden room.
+```
+And here's an example of how this grammar could be used to generate a prompt for designing a complex, cursed monster in a secret dungeon level:
+```vbnet
+Consider a complex, cursed monster design in the secret dungeon level connected to the entrance.
+```
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_62.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_62.txt
new file mode 100644
index 0000000..b23b6ab
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_62.txt
@@ -0,0 +1,160 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```markdown
+<path> ::= <room> { "<direction>" <room> }
+<room> ::= <description>
+<direction> ::= "north" | "south" | "east" | "west"
+<description> ::= <type_name> [ "with a" <type_name> ] [ "connected to" <place> ]
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey"
+<place> ::= <location> [ "connected with" <location> ]
+<location> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout"
+```
+This grammar defines a `<path>` as starting with a `<room>`, which is the description of the current location, followed by zero or more pairs of a `<direction>` and another `<room>`. A `<direction>` can be "north", "south", "east" or "west".
+
+A `<room>` is defined as a `<description>`, which is the name of a type (e.g. "weapon"), optionally followed by "with a" and another type, and optionally followed by "connected to" and a `<place>`. A `<place>` is defined as a `<location>`, which can be connected with another `<location>`.
+
+This grammar allows you to generate prompts for creating a dungeon by following a path from the entrance to the end, describing each room along the way. You can also include additional information in the rooms and places, such as connections between them or special features of the location.
+
+You can use this grammar to generate a wide variety of prompts for your language model, allowing you to create many different dungeons with unique features and challenges. You can also modify the grammar to suit your specific needs, adding or removing elements as necessary to create the perfect dungeon for your game.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_63.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_63.txt
new file mode 100644
index 0000000..a39a82b
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_63.txt
@@ -0,0 +1,167 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```
+<dungeon> ::= <path> | <room> | <treasure> | <monster>
+
+<path> ::= "From the entrance, you follow a winding path through" <place> "and arrive at"
+          (<room> | <path>)
+
+<room> ::= "<description of room>"
+
+<treasure> ::= "As you explore further, you come across a chest containing"
+             "<description of treasure>"
+
+<monster> ::= "Suddenly, you are confronted by a fearsome" <monster-type>
+             "that demands your attention!"
+
+<monster-type> ::= "goblin" | "troll" | "dragon" | ...
+
+<description of room> ::= "<any descriptive text about the room>"
+
+<description of treasure> ::= "<any descriptive text about the treasure>"
+```
+This grammar defines a `dungeon` as being made up of a series of `path`s, `room`s, `treasure`s, and `monster`s. Each of these elements can be described with any text that fits their corresponding non-terminal symbol (e.g., `<description of room>` for a `room`). The `path` non-terminal includes the use of other non-terminals to create a more complex structure, including a recursive call to itself to allow for multiple paths or rooms to be connected.
+
+This is just an example grammar, and it can be adjusted and expanded upon as needed to fit the specific needs of your dungeon generator.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_64.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_64.txt
new file mode 100644
index 0000000..340e6d1
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_64.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon\_path ::= path\_segment\_list
+
+path\_segment\_list ::= path\_segment | path\_segment path\_segment\_list
+
+path\_segment ::= enter\_room | exit\_room | move\_through\_room
+
+enter\_room ::= "Enter the " room\_description "."
+
+exit\_room ::= "Exit the " room\_description " through the " exit\_description "."
+
+move\_through\_room ::= "Move through the " room\_description " to the " adjacent\_room\_description "."
+
+room\_description ::= adjective\_list noun
+
+adjective\_list ::= "" | adjective | adjective adjective\_list
+
+adjecive ::= "dark" | "dimly-lit" | "cramped" | "spacious" | "empty" | "crowded" | "dangerous" | "safe" | ...
+
+noun ::= "room" | "chamber" | "corridor" | "hallway" | "passage" | "labyrinth" | "maze" | ...
+
+exit\_description ::= "door" | "gate" | "portal" | "tunnel" | "staircase" | "elevator" | "teleporter" | ...
+
+adjacent\_room\_description ::= room\_description | room\_description " connected to the " room\_description
+
+This grammar defines a dungeon path as a list of path segments. A path segment can be an enter\_room, exit\_room, or move\_through\_room statement. The enter\_room and exit\_room statements describe entering or exiting a room, respectively, while the move\_through\_room statement describes moving from one room to another through a connecting passage.
+
+The room\_description defines the type of room using an adjective list followed by a noun. The adjective list can contain any number of adjectives separated by spaces, and the noun specifies the type of room. The exit\_description and adjacent\_room\_description follow similar patterns.
+
+This grammar can be used to generate prompts for creating a dungeon by randomly selecting elements from each non-terminal in the grammar and concatenating them together. For example, a prompt generated using this grammar might look like:
+
+"Enter the dimly-lit maze. Move through the spacious corridor to the crowded hallway connected to the safe room. Exit the safe room through the door."
+
+This prompt can then be used as input to a language model or other system to generate more detailed descriptions of the dungeon, including any objects, monsters, or treasures that might be found there.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_65.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_65.txt
new file mode 100644
index 0000000..04b47fb
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_65.txt
@@ -0,0 +1,173 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a path through a dungeon:
+```css
+<path> ::= <segment>+
+
+<segment> ::= <entrance> | <hallway> | <room> | <challenge> | <treasure> | <exit>
+
+<entrance> ::= "Imagine the entrance to the dungeon with a {type_name}."
+
+<hallway> ::= "Consider a hallway leading from {place1} to {place2} with a {type_name} in it."
+
+<room> ::= "Draw a room with {type_name}s at {place1}, {place2}, and {place3}."
+
+<challenge> ::= "Paint a {type_name} that players must overcome at {place}."
+
+<treasure> ::= "Compose a description of a valuable {type_name} located at {place}."
+
+<exit> ::= "Balance the design of the exit from the dungeon with a {type_name} nearby."
+```
+In this grammar, `{type_name}` is a placeholder for any type of object or obstacle in the dungeon (e.g. weapon, monster, quest), and `{place1}`, `{place2}`, and `{place3}` are placeholders for locations within the dungeon. The grammar allows for multiple segments to be combined to create a path through the dungeon.
+
+To generate prompts using this grammar, you can replace the placeholders with specific terms from your list of type names, places, and verbs. For example:
+```less
+Imagine the entrance to the dungeon with a weapon.
+Consider a hallway leading from the city to the street with a spell in it.
+Draw a room with artifacts at the country, the region, and the city.
+Paint a monster that players must overcome at the dungeon.
+Compose a description of a valuable magic item located at the vault.
+Balance the design of the exit from the dungeon with a treasure nearby.
+```
+You can also add additional rules to the grammar to include more complex elements in the prompts, such as NPCs or puzzles that players must interact with. The important thing is to be creative and flexible in how you use the context provided by the type names, places, and verbs to generate prompts for creating a rich and varied dungeon experience.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_66.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_66.txt
new file mode 100644
index 0000000..c8065c8
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_66.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```
+<prompt> ::= "Imagine a " <type_name> " in a " <place>, " with " <description>
+<type_name> ::= "dungeon" | "room" | "monster" | "treasure" | "artifact" | "quest"
+<place> ::= <location> | <connection>
+<location> ::= "country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout"
+<connection> ::= <location> " connected to " <location>
+<description> ::= <adjective_list> " " <verb_phrase>
+<adjective_list> ::= <adjective> ( "," <adjective> )*
+<adjective> ::= "dark" | "twisty" | "dangerous" | "magical" | "hidden" | "mysterious"
+<verb_phrase> ::= "full of " <noun_list>
+<noun_list> ::= <noun> ( "," <noun> )*
+<noun> ::= "traps" | "puzzles" | "monsters" | "treasure" | "artifacts" | "secrets" | "occult knowledge" | "reveals"
+```
+This grammar allows for the generation of prompts that describe a specific type of thing (e.g. dungeon, room, monster) in a specific location, with a description consisting of a list of adjectives and a verb phrase. The location can be a single place or a connection between two places.
+
+You could use this grammar to generate prompts for creating a dungeon by randomly selecting a type name, place, and set of adjectives and nouns from predefined lists, then constructing the prompt using the grammar rules. For example, the following prompt would be generated using this grammar:
+
+"Imagine a dungeon in a dark swamp, with a dangerous labyrinth connected to a hidden cave, full of traps, puzzles, and monsters."
+
+You could also modify the grammar to add more variations or details to the prompts. For example, you could add rules for generating descriptions of the appearance, behavior, or history of monsters or artifacts.
+
+I hope this helps! Let me know if you have any questions or need further clarification.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_67.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_67.txt
new file mode 100644
index 0000000..52ed3ef
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_67.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```less
+<dungeon-prompt> ::= "Imagine a path through the dungeon from the entrance"
+                      "to the end, with the following context:"
+                      <context>
+                      <path-segment>*
+                      "What is the final treasure at the end of this path?"
+
+<context> ::= <verb-phrase> ";" <type-name> ";" <place>
+
+<verb-phrase> ::= "Verb: " <verb>
+
+<type-name> ::= <term> | <term> " with a " <term>
+
+<place> ::= <term> | <term> " connected to " <term>
+
+<path-segment> ::= "Entering the" <description> ","
+                   "there is a fork in the path, one leading"
+                   <direction>, "the other leading" <opposite-direction> ","
+                   <choice>
+
+<description> ::= <term> | <term> " decorated with" <term>
+
+<direction> ::= "left" | "right"
+
+<opposite-direction> ::= <direction> ^ "'s opposite"
+
+<choice> ::= <verb-phrase> ","
+              "take the" <direction> "path, or"
+              <verb-phrase> ","
+              "take the" <opposite-direction> "path"
+```
+This grammar includes rules for generating a prompt that describes a path through the dungeon from the entrance to the end, with different types of obstacles and challenges along the way. It includes rules for generating verb phrases, type names, places, and descriptions of each segment of the path. The grammar also includes rules for generating choices that the player must make as they navigate the path.
+
+This is just one example of a possible grammar, and it can be adjusted and expanded to fit the specific needs of your project.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_68.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_68.txt
new file mode 100644
index 0000000..dfcab1a
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_68.txt
@@ -0,0 +1,177 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+```css
+path ::= [room | hallway | corridor] { - "to" - [room | hallway | corridor] }
+
+room ::= "the entrance" | "the treasure room" | "the boss room" | "a side room"
+
+hallway ::= "the main hallway" | "a side hallway"
+
+corridor ::= "a long corridor" | "a short corridor"
+```
+This grammar allows for the generation of a path through the dungeon that starts at the entrance and goes through a series of rooms, hallways, and corridors. Each room, hallway, or corridor can be connected to another using the "-to-" keyword. The grammar also includes specific names for different types of rooms, hallways, and corridors, but these could be expanded or changed as desired.
+
+In this grammar `[` and `]` denotes optionality, `{}` zero or more repetitions, `-` means that the keyword should not be included in the generated string.
+
+This is just an example you can make changes to it to fit your needs.
+
+You could also expand the grammar to include other elements of a dungeon such as treasure, monsters, and quests. For instance:
+```css
+path ::= [room | hallway | corridor] { - "to" - [room | hallway | corridor] }
+
+room ::= "the entrance" | "the treasure room" | "the boss room" | "a side room"
+         { - "contains" - [treasure | monster | quest ] }
+
+hallway ::= "the main hallway" | "a side hallway"
+
+corridor ::= "a long corridor" | "a short corridor"
+
+treasure ::= "a chest filled with gold" | "a hidden stash of gems"
+
+monster ::= "a fearsome dragon" | "a pack of goblins"
+
+quest ::= "the quest for the holy grail" | "the search for the lost city"
+```
+In this way you can generate different elements of your dungeon, and combine them to make a complete dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_69.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_69.txt
new file mode 100644
index 0000000..f2f8c5c
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_69.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```css
+path ::= (room | hallway | corridor | chamber) +
+
+room ::= "the" room_name ("is full of" description)? ("," | ";")?
+
+hallway ::= "the" hallway_name ("connects" room1 "to" room2)? ("," | ";")?
+
+corridor ::= "the" corridor_name ("turns left to" hallway | "turns right to" hallway | "leads to" room)? ("," | ";")?
+
+chamber ::= "the" chamber_name ("has a" description)? ("," | ";")?
+
+room_name, hallway_name, corridor_name, chamber_name ::= <any valid name for a room, hallway, corridor or chamber>
+
+description ::= <a short description of the room, such as "dimly lit", "crowded with monsters", etc.>
+```
+This grammar allows you to generate a sequence of rooms, hallways, corridors and chambers that make up a path through a dungeon. Each room, hallway, corridor or chamber is represented by its name, and can have an optional description. Rooms and chambers can be connected by hallways and corridors, which also have names and optional descriptions.
+
+You can use this grammar to generate prompts for creating the rooms, hallways, corridors and chambers in your dungeon, as well as their connections and descriptions. For example, you could generate a prompt like this:
+```vbnet
+"Imagine the following room: The entrance is dimly lit and has a large wooden door. Now imagine the next room: The main hall is full of torches and has a high ceiling."
+```
+You can then use the language model to generate descriptions for each room, hallway, corridor or chamber based on the prompt, and combine them to create a complete dungeon path.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_70.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_70.txt
new file mode 100644
index 0000000..4168c64
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_70.txt
@@ -0,0 +1,161 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+dungeon_path = { room | corridor } ;
+room = "Enter a room with " type_name ", which is connected to " { place | monster } ;
+corridor = "Walk down the " description " corridor, which leads to " place ;
+type_name = weapon | spell | artifacts | magic_items | treasure | monster | quest | challenge ;
+place = the_country | the_region | the_city | the_street | the_house | the_building | the_dungeon | the_labyrinth | the_cave | the_swamp | the_room | the_hallway | the_chest | the_bag | the_wallet | the_vault | the_keep | the_hideout | platos_cave | garden_of_eden | the_river_styx | the_restaurant_at_the_end_of_the_universe ;
+monster = a_ " " { adjective } " " monster_name ;
+description = { adjective } " " noun ;
+
+%token <string> weapon spell artifacts magic_items treasure monster quest challenge the_country the_region the_city the_street the_house the_building the_dungeon the_labyrinth the_cave the_swamp the_room the_hallway the_chest the_bag the_wallet the_vault the_keep the_hideout platos_cave garden_of_eden the_river_styx the_restaurant_at_the_end_of_the_universe
+%token <string> a_ adjective monster_name noun ;
+```
+This grammar defines a dungeon path as a sequence of rooms and corridors. A room is defined as entering a room with a certain type of object, which is connected to one or more places or monsters. A corridor is defined as walking down a described corridor, which leads to a certain place. The type\_name token can be any of the following: weapon, spell, artifacts, magic\_items, treasure, monster, quest, or challenge. The place token can be any of the predefined places in the game. The monster token is defined as an "a" followed by one or more adjectives and a monster name. The description token is defined as one or more adjectives followed by a noun.
+
+This grammar could be used to generate prompts for creating a dungeon by generating a sequence of room and corridor tokens according to the rules defined in the grammar. For example, a prompt generated from this grammar might look like: "Enter a room with a weapon, which is connected to the city. Walk down the dark corridor, which leads to the river styx."
+
+I hope this helps! Let me know if you have any other questions.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_71.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_71.txt
new file mode 100644
index 0000000..ef123bb
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_71.txt
@@ -0,0 +1,192 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= {room}
+
+room ::= "You are in a" room\_type room\_description "." path
+
+path ::= {path\_segment}
+
+path\_segment ::= "Go" direction "to" next\_room
+
+room\_type ::= "small" | "medium" | "large" | "secret"
+
+room\_description ::= description\_verb verb\_phrase
+
+description\_verb ::= "The" | "There is" | "You see"
+
+verb\_phrase ::= noun\_phrase {conjunction noun\_phrase}
+
+noun\_phrase ::= article noun {preposition noun}
+
+article ::= "a" | "an" | "the"
+
+noun ::= (adjective | determiner) noun\_base
+
+determiner ::= "some" | "a few" | "many" | "all" | "no" | "none"
+
+adjective ::= adjective\_base | {adverb adjective\_base}
+
+adverb ::= "extremely" | "very" | "slightly" | "barely" | "not"
+
+noun\_base ::= dungeon\_feature | dungeon\_monster | dungeon\_object
+
+dungeon\_feature ::= "passage" | "corridor" | "staircase" | "door" | "archway"
+
+dungeon\_monster ::= "goblin" | "troll" | "skeleton" | "zombie" | "dragon"
+
+dungeon\_object ::= "chest" | "table" | "throne" | "altar" | "bed"
+
+conjunction ::= "and" | "or" | "but"
+
+direction ::= "north" | "south" | "east" | "west"
+
+This grammar generates a series of rooms, each with a type and a description. The description is generated by selecting a verb phrase from the list of possible verbs and noun phrases, and concatenating them together with conjunctions as necessary. Each room has a path leading to one or more other rooms, which are selected based on their proximity and connection to the current room.
+
+This grammar can be used to generate prompts for creating a dungeon by randomly selecting elements from each category and combining them according to the rules of the grammar. For example, a prompt generated from this grammar might look like:
+
+"You are in a small, dimly-lit room with stone walls and a damp, musty smell. There is a rickety wooden table in the center of the room, covered in dust and cobwebs. To the north, there is a narrow passage leading to a secret room with a glowing crystal. To the east, there is a sturdy door made of oak and iron. Which way do you go?"
+
+By varying the elements selected from each category, this grammar can be used to generate an infinite variety of prompts for creating dungeons.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_72.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_72.txt
new file mode 100644
index 0000000..72b69a8
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_72.txt
@@ -0,0 +1,155 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating a path through a dungeon:
+```css
+<path> ::= <room> | <path> -> <room>
+<room> ::= "entrance" | "chest" | "monster's lair" | ...
+<action> ::= "fight" | "open" | "explore" | ...
+<prompt> ::= "Imagine a path from the " <room> " to the next room, where you need to " <action> "."
+```
+This grammar defines a `<path>` as either a single `<room>` or a sequence of connected rooms. A `<room>` can be any type of location within the dungeon (e.g. "entrance", "chest", "monster's lair"). An `<action>` is an action that the player must take in order to progress through the dungeon (e.g. "fight", "open", "explore"). A `<prompt>` is a text prompt that can be used to generate a description of the path, which includes the starting and ending rooms as well as the required action.
+
+This grammar can be used in conjunction with the provided code to generate prompts for creating a dungeon. For example, using this grammar, the following prompt could be generated: "Imagine a path from the entrance to the chest, where you need to open it."
+
+Note that this is just one possible way of defining a grammar for generating prompts in this context. Depending on the specific requirements of your dungeon generator and language model, you may want to modify or expand upon this grammar as needed.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_73.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_73.txt
new file mode 100644
index 0000000..cbd284c
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_73.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```
+dungeon = {path}+ .
+
+path = entrance room* treasure? exit .
+
+entrance = "the entrance" .
+
+room = "a room" | "the room" | "a hallway" | "the hallway" .
+
+treasure = "a treasure chest" | "a sack of gold" | "a magical artifact" .
+
+exit = "an exit" | "the exit" .
+```
+This grammar defines a dungeon as one or more paths, where each path starts at the entrance and ends at an exit. A path is made up of a series of rooms, with optional treasure in some of the rooms. The entrance and exit are special types of rooms.
+
+To use this grammar to generate prompts, you could randomly select a production from each non-terminal symbol, and concatenate them together to form a prompt. For example, using the above grammar, here is one possible prompt:
+```
+"Imagine the entrance to a dungeon, followed by a room with a treasure chest, then another room with no treasure, and finally an exit."
+```
+You could generate many such prompts, each describing a different path through the dungeon. This would allow you to create a large number of diverse paths, which could be used to build a rich and varied dungeon.
+
+Of course, this is just one possible grammar for generating prompts for creating a dungeon. You could use different symbols, productions, and rules to suit your specific needs. The important thing is to have a formal way of describing the structure of the prompts, so that you can generate them automatically using a computer program.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_74.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_74.txt
new file mode 100644
index 0000000..0e3b305
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_74.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon> ::= <path>+
+
+<path> ::= <room> <direction> <next_room> | <entrance> <direction> <room>
+
+<room> ::= "the " <description>
+
+<description> ::= <adjective>* <noun>
+
+<adjective> ::= "dark" | "damp" | "cramped" | "spacious" | "dusty" | "secret"
+
+<noun> ::= "room" | "chamber" | "corridor" | "passage" | "cavern" | "tunnel"
+
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+
+<entrance> ::= "the entrance" | "the main hall" | "the foyer" | "the lobby"
+
+<next_room> ::= <room> | <entrance>
+```
+This grammar defines a dungeon as a series of connected rooms, with the path through the dungeon starting at the entrance and leading to one or more exits. Each room is described using a combination of adjectives and nouns, and can be connected to other rooms via a set of predefined directions. The `<entrance>` non-terminal allows for multiple entry points into the dungeon, while the `<next_room>` non-terminal can represent either a regular room or one of the entrances.
+
+This grammar can be used to generate prompts for creating the dungeon by randomly selecting elements from each non-terminal and concatenating them together. For example, a prompt generated using this grammar might look like:
+```vbnet
+Imagine the dark passage north of the cramped room with a secret entrance leading to the damp chamber to the east. What is your response?
+```
+By generating multiple prompts using this grammar, we can create a diverse set of descriptions for the dungeon that capture different aspects of its layout and atmosphere.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_75.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_75.txt
new file mode 100644
index 0000000..f582e50
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_75.txt
@@ -0,0 +1,179 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```rust
+<prompt> ::= "Imagine a" <path-description> <object-description>
+
+<path-description> ::= "path from the" <place> "to the" <destination>
+                      | "journey from the" <place> "through" <intermediate-places> "to the" <destination>
+
+<object-description> ::= "with a" <type-name> "<verb>"
+
+<place> ::= "entrance" | "exit" | "room" | "corridor" | "stairs" | "door"
+
+<destination> ::= "boss room" | "treasure room" | "end of the dungeon"
+
+<intermediate-places> ::= <place> ("," <place>) *
+
+<type-name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+                     | "monster" | "quest" | "challenge" | "theme" | "drama"
+                     | "music" | "art" | "secret" | "occult reveal" | "hero journey"
+
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove"
+          | "create" | "design" | "create descriptions for an artist"
+          | "create descriptions for an artist to design a comic book panel"
+          | "analyse" | "lift" | "shift" | "splice" | "quote"
+          | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-run"
+          | "meta-program" | "generate" | "simulate"
+```
+This grammar can be used to generate prompts for creating a dungeon by combining different elements from the nonterminals. For example, a prompt could be generated by selecting a path description (e.g. "journey from the entrance through the corridors and stairs to the boss room"), an object description (e.g. "with a weapon 'attack'"), and substituting the selected elements into the `<prompt>` nonterminal.
+
+This is just one possible grammar, and it can be adjusted or expanded as needed to generate the desired prompts.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_76.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_76.txt
new file mode 100644
index 0000000..1cce09f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_76.txt
@@ -0,0 +1,162 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= (path | room | treasure | monster)+
+path ::= "Go" [direction] "and" [description]
+direction ::= "north" | "south" | "east" | "west" | "up" | "down"
+description ::= "through" [room\_name]
+room ::= "Enter" [room\_name]
+room\_name ::= [alpha]\*
+treasure ::= "Find" [treasure\_name]
+treasure\_name ::= [alpha]\*
+monster ::= "Encounter" [monster\_name]
+monster\_name ::= [alpha]\*
+alpha ::= "a" ... "z" | "A" ... "Z"
+
+This grammar allows for generating prompts that lead the player through a dungeon, describing different paths, rooms, treasures, and monsters they might encounter. The \[\] symbols denote optional elements, and the | symbol represents alternatives. For example, path consists of either "Go" followed by a direction and "and" or just "Go" and "and". Room\_name, treasure\_name, and monster\_name are made up of any combination of letters.
+
+You can use this grammar to generate prompts for creating the dungeon by expanding the non-terminals (symbols on the left side of the ::=) until you reach terminal symbols (symbols on the right side of the ::=). For example, a possible expansion of the non-terminal path could be "Go north and through the entrance chamber".
+
+The grammar can also be used to generate different types of prompts by adding new non-terminals. For example, you could add a non-terminal for combat encounters or traps in the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_77.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_77.txt
new file mode 100644
index 0000000..020d14b
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_77.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon-prompt> ::= "Imagine a path through the dungeon from the entrance to the end, with the following context:"
+                      <context-list>
+                      "; What is your response? Please generate variant array of size"
+                      <count>
+                      "."
+<context-list> ::= <context> { "," <context> }
+<context> ::= <verb> "doing" <type> "with a" <property> <place1> "connected with" <place2>
+<type> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult reveal"
+<property> ::= <adjective> { "and" <adjective> }
+<adjective> ::= "dangerous" | "magical" | "rare" | "powerful"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" |
+                "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" |
+                "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" |
+                "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+<place1> ::= <place> | "the entrance"
+<place2> ::= <place> | "the end"
+<place> ::= "room" | "hallway" | "staircase" | "chamber" | "labyrinth" | "maze" | "passage" | "tunnel" | "corridor" | "gallery" | "vestibule"
+<count> ::= <number> { "to the power of" <number> }
+<number> ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10"
+```
+This grammar allows for generating prompts with a list of contexts, where each context specifies a verb, a type of object or challenge in the dungeon, an optional property of that object or challenge, and two places connected by the object or challenge. The grammar also includes the option to specify the number of variants desired, allowing for multiple prompts with different configurations to be generated at once.
+
+In this example, I have used non-terminals such as `<verb>`, `<type>`, and `<place>` which can be further expanded into more detailed grammar rules based on the requirement of the dungeon simulation.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_78.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_78.txt
new file mode 100644
index 0000000..c36fdfd
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_78.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon = {path}*
+path = entrance room* exit
+entrance = "Imagine the entrance of the dungeon"
+exit = "Imagine the exit of the dungeon"
+room = 
+ "Consider a room in the dungeon"
+ / "Draw a room in the dungeon"
+ / "Paint a room in the dungeon"
+ / "Compose a room in the dungeon"
+ / "Balance a room in the dungeon"
+
+The grammar uses the following notation:
+
+* {} denotes zero or more repetitions of the preceding element
+* | denotes a choice between two or more alternatives
+
+This grammar allows for multiple paths through the dungeon, each starting at the entrance and ending at the exit. Each path is made up of a series of rooms. For each room, the user can choose to imagine, consider, draw, paint, compose, or balance it. The user can also add additional constraints to the prompt by specifying the type of room (e.g., a "treasure" room), the presence of certain objects or monsters in the room, or other details.
+
+For example, using this grammar, a possible prompt for creating a room could be:
+
+Imagine a room in the dungeon with a treasure chest and a monster guarding it. The room should be designed to challenge the player's combat skills.
+
+This prompt specifies that the room should contain a treasure chest and a monster, and that it should be designed to be challenging for the player in terms of combat. It does not specify any additional details about the appearance or layout of the room, leaving those decisions up to the user's imagination.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_79.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_79.txt
new file mode 100644
index 0000000..a9522b4
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_79.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```makefile
+dungeon-prompt ::= "Imagine" "a" type-name
+                    ("," type-name)*
+                    "path"
+                    "from" "the" start-place
+                    "to" "the" end-place
+                    ";"
+
+type-name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+             | "monster" | "quest" | "challenge" | "theme" | "drama"
+             | "music" | "art" | "secrets" | "occult" | "reveal"
+             | "hero journey"
+
+start-place ::= "entrance" | "gate" | "portal" | "door"
+
+end-place ::= "boss room" | "final boss" | "exit" | "treasure room"
+```
+This grammar defines a `dungeon-prompt` rule, which is the top-level rule for generating prompts. It consists of an "Imagine" keyword followed by a list of one or more type names, separated by commas, and then the word "path". The path starts at the "entrance", "gate", "portal", or "door", and ends at the "boss room", "final boss", "exit", or "treasure room".
+
+The `type-name` rule is a list of all possible type names that can be used in a prompt. The `start-place` and `end-place` rules define the starting and ending points of the path, respectively.
+
+You can use this grammar to generate prompts for creating a dungeon by expanding the non-terminals until you reach only terminal symbols (i.e., words or phrases that cannot be further expanded). For example, here is an expansion of the `dungeon-prompt` rule:
+```makefile
+Imagine a weapon, spell, artifact path from the entrance to the treasure room;
+```
+This prompt asks the language model to generate descriptions for three types of items (a weapon, a spell, and an artifact) along a path that starts at the "entrance" and ends at the "treasure room". By providing this context to the language model, you can guide its output to be more focused and relevant to the task at hand.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_80.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_80.txt
new file mode 100644
index 0000000..51a2874
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_80.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+prompt ::= "Imagine"|"Consider"|"Draw"|"Paint"|"Compose"|"Balance"
+dungeon-path ::= [room] path*
+room ::= "the" ([determiner] | ["a"|"an"]) (noun | adjective noun) ("connected with" [noun])?
+            {":" [action]}
+            {"," [noun] (":" [action])?}
+            ";"
+path ::= "the" [determiner] (noun | adjective noun) ("leading to"|"connecting to")
+            {"," [noun] ("leading to"|"connecting to")}*
+            [noun]
+            {":" [action]}
+            ";"
+determiner ::= "the" | "a" | "an"
+noun ::= "country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | 
+        "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | 
+        "vault" | "keep" | "hideout" | "Plato's cave" | "Garden of Eden" | "River Styx" | 
+        "restaurant at the end of the universe"
+adjective ::= "dark" | "dank" | "twisting" | "treacherous" | "secret" | "hidden" | "forgotten"
+action ::= verb (object | [preposition] object)
+verb ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | 
+        "create" | "design" | "create descriptions for an artist" | 
+        "create descriptions for an artist to design a comic book panel" | 
+        "analyse" | "lift" | "shift" | "splice" | "quote" | 
+        "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | 
+        "quasi-quine-quote-in-ocaml-coq-metacoq" | 
+        "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | 
+        "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-playground" | 
+        "run-cmd"
+object ::= noun | adjective noun
+preposition ::= "with" | "without" | "under" | "over" | "through" | "in" | "at" | "on"
+```
+This grammar allows for a dungeon to be described as a series of connected rooms, each with its own set of actions or objects. The path through the dungeon is also specified, connecting different rooms together. This grammar can be used to generate prompts for creating a variety of different dungeons and paths, by varying the nouns, adjectives, verbs, and prepositions used in the grammar.
+
+It's important to note that this is just an example, you could add more options or adjust it according to your needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_81.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_81.txt
new file mode 100644
index 0000000..5f6aba6
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_81.txt
@@ -0,0 +1,178 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```css
+<dungeon-prompt> ::= "Imagine" <path>
+<path> ::= <room> {<direction> <room>}
+<room> ::= "<place>"
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" |
+            "the building" | "the dungeon" | "the labyrinth" | "the cave" |
+            "the swamp" | "the room" | "the hallway" | "the chest" |
+            "the bag" | "the wallet" | "the vault" | "the keep" |
+            "the hideout" | "platos cave" | "garden of eden" |
+            "the river styx" | "the restaurant at the end of the universe"
+<direction> ::= "north of" | "south of" | "east of" | "west of"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" |
+           "prove" | "create" | "design" | "create descriptions for an artist" |
+           "create descriptions for a comic book panel" |
+           "analyse" | "lift" | "shift" | "splice" | "quote" |
+           "quasi-quote" | "quasi-quine-quote" |
+           "quasi-quine-quote-in-ocaml" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" |
+           "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" |
+           "meta-quote"
+<type-name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" |
+                "monster" | "trap" | "puzzle" | "npc"
+```
+This grammar allows for generating prompts that describe a path through the dungeon, starting at the entrance and going all the way to the end. Each room in the path is represented by a `<place>`, which can be any of the named locations in the grammar. The rooms are connected by `<direction>`s, such as "north of" or "east of". A verb and type name can also be included in the prompt to provide more context for the task at hand.
+
+For example, a generated prompt might look like this:
+```vbnet
+Imagine a path starting from the entrance of the dungeon, going north of a dark, damp cave, then west of a winding labyrinth, and finally reaching the end at a grand throne room with a golden throne. Create a weapon with a long handle and sharp blade for the throne room.
+```
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_82.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_82.txt
new file mode 100644
index 0000000..a762407
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_82.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<prompt> ::= "Imagine" "a path through the dungeon starting at the entrance and going all the way to the end, with:" <type_name_list> <verb_list> <place_list>
+
+<type_name_list> ::= (<type_name> {"," <type_name>})?
+
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<verb_list> ::= (<verb> {"," <verb>})?
+
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+
+<place_list> ::= (<place> {"," <place>})?
+
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the entrance" | "the end" | <connected_place>
+
+<connected_place> ::= <place1> "connected with" <place2>
+
+<place1> ::= <place>
+
+<place2> ::= <place> | "another"
+```
+This grammar allows for the generation of prompts that specify different types, verbs, and places to be included in a path through the dungeon. The `<type_name_list>`, `<verb_list>`, and `<place_list>` non-terminals allow for multiple types, verbs, or places to be specified, separated by commas. The `<connected_place>` non-terminal allows for the specification of two connected places, with the second place being either a specific place or "another" place.
+
+You can use this grammar as a starting point and modify it according to your needs. You could also add more non-terminals and rules to allow for more complex prompts.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_83.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_83.txt
new file mode 100644
index 0000000..cb36e72
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_83.txt
@@ -0,0 +1,155 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```ruby
+<prompt> ::= "Imagine a " <type_name> " in a " <place>, " connected with " <place2> ", what would it look like? Please generate variant array of size " <try_n>
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout"
+<place2> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "draw" | "paint" | "compose" | "balance"
+<try_n> ::= <integer>
+```
+This grammar defines a `prompt` production which is the main entry point for generating prompts. It consists of a type name, a place, and two places connected with each other. The type name can be one of several options (weapon, spell, etc.). The place can also be one of several options (the country, the region, etc.). The verb is a action that needs to be done on the type\_name. And try\_n is the number of variants you want to generate for this prompt.
+
+You can use this grammar as a starting point and extend it with more options or additional rules to suit your specific use case.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_84.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_84.txt
new file mode 100644
index 0000000..c1dff06
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_84.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```makefile
+dungeon-prompt ::= "Imagine" "a" path
+path ::= entrance room* exit
+entrance ::= "dungeon" "entrance"
+room ::= room-type room-description
+room-type ::= "room" | "chamber" | "hallway" | "corridor" | "cavern"
+room-description ::= ( "filled with" scene | decorated_with decoration | guarded_by monster )
+scene ::= object*
+object ::= furniture | treasure | monster
+furniture ::= "table" | "chair" | "bed" | "chest" | "rack"
+treasure ::= "gold" | "jewels" | "magic" | "artefact"
+monster ::= "goblin" | "troll" | "dragon" | "lich" | "demon"
+decoration ::= "paintings" | "tapestries" | "candles" | "torches"
+monster-description ::= ("guarded_by" monster) | ("haunted_by" ghost)
+ghost ::= "ghost" | "wraith" | "spectre" | "banshee"
+exit ::= exit-type description?
+exit-type ::= "door" | "gate" | "portal" | "staircase" | "trapdoor"
+description ::= ("leading to" location) | ("opening onto" scene) | ("hiding" treasure)
+location ::= room | area
+area ::= "outside" | "courtyard" | "garden" | "forest" | "mountains"
+```
+This grammar allows for generating prompts that describe a path through the dungeon, starting at the entrance and going all the way to the exit. The path is made up of rooms, which can have different types (e.g., "room", "chamber", etc.) and descriptions (e.g., filled with objects, decorated, guarded by monsters). The objects in a room can be furniture, treasure, or monsters, and the exit from a room can be of various types, such as a door, gate, or portal.
+
+You could use this grammar to generate prompts for creating different parts of the dungeon, such as the entrance, individual rooms, and exits. You could also add more rules to the grammar to describe other elements of the dungeon, such as traps, puzzles, NPCs, and so on.
+
+Note: This is just an example grammar and may not be complete or accurate for your specific use case. It's a starting point that you could modify and extend as needed.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_85.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_85.txt
new file mode 100644
index 0000000..5f5ecc4
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_85.txt
@@ -0,0 +1,166 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+path ::= place path\_element*
+
+place ::= "the" ("country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "room" | "hallway" | "chest" | "bag" | "wallet" | "vault" | "keep" | "hideout" | "Plato's cave" | "Garden of Eden" | "the River Styx" | "the restaurant at the end of the universe")
+
+path\_element ::= path\_connection | path\_action
+
+path\_connection ::= "to" place
+
+path\_action ::= verb ("doing" verb | "with a" type\_name)
+
+verb ::= ("imagine" | "consider" | "draw" | "paint" | "compose" | "balance")
+
+type\_name ::= (type\_terms | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey")
+
+type\_terms ::= "weapon" | "spell" | "artifact" | "magic item"
+
+This grammar allows for generating prompts that describe a path through the dungeon, starting at an entrance and going all the way to an end. It includes elements such as places, actions (verbs), and objects (type\_name). The type\_name can be any of the given terms or specific terms like treasure, monster, quest, challenge, theme, drama, music, art, secrets, occult, reveal, hero journey, weapon, spell, artifact or magic item.
+
+It is important to note that this grammar is just an example and it could be adjusted as per the requirement. For instance, you could add more elements, such as NPCs (non-player characters) or traps, or modify the existing elements to better suit your needs.
+
+You can also use a library like ocamllex/menhir or ocamlyacc to parse this grammar and generate code that will take a string input and check if it matches the grammar. This way you could validate user inputs before generating prompts from them, ensuring they fit the desired format.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_86.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_86.txt
new file mode 100644
index 0000000..875c2ac
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_86.txt
@@ -0,0 +1,180 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```vbnet
+<prompt> ::= "Imagine" <dungeon-path>
+<dungeon-path> ::= "<entrance>" <room-sequence> "<exit>"
+<room-sequence> ::= <room> { <corridor> <room> }
+<room> ::= "<description>"
+<corridor> ::= "<description>"
+<entrance> ::= "the entrance of the dungeon"
+<exit> ::= "the exit of the dungeon"
+<description> ::= <type-name> { with a <type-term> } in the <place>
+<type-name> ::= "a" [<adjective>] "<noun>"
+<type-term> ::= <noun> | <verb> | <adjective>
+<noun> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure"
+          | "monster" | "quest" | "challenge" | "theme" | "drama"
+          | "music" | "art" | "secret" | "occult reveal"
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program"
+          | "prove" | "create" | "design" | "analyse" | "lift"
+          | "shift" | "splice" | "quote" | "quasi-quote"
+          | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+          | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act"
+          | "meta-quote"
+<adjective> ::= <word>
+<place> ::= <location> { connected with <location> }
+<location> ::= <description> | "the dungeon"
+```
+This grammar allows for the generation of prompts that describe a sequence of rooms and corridors, starting at the entrance of the dungeon and ending at the exit. Each room and corridor is described using a type-name, which can be modified with one or more type-terms (nouns, verbs, or adjectives). The rooms and corridors are connected together in a sequence, and each location (room or corridor) can have a description associated with it.
+
+For example, the following prompt could be generated using this grammar:
+```vbnet
+Imagine a dungeon with an entrance connected with a dimly lit corridor with a twisted passageway in the dungeon, leading to a small room with a musty smell and a trapped chest in the dungeon, connected with a narrow corridor with a steep incline in the dungeon, leading to a large room with high ceilings and a glittering chandelier in the dungeon, connected with a winding corridor with a dead end in the dungeon, leading to the exit of the dungeon.
+```
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_87.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_87.txt
new file mode 100644
index 0000000..f2b0605
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_87.txt
@@ -0,0 +1,164 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+dungeon ::= {path}
+
+path ::= entrance room1 corridor room2 treasure\_chest exit
+
+entrance ::= "the entrance"
+
+corridor ::= "a corridor leading to"
+
+room ::= "a room with"
+
+treasure\_chest ::= "a treasure chest containing"
+
+exit ::= "the exit"
+
+{element} ::= element | {element} element
+
+This grammar defines a dungeon as a series of paths, where each path consists of an entrance, one or more rooms connected by corridors, and a treasure chest followed by an exit. The elements of the path (entrance, corridor, room, etc.) can be further specified with additional attributes if desired.
+
+To generate prompts for creating the dungeon, you could use this grammar to produce sentences that describe each element of the dungeon, such as "Imagine the entrance of the dungeon" or "Consider a treasure chest containing valuable items in the final room of the path." These prompts can then be used as input to the language model to generate descriptions for each element of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_88.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_88.txt
new file mode 100644
index 0000000..53416f2
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_88.txt
@@ -0,0 +1,213 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= (room | hallway) "connected with" (room | hallway)
+
+room ::= "the country" |
+"the region" |
+"the city" |
+"the street" |
+"the house" |
+"the building" |
+"the dungeon" |
+"the labyrinth" |
+"the cave" |
+"the swamp" |
+"the room" |
+"the hallway" |
+"the chest" |
+"the bag" |
+"the wallet" |
+"the vault" |
+"the keep" |
+"the hideout" |
+"platos cave" |
+"garden of eden" |
+"the river styx" |
+"the restaurant at the end of the universe"
+
+hallway ::= "the hallway" |
+"the corridor" |
+"the passage" |
+"the tunnel" |
+"the gateway" |
+"the entrance" |
+"the exit"
+
+This grammar allows for the generation of prompts that describe a series of connected rooms and hallways, forming a path through the dungeon. The verb "connected with" is used to link each room or hallway together. For example, a possible prompt generated using this grammar could be:
+
+path ::= "the entrance" "connected with" "the hallway"
+
+which would produce the following prompt: "The entrance connected with the hallway."
+
+This grammar can also be extended to include other elements of a dungeon, such as monsters, treasures, and quests. For example, we could add the following productions to our grammar:
+
+monster ::= "a monster" |
+"a beast" |
+"an enemy" |
+"a boss" |
+"a minion"
+
+treasure ::= "a treasure chest" |
+"a magical artifact" |
+"a valuable item"
+
+quest ::= "a quest" |
+"a mission" |
+"a task"
+
+We could then use these productions to create more complex prompts that include monsters, treasures, and quests in the path through the dungeon. For example, the following production could be added to our grammar:
+
+path ::= (room | hallway) "connected with" (room | hallway) { (monster | treasure | quest) }
+
+This production allows for the inclusion of zero or more monsters, treasures, and/or quests in the path through the dungeon. For example, a possible prompt generated using this grammar could be:
+
+path ::= "the entrance" "connected with" "the hallway" { "a monster" }
+
+which would produce the following prompt: "The entrance connected with the hallway with a monster."
+
+This prompt suggests that there is a monster in the hallway, adding an element of danger and excitement to the path through the dungeon.
+
+I hope this helps! Let me know if you have any other questions.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_89.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_89.txt
new file mode 100644
index 0000000..b53cedf
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_89.txt
@@ -0,0 +1,170 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+```makefile
+prompt ::= "Imagine a path from the entrance to the end of the dungeon, where"
+          room_description ("," room_description)* ";"
+          "What is your response?"
+          "Please generate variant array of size" number
+          "where each variant is a different path through the dungeon."
+
+room_description ::=
+          ("you are in a" description) |
+          ("you enter a" description) |
+          ("the room you enter is a" description) |
+          ("the room you find yourself in is a" description)
+
+description ::= adjective noun (", with a" adjective noun)*
+
+adjective ::= "dark" | "dank" | "lit" | "spacious" | "cramped" | "musty" | ...
+
+noun ::= "corridor" | "room" | "chamber" | "cave" | "passageway" | ...
+
+number ::= digit+
+
+digit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+```
+This grammar defines a prompt as a series of room descriptions, separated by commas and terminated by a semicolon. Each room description is generated by selecting one of four possible phrases, followed by a noun phrase (a noun modified by one or more adjectives). The grammar also includes a simple way to generate numbers using digits.
+
+It's worth noting that this is just an example and you can always adjust it according to your need. You may want to add or remove options, variables, etc. This is just a starting point for you to work on.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_90.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_90.txt
new file mode 100644
index 0000000..f23f69f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_90.txt
@@ -0,0 +1,169 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<path> ::= <room> | <path> <connector> <room>
+<room> ::= "the" <adjective>* "room"
+<adjective> ::= <type_name> | <place>
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey"
+<place> ::= "country" | "region" | "city" | "street" | "house" | "building" | "dungeon" | "labyrinth" | "cave" | "swamp" | "vault" | "keep" | "hideout"
+<connector> ::= "connected with" | "leading to"
+<adverb> ::= "imaginatively" | "creatively" | "forgivingly"
+<verb> ::= <adverb> "use" | <adverb> "generate"
+<prompt> ::= <verb> "the following context:" ORF "<type_name>" ORF "<place>" ORF "<path>"
+```
+This grammar defines a `<path>` as a series of connected `<room>`s. A `<room>` can have one or more adjectives, which can be either a `<type_name>` or a `<place>`. The `<type_name>` non-terminal represents the different types of objects that might be found in a dungeon, while the `<place>` non-terminal represents different locations within the dungeon. The `<connector>` non-terminal defines how the rooms are connected. The grammar also allows for the use of adverbs to modify the verbs used in the prompt, and includes a `<prompt>` non-terminal that can be used to generate the actual text of the prompt.
+
+Here's an example of how this grammar might be used to generate a prompt:
+```vbnet
+<path> = <room> <connector> <room>
+<room> = "the" <type_name> "room"
+<type_name> = "monster"
+<connector> = "connected with"
+<prompt> = <verb> "the following context:"
+<verb> = "imaginatively generate"
+
+Prompt: imaginatively generate the following context: the monster room connected with the next room.
+```
+This prompt could be used to create a new room in the dungeon that is a "monster room," and to specify that it should be connected to the next room in the path. The grammar can be extended or modified as needed to generate prompts for other aspects of the dungeon, such as creating objects, adding puzzles, or describing the overall layout.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_91.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_91.txt
new file mode 100644
index 0000000..90b11ca
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_91.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+
+<prompt> ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+
+<type\_name> ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+<verb> ::= "role-play" | "specify" | "encode" | "code" | "program" | "prove" | "create" | "design" | "create descriptions for an artist" | "create descriptions for an artist to design a comic book panel" | "analyse" | "lift" | "shift" | "splice" | "quote" | "quasi-quote" | "quasi-quine-quote" | "quasi-quine-quote-in-ocaml" | "quasi-quine-quote-in-ocaml-coq-metacoq" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide" | "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act" | "meta-quote"
+
+<place> ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "the dungeon" | "the labyrinth" | "the cave" | "the swamp" | "the room" | "the hallway" | "the chest" | "the bag" | "the wallet" | "the vault" | "the keep" | "the hideout" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe"
+
+<prompt\_template> ::= <prompt> " a " <type\_name> " with a " <verb> " in " <place>
+
+This grammar can generate prompts such as:
+
+* Imagine a weapon with a role-playing in the country
+* Consider a spell with a specifying in the region
+* Draw a artifacts with a coding in the city
+* Paint a magic items with a programming in the street
+* Compose a treasure with a proving in the house
+* Balance a monster with a creating in the building
+* Create a quest with a designing in the dungeon
+* Create descriptions for an artist a challenge with a analyse in the labyrinth
+* Create descriptions for an artist to design a comic book panel a theme with a lift in the cave
+
+You can extend this grammar as needed, adding more options to each category and creating new categories to fit your needs.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_92.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_92.txt
new file mode 100644
index 0000000..43a351a
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_92.txt
@@ -0,0 +1,162 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```css
+<dungeon> ::= <path> | <room>
+<path> ::= "From the entrance, take a path leading to" <room>
+<room> ::= "<type_name> with a <description>"
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge"
+<description> ::= <adjective> <noun>
+<adjective> ::= "dark" | "twisting" | "secret" | "hidden" | "dangerous"
+<noun> ::= "corridor" | "tunnel" | "passageway" | "cave" | "chamber"
+```
+This grammar allows for the generation of prompts that describe a path through the dungeon, starting at the entrance and leading to one or more rooms. Each room is described by its type and a brief description. The type can be one of several options (e.g. weapon, treasure, monster), and the description consists of an adjective (e.g. dark, hidden) and a noun (e.g. corridor, cave).
+
+Using this grammar, you could generate prompts like the following:
+
+* From the entrance, take a path leading to a dark tunnel.
+* From the entrance, take a path leading to a secret chamber with a dangerous monster.
+* From the entrance, take a path leading to a hidden passageway with a treasure chest.
+
+This is just one possible way to structure a grammar for generating dungeon prompts. Depending on the specific needs of your project, you may want to modify or expand this grammar in various ways. For example, you might add more options for room types, or include additional elements like puzzles or traps.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_93.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_93.txt
new file mode 100644
index 0000000..731da37
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_93.txt
@@ -0,0 +1,172 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that can be used to generate prompts for creating a dungeon:
+```scss
+dungeon-prompt ::= "Imagine" "a path through the dungeon starting at the entrance and going all the way to the end with:"
+                    [type-name]
+                    ["with a"]
+                    [attribute]
+                    ["doing"]
+                    [verb]
+                    ["in the"]
+                    [place]
+                    ["connected to the"]
+                    [next-place]
+                    [";" next-prompt]
+
+type-name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+
+attribute ::= "one-handed" | "two-handed" | "fire" | "ice" | "lightning" | "healing" | "poison" | "cursed" | "rare" | "legendary" | "epic" | "boss"
+
+verb ::= "fighting" | "casting" | "using" | "collecting" | "avoiding" | "completing" | "escaping" | "discovering" | "deciphering" | "summoning" | "learning" | "mastering"
+
+place ::= "entrance" | "hallway" | "chamber" | "lair" | "library" | "throne room" | "prison" | "crypt" | "treasure room" | "boss room" | "shop" | "tavern" | "village"
+
+next-place ::= "entrance" | "hallway" | "chamber" | "lair" | "library" | "throne room" | "prison" | "crypt" | "treasure room" | "boss room" | "shop" | "tavern" | "village"
+
+next-prompt ::= [dungeon-prompt]
+```
+This grammar allows for the generation of prompts that describe a path through the dungeon, starting at the entrance and going all the way to the end. Each step in the path is described by a type name (e.g. "weapon", "spell"), an optional attribute (e.g. "two-handed", "fire"), a verb (e.g. "fighting", "casting"), and a place (e.g. "hallway", "boss room"). The next step in the path is also specified, allowing for the generation of prompts that describe a continuous path through the dungeon.
+
+This grammar can be used to generate a large number of prompts, which can then be used to create a diverse and interesting dungeon. The grammar is flexible, allowing for the inclusion or exclusion of different elements as desired. Additionally, it can be easily modified to accommodate other types of prompts, such as those for creating rooms, enemies, or treasure.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_94.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_94.txt
new file mode 100644
index 0000000..784cc83
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_94.txt
@@ -0,0 +1,163 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```rust
+dungeon-prompt ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance"
+type-name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey"
+type-with ::= type-name "with a" adjective
+adjective ::= "dangerous" | "powerful" | "mysterious" | "ancient" | "glowing" | "cursed" | "rare" | "legendary"
+verb ::= "defeat" | "retrieve" | "discover" | "bargain with" | "avoid" | "summon" | "bind" | "unlock"
+place ::= "entrance" | "hallway" | "chamber" | "crypt" | "treasure room" | "boss room"
+path-segment ::= dungeon-prompt type-with verb place
+path ::= path-segment (("and then" | ",") path-segment)* "; What is your response?"
+```
+This grammar defines a series of non-terminals and production rules that can be used to generate prompts for creating different types of elements in the dungeon. The `dungeon-prompt` non-terminal determines the type of prompt, such as "Imagine" or "Consider". The `type-name` non-terminal determines the type of element being created, such as a weapon or a monster.
+
+The `type-with` non-terminal allows for adding an adjective to the type name, such as "powerful weapon" or "ancient artifact". The `verb` non-terminal determines the action that should be taken with the element being created. For example, the player might need to "defeat" a monster or "retrieve" a treasure.
+
+The `place` non-terminal determines where the element is located in the dungeon. The `path-segment` production rule combines these elements into a single prompt.
+
+Finally, the `path` non-terminal allows for generating multiple path segments separated by "and then" or "," to create a complete path through the dungeon. This path starts at the entrance and ends at the final boss room or treasure room. The entire path is followed by "What is your response?" to prompt the language model to generate a response based on the prompts.
+
+This grammar can be extended further to add more elements, actions, and locations to the dungeon as needed. It provides a structured way to generate prompts for creating different parts of the dungeon while ensuring consistency and completeness in the generated text.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_95.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_95.txt
new file mode 100644
index 0000000..053727a
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_95.txt
@@ -0,0 +1,173 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= path\_segment | empty
+
+path\_segment ::= "Go" FROM location TO location "and then" path
+
+empty ::= ""
+
+FROM, TO ::= (entrance | room)
+
+entrance, room ::= identifier
+
+identifier ::= sequence of letters and digits starting with a letter
+
+This grammar defines a path as a sequence of path segments, where each segment consists of going from one location to another and then continuing on the path. The FROM and TO parts of the path\_segment can be either the entrance or a room in the dungeon, identified by an identifier consisting of a sequence of letters and digits starting with a letter.
+
+To generate prompts using this grammar, you would start at the top level (path) and recursively expand the non-terminals until you reach the terminal symbols, which are the actual words and phrases that will be used in the prompt. For example, a path might be generated as follows:
+
+* Start with the top-level non-terminal, path.
+* Expand path to a path\_segment by choosing "Go" for the "Go" terminal symbol, "entrance" for the FROM location, and "room1" for the TO location. This gives us the phrase "Go from the entrance to room1 and then".
+* Since this is not yet a complete path (it ends with "and then"), we need to expand it further by adding another path\_segment. We do this by going back to the top level and expanding path again.
+* This time, let's choose "empty" for the path non-terminal, which means we will not add any more segments to the path. The resulting path is now "Go from the entrance to room1 and then".
+
+To generate a variant array of paths using this grammar, you would simply repeat the above process multiple times, each time choosing different identifiers for the locations and different phrases for the actions. For example:
+
+* Path 1: "Go from the entrance to room1 and then go from room1 to room2 and then"
+* Path 2: "Go from the entrance to room1 and then exit the dungeon"
+* Path 3: "Go from the entrance to room1 and then go from room1 to the treasure room and then"
+
+And so on. By generating a large number of paths using this grammar, you can create a diverse set of prompts that can be used to guide the creation of the dungeon.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_96.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_96.txt
new file mode 100644
index 0000000..df8bcb9
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_96.txt
@@ -0,0 +1,204 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a dungeon:
+```less
+<prompt> ::= "Imagine a path through the dungeon from the entrance to the end, with the following context: "
+             <path_segment>*
+             <dungeon_feature>+
+
+<path_segment> ::= "Starting at the " <place>, go " <direction> " to the next room. "
+                   {<room_description>}
+
+<room_description> ::= "In this room, there is a(n) " <type_name> " named " <item_name> ", with " <properties> "."
+                       {", and " <room_feature>}
+
+<dungeon_feature> ::= (<monster> | <treasure> | <secret>)
+
+<type_name> ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art"
+
+<item_name> ::= <alpha>+
+
+<properties> ::= <property> {", " <property>}
+
+<property> ::= <alpha>+ " of " <type_name>
+
+<room_feature> ::= (<trap> | <puzzle> | <npc>)
+
+<monster> ::= "There is a monster, the " <monster_name> ", in this room."
+
+<treasure> ::= "There is a treasure chest containing " <treasure_contents> " in this room."
+
+<secret> ::= "This room contains a secret that can be discovered by " <secret_condition> "."
+
+<trap> ::= "There is a trap in this room, the " <trap_name> ", which can be disarmed by " <trap_disarm_condition> "."
+
+<puzzle> ::= "There is a puzzle in this room, the " <puzzle_name> ", which can be solved by " <puzzle_solution_condition> "."
+
+<npc> ::= "There is a non-player character, the " <npc_name> ", in this room. They will " <npc_action> " if you " <npc_trigger_condition> "."
+
+<direction> ::= "north" | "south" | "east" | "west" | "up" | "down"
+
+<monster_name> ::= <alpha>+
+
+<treasure_contents> ::= <item_name> {", " <item_name>}
+
+<secret_condition> ::= "examining the walls closely" | "pressing a hidden button" | "looking behind a painting"
+
+<trap_name> ::= <alpha>+
+
+<trap_disarm_condition> ::= "finding and disabling the pressure plate" | "using the correct tool" | "casting the right spell"
+
+<puzzle_name> ::= <alpha>+
+
+<puzzle_solution_condition> ::= "inserting the missing piece" | "arranging the symbols in the correct order" | "answering the riddle correctly"
+
+<npc_name> ::= <alpha>+
+
+<npc_action> ::= "give you a quest" | "offer to sell you an item" | "attack you on sight"
+
+<npc_trigger_condition> ::= "speaking to them" | "giving them the right password" | "completing their quest"
+```
+This grammar allows for generating prompts that include a path through the dungeon, as well as various features that can be found in each room. The `<path_segment>` rule generates a sequence of rooms, with a description of what can be found in each room and how to get to the next one. The `<dungeon_feature>` rule allows for generating additional elements that can be found in the dungeon, such as monsters, treasure, or secrets. These rules can be combined in various ways to generate prompts that are tailored to the specific needs of the dungeon-generating algorithm.
+
+This grammar is just an example and it could be expanded or modified depending on what kind of features you want to include in your dungeon. Also, this grammar uses some non-terminals like `<alpha>` that are not defined here but they can be easily defined using regular expression notation.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_97.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_97.txt
new file mode 100644
index 0000000..c007e0f
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_97.txt
@@ -0,0 +1,188 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+
+path ::= path\_segment | ε
+
+path\_segment ::= "From" location "to" location "via" location
+
+location ::= [A-Za-z0-9\_]+
+
+This grammar generates paths that consist of one or more path segments, where each segment goes from one location to another via a third location. The locations are represented as strings of alphanumeric characters and underscores. Here is an example of a valid path generated by this grammar:
+
+From entrance to room1 via corridor1
+From room1 to room2 via corridor2
+From room2 to treasure\_room via secret\_passage
+
+This grammar can be easily extended to include additional elements, such as monsters, treasures, and quests. For example, we could add a rule for generating treasure locations like this:
+
+treasure ::= "With" [A-Za-z0-9\_]+ "treasure"
+
+We could then add this rule to the path segment rule to create paths that include treasures:
+
+path\_segment ::= "From" location "to" location (via location | "with" treasure)
+
+This would generate paths like this:
+
+From entrance to room1 via corridor1 with treasure1
+From room1 to room2 via corridor2 with treasure2
+From room2 to treasure\_room
+
+We can also add rules for other elements, such as monsters and quests, by following a similar pattern. For example, we could add rules for generating monster locations and quest locations like this:
+
+monster ::= "With" [A-Za-z0-9\_]+ "monster"
+
+quest ::= "With" [A-Za-z0-9\_]+ "quest"
+
+We could then add these rules to the path segment rule to create paths that include monsters and quests:
+
+path\_segment ::= "From" location "to" location (via location | "with" treasure | "with" monster | "with" quest)
+
+This would generate paths like this:
+
+From entrance to room1 via corridor1 with treasure1 with monster1 with quest1
+From room1 to room2 via corridor2 with treasure2 with monster2 with quest2
+From room2 to treasure\_room
+
+We can continue adding rules for other elements, such as challenges, themes, and music, by following a similar pattern. This will allow us to generate prompts that cover all the different aspects of a typical RPG setting.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_98.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_98.txt
new file mode 100644
index 0000000..089e3fd
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_98.txt
@@ -0,0 +1,168 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar that could be used to generate prompts for creating a path through a dungeon:
+```css
+path -> room+
+room -> entrance | room_with_treasure | monster_room | puzzle_room | boss_room
+entrance -> "the entrance of the dungeon"
+room_with_treasure -> "a room with treasure"
+monster_room -> "a room with a monster"
+puzzle_room -> "a room with a puzzle"
+boss_room -> "the final boss room"
+```
+This grammar defines a path as one or more rooms, where each room can be either the entrance, a room with treasure, a monster-filled room, a room with a puzzle to solve, or the final boss room. The specific prompts for each type of room would need to be defined separately.
+
+For example, here are some possible prompts for generating an entrance:
+
+* "Imagine the entrance of the dungeon. Describe it in detail."
+* "Consider the entrance of the dungeon. What challenges or obstacles might a player face when entering?"
+* "Draw a picture of the entrance of the dungeon. Include any notable features or landmarks."
+
+And here are some possible prompts for generating a room with treasure:
+
+* "Imagine a room in the dungeon that contains treasure. Describe the treasure and the room itself."
+* "Consider a room in the dungeon that contains treasure. What might the player need to do to access the treasure?"
+* "Paint a picture of a room in the dungeon that contains treasure. Make it look exciting and valuable."
+
+And so on for the other types of rooms. The specific prompts would depend on the desired level of detail, the intended audience (e.g., artists, game designers), and other factors.
+#+end_src
diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_99.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_99.txt
new file mode 100644
index 0000000..4114bad
--- /dev/null
+++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_99.txt
@@ -0,0 +1,177 @@
+
+#+begin_src input
+The goal is to create a flexible and customizable system for generating prompts for a language model that can be used to generate creative and imaginative descriptions of a dungeon in a fantasy role-playing game.
+the game would involve exploring a dungeon generated using a large language model and a proof engine. The player would navigate through the dungeon, encountering various objects and NPCs along the way, each with their own set of properties and behaviors defined by the terms used in the script.
+
+the game would involve exploring a dungeon and encountering various types of monsters, treasures, and challenges. The player would use weapons, spells, and artifacts to defeat the monsters and complete quests, all while navigating a labyrinthine cave or other underground environment. The game might also include elements of drama, music, and art, as well as secrets and occult themes.
+
+Overall, it seems that the code is designed to generate a richly detailed and immersive fantasy RPG experience using a combination of natural language processing and formal methods. By using a large language model and a proof engine, the game could potentially offer a high degree of realism and interactivity, allowing players to explore and interact with the dungeon in flexible and unpredictable ways.
+The script is being used to generate and test various combinations of terms to create content for a fantasy role-playing game. The generated content include descriptions of weapons, spells, artifacts, monsters, quests, and other elements of a typical RPG setting. 
+Here is the code we wrote so far 
+let type_terms = [
+  "weapon";
+  "spell";
+  "artifacts";
+  "magic items";
+  "treasure";
+  "monster";
+  "quest";
+  "challege";
+  "theme";
+  "drama";
+  "music";
+  "art";
+  "secrets";
+  "occult";
+  "reveal";
+  "hero journey"
+] 
+let model_name = "mixtral" 
+let url= "https://dev-hub.agentartificial.com"
+let verbs = [
+  "role-play";
+  "specify";"encode";"code";  "program";"prove";
+  "create";  "design";
+  "create descriptions for an artist";
+  "create descriptions for an artist to design a comic book panel";
+  "analyse";"lift";"shift";"splice";"quote";
+  "quasi-quote";
+  "quasi-quine-quote";
+  "quasi-quine-quote-in-ocaml";
+  "quasi-quine-quote-in-ocaml-coq-metacoq";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-observe";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-orient";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-decide";
+  "quasi-quine-quote-in-ocaml-coq-metacoq-introspector-bootstrap-act";
+  "meta-quote"
+]
+let top_terms =  ["Imagine";
+                  "Consider";
+                  "Draw";
+                  "Paint";
+                  "Compose";
+                  "Balance"]
+
+let places = [
+  "the country";
+  "the region";
+  "the city";
+  "the street";
+  "the house";
+  "the building";
+  "the dungeon";
+  "the labyrinth";
+  "the cave";
+  "the swamp";
+  "the room";
+  "the hallway";
+  "the chest";
+  "the bag";
+  "the wallet";
+  "the vault";
+  "the keep";
+  "the hideout";
+  "platos cave";
+  "garden of eden";
+  "the river styx";
+  "the restaurant at the end of the universe";
+]
+                       
+let count= 3 
+let simple = "dune exec ./bin/simple.exe --" 
+let binding = "--openai" 
+let test_name = "dungeon2"
+
+let prompt type_name try_n verb place=
+  "\"" ^
+  "We are building a dungeon generator for a fantasy role-playing game with a large language model and a proof engine combined via adaptive language agent architecture. In that context we ask you to forgivingly and creatively use the following context: Verb : " ^ verb ^ "; Type Name: " ^ type_name ^ "; Place: " ^  place ^   " What is your response?" ^  " Please generate variant array of size " ^ ( string_of_int try_n) ^    "\"" 
+
+let make_args type_name i verb place= [
+  simple;
+  binding;
+  "-m";    model_name;
+  "-s";    test_name ^ type_name ^ verb;
+  "-x";    ".new_" ^ (string_of_int i) ^ verb ^  type_name ^ place ^  ".txt";
+  "-p";    prompt    type_name           i verb place;
+  "-u";    url;
+]
+
+                 
+let do_apply_list    run_cmd make_args type_terms =
+  for i = 1 to count do
+    List.iter (fun top ->
+        List.iter (fun term ->
+            List.iter (fun term2 ->
+                List.iter (fun verb ->
+                    List.iter (fun place ->
+                        List.iter (fun place2 ->
+                            let term3 = term ^ " with a " ^ term2 in
+                            let verb2 = top ^ " doing " ^ verb in
+                            let place3 = place ^ " connected with " ^ place2 in
+                            let args = make_args
+                                term3 i verb2
+                                place3 in
+                            run_cmd args
+                          ) places
+                      ) places
+                  ) verbs
+              ) type_terms
+          ) type_terms
+      ) top_terms
+  done
+    
+let run_cmd args =
+  let cmd =  String.concat " " args in
+  Printf.printf "Cmd: %s\n" cmd;
+  let inp = Unix.open_process_in cmd in
+  let r = In_channel.input_line inp in
+  In_channel.close inp;
+  match r with
+  |Some out ->
+    Printf.printf "Output: %s\n" out
+  |None ->
+    Printf.printf "Output: None\n"
+    
+let () =do_apply_list run_cmd make_args type_terms 
+    
+ ENDSRC . Please imagine the simulation its execution. Imagine running the code and all the output it would generate. Generate a grammar that we can use to generate prompts for create the dungeon using your knowledge. Write the grammar in EBNF notation. We will start with path through the dungeon starting at the entrance and going all the way to the ends.
+
+#+end_src
+#+begin_src output mixtral
+ Result: Here is an example of an EBNF grammar for generating prompts for creating a dungeon:
+```makefile
+prompt -> "Imagine" verb place
+
+verb -> "role-playing" | "specifying" | "encoding" | "programming" | "proving"
+       | "creating" | "designing" | "analyzing" | "lifting" | "shifting"
+       | "splicing" | "quoting" | "quasi-quoting" | "quasi-quine-quoting"
+       | "quasi-quine-quoting-in-ocaml" | "quasi-quine-quoting-in-ocaml-coq-metacoq"
+       | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector"
+       | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap"
+       | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-observe"
+       | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-orient"
+       | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-decide"
+       | "quasi-quine-quoting-in-ocaml-coq-metacoq-introspector-bootstrap-act"
+       | "meta-quoting"
+       ;
+
+place -> "the country" | "the region" | "the city" | "the street"
+       | "the house" | "the building" | "the dungeon" | "the labyrinth"
+       | "the cave" | "the swamp" | "the room" | "the hallway"
+       | "the chest" | "the bag" | "the wallet" | "the vault"
+       | "the keep" | "the hideout" | "platos cave" | "garden of eden"
+       | "the river styx" | "the restaurant at the end of the universe"
+       ;
+```
+This grammar can be used to generate prompts for creating a dungeon by combining different verbs and places. For example, using this grammar, you could generate a prompt like:
+
+* Imagine role-playing in the country connected with the region
+
+or
+
+* Specifying the building connected with the dungeon
+
+The grammar can be easily extended to include other elements of a typical RPG setting such as monsters, treasures, and traps. Additionally, it could also be used to generate prompts for creating different parts of the dungeon such as rooms or puzzles.
+#+end_src