diff --git a/data/dungeon/example.ebnf b/data/dungeon/example.ebnf new file mode 100644 index 0000000..25403af --- /dev/null +++ b/data/dungeon/example.ebnf @@ -0,0 +1,23 @@ +dungeon ::= (path | room | treasure | monster)+ + +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, please generate a path from the entrance to the end of the dungeon." + +room ::= "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, please describe a room in the dungeon with the following features: (feature1, feature2, ...)" + +treasure ::= "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, please describe a treasure in the dungeon with the following features: (feature1, feature2, ...)" + +monster ::= "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, please describe a monster in the dungeon with the following features: (feature1, feature2, ...)" + +feature ::= "type" | "size" | "shape" | "color" | "location" | "behavior" + +type ::= "weapon" | "spell" | "artifact" | "magic item" | "trap" + +size ::= "small" | "medium" | "large" | "huge" + +shape ::= "round" | "square" | "rectangular" | "irregular" + +color ::= "red" | "blue" | "green" | "yellow" | "purple" + +location ::= "north" | "south" | "east" | "west" | "center" | "corner" + +behavior ::= "aggressive" | "defensive" | "neutral" | "friendly" diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_141.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_141.txt new file mode 100644 index 0000000..539331f --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_141.txt @@ -0,0 +1,189 @@ + +#+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 +dungeon-prompt ::= "Imagine" SP "a path" SP "from" SP "the entrance" SP "to" SP "the end" NL + room-sequence + +room-sequence ::= room NL room-sequence | epsilon + +room ::= "Consider" SP room-name SP "in" SP location SP NL + description + +room-name ::= identifier + +location ::= location-type SP "connected with" SP adjacent-location + +adjacent-location ::= location | "the end" + +location-type ::= "a" SP location-keyword + +location-keyword ::= "dungeon room" | "corridor" | "passageway" | "chamber" + +description ::= "Draw" SP description-detail NL + "Paint" SP description-detail NL + "Compose" SP description-detail NL + "Balance" SP description-detail NL + +description-detail ::= "the appearance of the" SP room-name NL + "the features of the" SP room-name NL + "the layout of the" SP room-name NL + "the contents of the" SP room-name NL + "the atmosphere of the" SP room-name NL + epsilon +``` +In this grammar, `SP` represents a single whitespace character and `NL` represents a newline character. The non-terminals are defined as follows: + +* `dungeon-prompt`: The top-level non-terminal representing the overall structure of the prompt. It consists of an initial phrase introducing the task, followed by a sequence of rooms. +* `room-sequence`: A repetition of one or more room descriptions. +* `room`: A single room description, consisting of a name, location, and detailed description. +* `room-name`: An identifier representing the name of the room. +* `location`: The type of location and its connection to adjacent locations. +* `adjacent-location`: The location that is connected to the current location, which can be another room or "the end" of the path. +* `location-type`: A keyword representing the type of location (e.g., dungeon room, corridor). +* `location-keyword`: A specific keyword representing a type of location. +* `description`: The detailed description of the room, which consists of one or more creative actions such as drawing, painting, composing, or balancing. +* `description-detail`: A phrase describing some aspect of the room's appearance, features, layout, contents, or atmosphere. + +Note that this is just an example grammar and can be adjusted to fit specific needs or preferences. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_142.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_142.txt new file mode 100644 index 0000000..c93cf0d --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_142.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: +```less +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 ::= "with a " (attribute | "magical") +attribute ::= "powerful" | "durable" | "fast" | "deadly" | "mysterious" | "rare" | "legendary" +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" | "the entrance" | "the end" +path ::= place ("," place)* ("connected with" place)? +prompt ::= dungeon_prompt type_name (type_modifier)? verb path +``` +In this grammar, a `dungeon_prompt` is one of several words that can be used to begin a prompt. A `type_name` specifies the type of object or feature being created for the dungeon. The optional `type_modifier` can be used to add additional attributes to the type name. A `verb` describes the action to be taken, and a `place` is a location in the dungeon. A `path` is a list of one or more places separated by commas, optionally followed by a description of how they are connected. Finally, a `prompt` consists of a `dungeon_prompt`, a `type_name`, an optional `type_modifier`, and a `verb` that operates on a `path`. + +For example, the following prompt would be generated by this grammar: +```less +Imagine a treasure with a magical power in the entrance connected with the end. +``` +This prompt instructs the user to imagine a magical treasure located at the dungeon entrance, which is connected to the end of the dungeon. By generating prompts in this way, we can create a variety of different scenarios for users to explore and populate their dungeons with. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_143.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_143.txt new file mode 100644 index 0000000..640c33d --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_143.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 for generating a path through a dungeon: +```css +path ::= [room | corridor]+ +room ::= "Enter room" SPACE type_name SPACE verb SPACE place +corridor ::= "Traverse corridor" SPACE verb SPACE place +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" +SPACE ::= " " +``` +This grammar defines a `path` as one or more occurrences of either a `room` or a `corridor`. A `room` is defined by the phrase "Enter room" followed by a `type_name`, a verb, and a `place`. A `corridor` is defined by the phrase "Traverse corridor" followed by a verb and a `place`. + +The non-terminal symbols `type_name` and `verb` are defined as a list of possible options. The non-terminal symbol `place` is also defined as a list of possible options, including some that may be more specific to the context in which this grammar is used. + +The terminal symbol `SPACE` is included to indicate where spaces should appear in the generated text. This can be useful when generating prompts or other natural language text. + +This grammar could be used to generate a path through a dungeon by starting at the entrance and following the path until reaching the end. The `type_name`, verb, and `place` for each room or corridor could be chosen randomly or according to some predetermined pattern. This would allow for a wide variety of different paths to be generated, depending on the specific options selected. + +For example, a possible path through a dungeon might look like this: +```vbnet +Enter room treasure with a glowing with the entrance +Traverse corridor create doing the city +Enter room challenge with a maze with the library +Traverse corridor program doing the swamp +Enter room spell with a fire with the laboratory +Traverse corridor role-play doing the country +``` +This path consists of three rooms and two corridors, each with a different `type_name`, verb, and `place`. The specific choices made for these elements can be customized to fit the needs of the simulation or other application in which this grammar is used. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_144.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_144.txt new file mode 100644 index 0000000..e075ec9 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_144.txt @@ -0,0 +1,165 @@ + +#+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 + ::= "Imagine" "connected with" "; what is your response?" + ::= " of the " | " in the " + ::= " leading to the " | " at the end of the " + ::= "with a" + ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey" + ::= | + ::= "Imagine" | "Consider" | "Draw" | "Paint" | "Compose" | "Balance" + ::= any adjective that describes the type + ::= "of" | "in" | "from" | "with" + ::= any noun that is related to the type +``` +This grammar can be used to generate prompts for creating different elements of a dungeon, such as weapons, spells, artifacts, etc. The `` can be chosen based on the desired level of creativity or direction for the generated content. The `` and `` can be used to specify the type of element being created and any additional details about it. The `` and `` can be used to describe the location of the element within the dungeon and its connection to other elements. + +Here is an example of a prompt generated using this grammar: +```less +Imagine a weapon of destruction in the entrance connected with a monster guarding the treasure; what is your response? +``` +This prompt asks the language model to generate a description of a weapon that is located at the entrance of the dungeon and is connected to a monster that is guarding the treasure. The language model can use its knowledge of fantasy role-playing games, weapons, monsters, and treasures to generate a creative and appropriate response. + +This grammar can be further expanded or modified to include additional elements or details about the dungeon, such as rooms, hallways, traps, puzzles, etc. The ``, ``, and `` non-terminals can also be defined with more specific values to guide the language model towards generating certain types of content. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_145.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_145.txt new file mode 100644 index 0000000..2dd7ec1 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_145.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: + +path = path\_segment, { path\_segment } + +path\_segment = path\_verb, place, "connected with", place2 + +path\_verb = "traverse" | "explore" | "navigate" + +place = type\_name, "in the", region + +type\_name = "dungeon" | "labyrinth" | "maze" + +region = "entrance" | "corridor" | "chamber" | "dead end" + +In this grammar, a path is defined as one or more path segments, where each segment consists of a verb and two places connected by the word "connected with". A place is defined as a type of location (such as a dungeon or maze) in a specific region (such as the entrance or a corridor). The type\_name and region components can be further broken down into more specific terms if desired. + +This grammar could then be used to generate prompts by randomly selecting values for each non-terminal symbol in the grammar, such as: "traverse a labyrinth in the entrance connected with a corridor" or "explore a maze in a dead end connected with a chamber". These prompts can then be used to generate descriptions of the path through the dungeon using a language model. + +Additionally, this grammar could be expanded to include more elements such as monsters, treasure, and traps that are commonly found in a dungeon setting, by adding new symbols or terms. This would allow for more varied and interesting prompts to be generated. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_146.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_146.txt new file mode 100644 index 0000000..b70f2b1 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_146.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: + +dungeon = { room | hallway } end + +room = "You are in a room with exits leading to: " exit { ", " exit } "." +exit = door | portal | ladder | tunnel +door = "a door to the " direction +direction = "north" | "south" | "east" | "west" +portal = "a portal to the " location +location = "Feywild" | "Shadowfell" | "Elemental Chaos" +ladder = "a ladder leading down" +tunnel = "a tunnel leading north" | "a tunnel leading south" | "a tunnel leading east" | "a tunnel leading west" + +hallway = "You are in a hallway with exits leading to: " exit { ", " exit } "." + +This grammar can be used to generate prompts for creating rooms and hallways, as well as the exits from those rooms and hallways. The rooms and hallways can be connected together to form a dungeon. The grammar uses non-terminals such as room and hallway, which are then defined in terms of other non-terminals and terminals. The | symbol is used to indicate alternatives, and the { } symbols are used to indicate repetition. + +For example, using this grammar, a prompt for creating a room with exits leading north and east could be: +You are in a room with exits leading to: a door to the north, a door to the east. + +A prompt for creating a hallway with exits leading south and west could be: +You are in a hallway with exits leading to: a door to the south, a door to the west. + +This grammar can be extended to include other elements of a dungeon, such as traps, treasures, monsters, and NPCs. For example, a non-terminal for trap could be added, with alternatives such as pit trap, dart trap, or pressure plate trap. Similarly, non-terminals for treasure, monster, and NPC could be added. + +In addition to this grammar, the code can also make use of language models like GPT-3, which can generate more diverse and creative prompts. The prompt generation code can then use the generated prompts as input to create the final prompts for creating the dungeon. This way, the code can leverage the power of large language models to generate more interesting and varied prompts. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_147.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_147.txt new file mode 100644 index 0000000..c52f9f0 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_147.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: +```ruby +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" +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" + +path ::= path_segment* +path_segment ::= dungeon_prompt type_name verb place "connected with" place +``` +This grammar allows for generating prompts that describe a sequence of connected rooms or areas in the dungeon, each containing an object or challenge and a corresponding action to be taken by the player. The `path_segment` non-terminal represents a single room or area, while the `path` non-terminal allows for multiple connected segments. + +Here is an example of a path that could be generated using this grammar: +```vbnet +Imagine a weapon with a sword in a hallway connected with a treasure chest +Consider a spell with a fireball in a room connected with a monster +Draw a magic item with a healing potion in a cave connected with a secret door +Paint an artifact with a staff of power in a labyrinth connected with a boss battle +Compose a theme with a dark and eerie atmosphere in a dungeon connected with a trap-filled corridor +Balance a drama with a plot twist in a keep connected with a final showdown +``` +This path describes a series of rooms or areas, each containing a different object or challenge and action for the player to take. The first room contains a weapon (a sword), the second room contains a spell (fireball), the third room contains a magic item (healing potion), and so on. Each room is connected to the next one via a specified place, allowing for the creation of a coherent path through the dungeon. + +Using this grammar as a starting point, it would be possible to generate more complex paths with multiple branches or loops, as well as variations in the types of objects and challenges encountered along the way. The resulting prompts could then be used to create a rich and varied dungeon for players to explore. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_148.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_148.txt new file mode 100644 index 0000000..ab3f284 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_148.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: + + ::= "Imagine" + + ::= * "" + + ::= | | | + + ::= "north" | "south" | "east" | "west" + + ::= "the country" | "the region" | "the city" | "the street" | "the house" | "the building" | "platos cave" | "garden of eden" | "the river styx" | "the restaurant at the end of the universe" + + ::= "with a" + + ::= "connected with" + + ::= "containing" + + ::= "weapon" | "spell" | "artifacts" | "magic items" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey" + + ::= | | + + ::= "ancient artifact" | "precious gem" | "rare object" + + ::= "magic potion" | "enchanted weapon" | "mystical talisman" + +This grammar allows for generating prompts that describe a path through the dungeon, starting at the entrance and ending at the final location. Each location can be a place, room, hallway, or chest, and each location is connected to other locations by directions such as north, south, east, or west. The rooms and chests contain treasures, which can be of different types, artifacts, or magic items. + +This grammar can be used to generate a large number of prompts for creating the dungeon. The grammar is just an example, it can be further expanded and customized according to specific requirements. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_149.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_149.txt new file mode 100644 index 0000000..cb0bf31 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_149.txt @@ -0,0 +1,224 @@ + +#+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 a path through a dungeon: +``` +path := entrance room* exit + +entrance := "You enter the dungeon through the" place + +room := "In this" place "you find:" "\n" item ("," item)* "\n" + | "You see nothing of interest in this" place "\n" + +item := object_type object_description + +object_type := "a" | "an" type_name + +type_name := "weapon" | "spell" | "artifact" | "magic item" | "treasure" + | "monster" | "quest" | "challenge" | "theme" | "drama" + | "music" | "art" | "secret" | "occult reveal" | "hero journey" + +object_description := object_name (attribute)* + +object_name := noun_phrase ("of" noun\_phrase)? + +noun_phrase := determinant noun + +determinant := "the" | "a" | "an" | possessive_pronoun + +possessive_pronoun := "your" | "his" | "her" | "its" | "their" + +noun := type_name | common_noun | proper_noun + +attribute := adjective | prepositional_phrase + +adjective := adjectival_noun | past\_participle + +prepositional_phrase := preposition noun_phrase + +preposition := "in" | "on" | "under" | "behind" | "between" | "next to" + | "above" | "below" | "through" | "across" + +common_noun := "table" | "chest" | "box" | "bag" | "wallet" | "vault" + | "keep" | "hideout" | "door" | "passage" + | "corridor" | "hallway" | "stairs" | "elevator" + | "chamber" | "cellar" | "tower" | "dungeon" + | "castle" | "fortress" | "palace" | "city" + | "town" | "village" | "hamlet" | "farm" + | "field" | "forest" | "woods" | "jungle" + | "mountain" | "hill" | "valley" | "plain" + | "river" | "stream" | "brook" | "lake" + | "sea" | "ocean" | "bay" | "gulf" + | "swamp" | "marsh" | "moor" | "fen" + | "desert" | "wasteland" | "badlands" | "heath" + | "glade" | "grove" | "pasture" | "meadow" + | "isle" | "island" | "peninsula" | "cape" + | "beach" | "shore" | "coast" | "cliff" + | "cave" | "grotto" | "den" | "burrow" + | "hive" | "nest" | "lair" | "hideaway" + +proper_noun := name\_of\_character | name\_of\_place + +name\_of\_character := "Gandalf" | "Frodo" | "Samwise" | "Merry" + | "Pippin" | "Aragorn" | "Legolas" + | "Gimli" | "Boromir" | "Saruman" + | "Sauron" | "Gollum" | "Balrog" + | "Witch-king" | "Nazgul" | "Orcs" + | "Elves" | "Dwarves" | "Hobbits" + | "Ents" | "Eagles" | "Men" + +name\_of\_place := "Mordor" | "Mount Doom" | "Minas Tirith" + | "Rohan" | "Gondor" | "Isengard" + | "Shire" | "Bree" | "Lothlorien" + | "Fangorn Forest" | "Moria" | "Caradhras" + | "Misty Mountains" | "Anduin" | "Grey Havens" + +exit := "You leave the dungeon through the" place +``` +This grammar generates a path through the dungeon starting at the entrance and going all the way to the exit. The path consists of a series of rooms, each with its own objects and descriptions. The objects are specified using type names and object names, and they can have attributes such as adjectives or prepositional phrases. The rooms are connected by passages, doors, or other means of transportation. The entrance and exit of the dungeon are also specified in the grammar. + +The grammar is written in EBNF notation, which stands for Extended Backus-Naur Form. This is a formal way of describing a language using productions, which consist of a non-terminal symbol followed by one or more alternatives separated by vertical bars. The alternatives can be terminals (strings enclosed in double quotes) or non-terminals (symbols without quotes). Non-terminals can also have recursive definitions, which allow for complex structures to be generated. + +The grammar can be used to generate prompts for creating the dungeon by expanding the non-terminal symbols into concrete phrases or sentences. For example, the non-terminal `entrance` can be expanded into "You enter the dungeon through the dark and narrow entrance tunnel", and the non-terminal `room` can be expanded into several possible combinations of objects and descriptions. The grammar can also be extended to include more features or variations, such as different types of monsters, treasures, or challenges. + +By using a formal grammar to generate prompts, we can ensure that the prompts are consistent, complete, and unambiguous. We can also easily modify or extend the grammar to suit our needs or preferences. This can help us create more engaging and immersive simulations that can be used for various purposes, such as education, entertainment, or research. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_150.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_150.txt new file mode 100644 index 0000000..2f3a633 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_150.txt @@ -0,0 +1,203 @@ + +#+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 + ::= "Imagine" "a path through the dungeon from the entrance to the end with the following context: " + + + ::= ( ";" | ";")+ + + ::= "Room" "with a" + (("connected to" ) | + ("leading to" )) + ()? + + ::= "Corridor" "connecting" "to" + + ()? + + ::= ("the entrance" | ) + + ::= | | + + ::= - {"the entrance"} + + ::= + (" " "+")? ("," ) * "." + + ::= + "-" "-" + + + ::= + (" " "+")? ("," ) * "." + + ::= {"the throne room", "the treasure chamber", "the dragon's lair", + "the laboratory", "the library", "the barracks", + "the kitchen", "the dining hall", "the great hall"} + + ::= {"torch", "door", "chest", "table", "chair", "bed", "altar", + "statue", "fountain", "staircase", "archway", "gate", + "window", "wall", "floor", "ceiling"} + + ::= {"goblin", "orc", "troll", "skeleton", "zombie", "wight", + "mummy", "ghost", "demon", "dragon", "lich", "beholder", + "minotaur"} + + ::= {"gold coins", "gems", "magic sword", "armor", "scrolls", + "potion of healing", "staff of power", "spellbook", + "map to treasure", "ring of teleportation", "amulet of life"} + + ::= {"dark", "damp", "cold", "hot", "noisy", "quiet", "narrow", + "wide", "low", "high", "twisting", "secret", "guarded", + "abandoned", "cursed"} + + ::= {"lit", "locked", "trapped", "hidden", "guarded by", "infested with"} + + ::= {"rats", "bats", "spiders", "snakes", "insects", "slimes", + "zombies", "skeletons", "goblins", "orcs", "trolls"} +``` +This grammar can be used to generate prompts for creating a dungeon by combining different elements of the grammar in various ways. For example, a prompt could be generated as follows: + +Imagine a path through the dungeon from the entrance to the end with the following context: Room the throne room with a treasure connected to the corridor connecting the throne room to the treasure chamber leading to the barracks; Room the treasure chamber with a magic sword connected to the corridor connecting the treasure chamber to the kitchen; Room the kitchen with a table connected to the corridor connecting the kitchen to the dining hall; Room the dining hall with a chair connected to the corridor connecting the dining hall to the great hall; Room the great hall with a door connected to the exit. + +This prompt describes a path through the dungeon that starts at the entrance (the throne room) and ends at the exit, passing through several rooms along the way. Each room has a type of object in it, and is connected to either another room or a corridor. The objects, enemies, and treasures in the rooms are randomly generated according to the grammar rules. + +The grammar can be extended to include more elements, such as puzzles, traps, and NPCs. The prompts generated from the grammar can then be used to create a text-based dungeon crawler game or a tabletop role-playing game scenario. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_151.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_151.txt new file mode 100644 index 0000000..dbda668 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_151.txt @@ -0,0 +1,165 @@ + +#+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 + ::= | "to" + ::= ["connected to" ] + ::= ["with a" ] [] [] + ::= "a" | "an" + ::= | + ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secret" | "occult" | "reveal" | "hero journey" + ::= ["doing" ] [] + ::= "imagine" | "consider" | "draw" | "paint" | "compose" | "balance" + ::= "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" + ::= ["in the" ] | ["connected to" ] + ::= | + ::= "entrance" | "exit" | "hallway" | "stairs" | "corridor" | "door" | "window" | "passage" | "chamber" | "room" | "tower" | "cave" | "labyrinth" | + ::= | + ::= "entrance" | "exit" | "hallway" | "stairs" | "corridor" | "door" | "window" | "passage" | "chamber" | "room" | "tower" | "cave" | "labyrinth" +``` +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 room on the path is described using a type name, such as "a weapon" or "an artifact", which can be modified with additional terms such as "with a magical aura". The room can also have a verb phrase, such as "imagine a monster roaring", and a place phrase, such as "in the dark castle tower". + +The grammar also allows for the connection of rooms to other rooms or places, such as "connected to the entrance" or "connected to the dark castle tower". This can be used to create more complex dungeon layouts. + +Overall, this grammar provides a flexible and extensible way to generate prompts for creating a dungeon, allowing for a wide variety of descriptions and configurations. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_152.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_152.txt new file mode 100644 index 0000000..8711975 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_152.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 for generating a path through a dungeon: +```css + ::= { "-" ">" } + + ::= ["(" ")"] + + ::= "north" | "south" | "east" | "west" + + ::= + + ::= + + ::= { | } + + ::= { } + + ::= { } "." + + ::= { | | "-" } +``` +In this grammar, `` represents the entire path through the dungeon, starting at the entrance and ending at the final room. Each room in the path is represented by a ``, which consists of a name and an optional description. The direction of travel between rooms is represented by a ``. + +The grammar includes non-terminals for other elements such as `` and `` to allow for more flexibility in generating the prompts. For example, the `` non-terminal could be used to generate unique names for monsters or treasures in the dungeon, while the `` non-terminal could be used to generate descriptions of those elements. + +Overall, this grammar provides a framework for generating prompts that can be used to create a variety of different elements in a fantasy role-playing game setting. The grammar can be further customized and expanded as needed to suit the specific requirements of the project. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_153.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_153.txt new file mode 100644 index 0000000..2a8f209 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_153.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 path through a dungeon: +```css +path ::= [room | hallway | corridor | stairway] 'to' [room | hallway | corridor | stairway] +room ::= 'the' place ('with a' type_name | 'containing' treasure) +hallway ::= 'the' place ('connecting' room | hallway | corridor | stairway) +corridor ::= 'the' place ('leading to' room | hallway | corridor | stairway) +stairway ::= 'the' place ('ascending to' room | 'descending to' room) +type_name ::= weapon | spell | artifact | magic item +treasure ::= treasure_chest | pile_of_coins | rare_gemstone +``` +In this grammar, a `path` is defined as one or more rooms, hallways, corridors, or stairways connected by the word "to". Rooms are defined as "the place with a type\_name" or "the place containing treasure", where "place" is a specific location in the dungeon and "type\_name" is an item from the `type_terms` list (e.g. weapon, spell, etc.) and "treasure" is a specific treasure that can be found in the room. + +Hallways are defined as "the place connecting room or hallway or corridor or stairway", where the hallways connects two locations together. Corridors are defined as "the place leading to room or hallway or corridor or stairway". Stairways are defined as "the place ascending to room" or "the place descending to room", indicating a change in elevation within the dungeon. + +Treasure is defined as `treasure_chest`, `pile_of_coins`, or `rare_gemstone`, which can be further specified with more detail if desired. + +This grammar could be used to generate prompts for creating a path through the dungeon by randomly selecting elements from each non-terminal and concatenating them together in a meaningful way. For example, a prompt generated using this grammar might look like: "The entrance hall leads to a long corridor with a weapon rack at the end. The corridor connects to a small room with a magic circle on the floor. The magic circle is connected to a winding stairway descending to the treasury." +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_154.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_154.txt new file mode 100644 index 0000000..2c5a388 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_154.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 a path through a dungeon: +``` +path ::= (room | corridor)*) +room ::= "enter" room\_name + | "exit" room\_name +corridor ::= "traverse" corridor\_name + | "exit" corridor\_name "to" room\_name + | "enter" corridor\_name "from" room\_name + +room_name ::= [a-zA-Z]+ +corridor_name ::= [a-zA-Z]+ +``` +This grammar defines a `path` as a sequence of one or more `room`s and/or `corridor`s. A `room` can be entered or exited, with the name of the room following the keyword. A `corridor` can be traversed, exited, or entered, with the name of the corridor following the keyword. If a corridor is exited or entered, the name of the room it connects to follows the name of the corridor. + +To generate prompts for creating the dungeon using this grammar, you could use the following template: +``` +"Imagine entering {room_name} and then {path}. What does the room look like? Describe the path in as much detail as possible." +``` +Replace `{room_name}` with the name of a room, and `{path}` with a sequence of rooms and corridors generated using the grammar. This template can be used to generate prompts for creating each room and connecting corridor in the dungeon. + +You could also extend this grammar to include other elements of the dungeon, such as monsters, treasures, and quests, by adding new non-terminals and production rules. For example: +``` +path ::= (room | corridor)* +room ::= "enter" room_name + | "exit" room_name + | "encounter" monster_name + | "find" treasure_name + | "complete" quest_name +corridor ::= "traverse" corridor_name + | "exit" corridor_name "to" room_name + | "enter" corridor_name "from" room_name +monster_name ::= [a-zA-Z]+ +treasure_name ::= [a-zA-Z]+ +quest_name ::= [a-zA-Z]+ +``` +This extended grammar allows you to generate prompts for creating and describing monsters, treasures, and quests in the dungeon. You can use these prompts to guide the language model in generating descriptions of these elements as well. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_155.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_155.txt new file mode 100644 index 0000000..d08f9ee --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_155.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: + +dungeon ::= entrance room+ treasure\_room+ monster\_room+ boss\_room +entrance ::= "the entrance" +room ::= corridor+ description +corridor ::= "corridor leading to" | "secret passage to" | "hidden door to" +description ::= [adjective] noun [relative\_clause] +adjective ::= "dark" | "twisting" | "narrow" | "ancient" | "crumbling" | "dusty" +noun ::= "room" | "passageway" | "chamber" | "cavern" | "tunnel" | "vault" +relative\_clause ::= "containing" [treasure] | "infested with" [monsters] +treasure ::= "a chest filled with gold and jewels" | "piles of coins and gems" | "rare and valuable artifacts" +monsters ::= "goblins" | "orcs" | "trolls" | "dragons" | "lichs" | "skeletons" +treasure\_room ::= description "containing" [treasure] +monster\_room ::= description "infested with" [monsters] +boss\_room ::= "the final boss room" | "the lair of the ultimate evil" | "the dragon's den" + +This grammar defines a dungeon as a series of rooms connected by corridors. Each room can have a description, which includes an optional adjective and a noun, as well as an optional relative clause indicating the presence of treasure or monsters. There are also specific types of rooms, such as treasure rooms, monster rooms, and a boss room. + +You could use this grammar to generate prompts for creating different parts of the dungeon by expanding the non-terminals into natural language sentences. For example, you could generate a prompt for a treasure room by expanding the `treasure_room` non-terminal as follows: + +"Generate a description for a treasure room with a dark cavern containing piles of coins and gems." + +You can also use this grammar to generate different variations of the same type of room by randomly selecting different options from the non-terminals. For example, you could generate multiple variations of a monster room as follows: + +* "Generate a description for a monster room with a narrow passageway infested with goblins." +* "Generate a description for a monster room with a crumbling chamber infested with dragons." +* "Generate a description for a monster room with an ancient tunnel infested with skeletons." + +You can use this grammar as a starting point and extend it to include more details about the dungeon, such as traps, puzzles, and NPCs. You can also modify the grammar to generate prompts for other types of simulations, such as city building or space exploration. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_156.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_156.txt new file mode 100644 index 0000000..12a0bd0 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_156.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: +```ruby + ::= "Imagine" "path from the entrance to the end with" + "" "connected with" "" + ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | + "monster" | "quest" | "challenge" | "theme" | "drama" | + "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey" + ::= "role-playing" | "specifying" | "encoding" | "coding" | "programming" | "proving" | + "creating" | "designing" | "describing" | "analysing" | "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" + ::= "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 entrance" | "the end" +``` +This grammar defines a prompt as a series of type names, verbs and places. The `` non-terminal represents the different types of things that can be found in the dungeon, such as weapons, spells, artifacts, etc. The `` non-terminal represents actions that can be performed on those type of things, such as role-playing, specifying, encoding, creating, designing, etc. Finally, the `` non-terminal represents different locations in the dungeon, such as the country, the region, the city, etc. + +The grammar allows for a variety of prompts to be generated by combining different type names, verbs and places. For example, one possible prompt generated by this grammar would be: "Imagine a weapon path from the entrance to the end with treasure creating in the building connected with artifact role-playing in the country" + +This is just an example of how the grammar can be used, you could also add more rules or non terminals to the grammar to generate more specific prompts. Also this grammar is not complete and may require further modification based on your requirements. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_157.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_157.txt new file mode 100644 index 0000000..ba4ece2 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_157.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: +```makefile + ::= "Imagine" "; What is your response?" + + ::= { } + + ::= + + ::= "Enter" | "Exit" | "Traverse" | "Explore" | "Navigate" + + ::= "room" | "hallway" | "corridor" | "chamber" | "passage" + + ::= { "connected with" } + + ::= "then" | "followed by" | "next is" + + ::= "the entrance" | "the exit" | "a dead end" | "a treasure room" + | "a monster's lair" | "an ancient ruin" | "a hidden passage" +``` +This grammar can be used to generate prompts for creating a dungeon by expanding the non-terminals until a `` is generated. For example, one possible path through the dungeon might be: +```vbnet +Imagine Enter room at the entrance then traverse hallway connected with the entrance; What is your response? +``` +This prompt can then be used to generate text describing this part of the dungeon using a language model. The process can be repeated for each step in the path, resulting in a complete description of the dungeon. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_158.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_158.txt new file mode 100644 index 0000000..3ca2424 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_158.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 for generating prompts for creating a dungeon: +```ruby + ::= "Imagine" "a " " in " + ::= "dungeon" | "room" | "corridor" | "monster" | "treasure" + ::= | ( " connected with " ) + ::= "the entrance" | "the end" | + ::= + ::= "dark" | "twisty" | "labyrinthine" | "secret" + ::= "passage" | "door" | "chamber" | "staircase" +``` +For example, using this grammar, the following would be a valid prompt: + +Imagine a dungeon in the entrance connected with a dark passage. + +This prompt asks the language model to imagine a dungeon at the entrance of the dungeon, which is connected to a dark passage. The type name is "dungeon", and the place is "the entrance connected with a dark passage". This prompt could be used to generate a description of the first room or area in the dungeon. + +Here is an example of how this grammar could be used to generate a sequence of prompts for creating a path through the dungeon: +```ruby + ::= + ::= "Imagine" "a " "dungeon" " in " + ::= ( )* + ::= "Imagine" "a " "corridor" " in " + ::= ( )+ + ::= "Imagine" "a " "room" " in " + ::= ( )* + ::= "Imagine" "a " "monster" " in " + ::= "easy" | "medium" | "hard" + ::= ( )* + ::= "Imagine" "a " "treasure" " in " + ::= "common" | "uncommon" | "rare" + ::= "Imagine" "the " "end" " of the dungeon" +``` +For example, using this grammar, the following would be a valid path through the dungeon: + +Imagine a dungeon in the entrance. Imagine a corridor in the dark passage connected with the first room. Imagine a room in the first room connected with an easy goblin. Imagine a treasure in the goblin's lair. Imagine a treasure in the goblin's hoard. Imagine the end of the dungeon. + +This path consists of a dungeon at the entrance, which is connected to a corridor in the dark passage. The corridor leads to a room with an easy goblin, which has a lair and a hoard with treasures. The path ends at the end of the dungeon. This sequence of prompts could be used to generate a coherent and interesting path through the dungeon, using the language model's imagination and creativity. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_159.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_159.txt new file mode 100644 index 0000000..b82c17d --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_159.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: +``` +path := entrance room* exit +entrance := "You enter the dungeon through the" "." +exit := "You find the" "and leave the dungeon." +room := "As you move forward, you enter a" "." room_content+ "." +room_content := "There is" "in the" "." +``` +The `` non-terminal can be expanded using a similar grammar for generating descriptions of places, monsters, treasures, and other elements of a typical RPG setting. The `*` symbol indicates that the preceding element can be repeated any number of times, including zero. The `+` symbol indicates that the preceding element must appear at least once. + +In this grammar, the `entrance` non-terminal describes how the path begins, with a description of the entrance to the dungeon. The `exit` non-terminal describes how the path ends, with a description of the exit from the dungeon. The `room` non-terminal describes an individual room in the path, which includes a description of the room and any content (e.g., monsters, treasures) found within it. + +This grammar can be used to generate a variety of different paths through the dungeon by expanding the `` non-terminals in different ways. For example, one possible path generated using this grammar might be: +``` +You enter the dungeon through the dark and ominous entrance. There is a faint glimmer of light at the end of the long, winding tunnel. As you move forward, you enter a dimly-lit room with damp stone walls and a low ceiling. A rat scurries across the floor, startling you. In the corner of the room, you see a chest that looks like it might contain something valuable. +``` +Another possible path generated using this grammar might be: +``` +You enter the dungeon through the grand and imposing entrance. The sound of running water echoes through the hallway ahead. As you move forward, you enter a large chamber with a high ceiling and a glittering chandelier. A group of goblins stands in the center of the room, jeering at you. In the corner of the room, you see a treasure chest encrusted with jewels. +``` +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_160.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_160.txt new file mode 100644 index 0000000..607a739 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_160.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: +```css +path ::= (room | hallway | corridor) path | end + +room ::= "the room" | "the treasure room" | "the boss room" | ... + +hallway ::= "the hallway" | "the connecting hallway" | "the winding hallway" | ... + +corridor ::= "the corridor" | "the dark corridor" | "the narrow corridor" | ... + +end ::= "the end of the path" | "the final chamber" | "the exit" | ... +``` +This grammar defines a `path` as one or more `room`, `hallway`, or `corridor` elements, followed by an `end` element. Each of these elements can be further specified using different keywords to create more varied and interesting descriptions. The "..." in the grammar represents that there could be many other types of rooms/hallways/corridors, depending on the specific needs of your dungeon. + +You can also add other elements such as monsters, treasures, traps, etc... by adding new non-terminals and rules to this grammar. + +For example: +```css +monster ::= "the dragon" | "the goblin" | "the skeleton warrior" | ... + +treasure ::= "the golden chalice" | "the magic sword" | "the rare gem" | ... + +trap ::= "the pitfall trap" | "the dart trap" | "the poison needle trap" | ... + +path ::= (room | hallway | corridor) path | end | (monster | treasure | trap) path +``` +You can also use this grammar to generate prompts for other parts of the dungeon, such as the layout, or the background story. You just have to modify the non-terminals and rules accordingly. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_161.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_161.txt new file mode 100644 index 0000000..a566445 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_161.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: +```less +dungeon-prompt ::= "Imagine" "a" path +path ::= entrance (room | hallway | corridor)* exit +entrance ::= "the" "entrance" "to" "the" "dungeon" +exit ::= "the" "exit" ("from" "the" "dungeon")? +room ::= "a" "room" ("with" description)? (connected-by hallway)* +hallway ::= "a" "hallway" ("connecting" room room?)?; +corridor ::= "a" "corridor" ("leading" "to" room)?; +description ::= adjective* noun+ +adjective ::= "dark" | "twisty" | "narrow" | "low-ceilinged" | ... +noun ::= "passageway" | "treasure-chest" | "monster" | "puzzle" | ... +connected-by ::= "connected" ("by" hallway)?; +``` +In this grammar, a dungeon prompt is generated by starting at the entrance of the dungeon and then traversing a path through a series of rooms, hallways, and corridors until reaching the exit. Each room, hallway, or corridor can optionally have a description, which is generated using a list of adjectives and nouns. The grammar also allows for different types of connections between rooms (e.g., a hallway, a corridor) to be specified. + +This grammar could be used in conjunction with the code provided by the user to generate prompts for creating a dungeon with a large language model and a proof engine combined via adaptive language agent architecture. The generated prompts would include specific type names (e.g., "a dark room with a treasure chest"), verbs, and places, as specified in the code. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_162.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_162.txt new file mode 100644 index 0000000..fd78c0f --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_162.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 ::= (path | room | treasure | monster)+ + +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, please generate a path from the entrance to the end of the dungeon." + +room ::= "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, please describe a room in the dungeon with the following features: (feature1, feature2, ...)" + +treasure ::= "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, please describe a treasure in the dungeon with the following features: (feature1, feature2, ...)" + +monster ::= "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, please describe a monster in the dungeon with the following features: (feature1, feature2, ...)" + +feature ::= "type" | "size" | "shape" | "color" | "location" | "behavior" + +type ::= "weapon" | "spell" | "artifact" | "magic item" | "trap" + +size ::= "small" | "medium" | "large" | "huge" + +shape ::= "round" | "square" | "rectangular" | "irregular" + +color ::= "red" | "blue" | "green" | "yellow" | "purple" + +location ::= "north" | "south" | "east" | "west" | "center" | "corner" + +behavior ::= "aggressive" | "defensive" | "neutral" | "friendly" + +Note that this is just an example and the actual grammar would depend on the specific requirements of your dungeon generator. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_163.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_163.txt new file mode 100644 index 0000000..88983d4 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_163.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: +```r +dungeon_prompt ::= "Imagine" "a" path +path ::= entrance room* exit +entrance ::= "dungeon" "entrance" +room ::= room_type room_description room\_link? +room\_type ::= "a" type\_name +room\_description ::= description +room\_link ::= "connected" "to" next\_room +next\_room ::= room\_type | entrance | exit +exit ::= "dungeon" "exit" +type_name ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey" +description ::= verb_noun_phrase room\_detail* +verb_noun_phrase ::= verb_noun verb_modifier? +verb_noun ::= verb particle noun +verb ::= "create" | "design" | "create descriptions for an artist" | "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 ::= "description" | "artist" | "comic book panel" | "place" +particle ::= "for" | "to" | "with a" +verb_modifier ::= adverb | preposition_phrase +adverb ::= "creatively" | "intricately" | "dangerously" | "magically" +preposition_phrase ::= "in the" place | "of the" type\_name +place ::= "room" | "entrance" | "exit" +``` +This grammar generates a prompt that starts with "Imagine", followed by a path through the dungeon. The path consists of an entrance, one or more rooms, and an exit. Each room is described using a type name (such as "weapon" or "monster"), a description, and an optional link to the next room. + +The description of each room is generated using a verb-noun phrase, followed by zero or more modifiers that provide additional detail about the room. The verb-noun phrase consists of a verb (such as "create" or "analyse"), a particle (such as "for", "to", or "with a"), and a noun (such as "description" or "artist"). + +The modifiers can be adverbs (such as "creatively" or "dangerously") or preposition phrases (such as "in the room" or "of the weapon"). + +This grammar is just an example, and it can be adjusted to generate different types of prompts for creating a dungeon. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_164.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_164.txt new file mode 100644 index 0000000..8c6ffb9 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_164.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 for generating prompts for creating a dungeon: +```makefile + ::= "Imagine" + + ::= "a path through the dungeon from the entrance to the end with" + + + ::= { "and" } + + ::= { "with a" } + [ "in" ] + + ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" + | "monster" | "quest" | "challenge" | "theme" | "drama" + | "music" | "art" | "secret" | "occult" | "reveal" + | "hero journey" + + ::= | + + ::= "role-playing" | "specifying" | "encoding" | "programming" + | "proving" | "creating" | "designing" | "composing" | "balancing" + | "analyzing" | "lifting" | "shifting" | "splicing" | "quoting" + | "quasi-quoting" | "meta-quoting" + + ::= { "-" } + + ::= "fantasy" | "dangerous" | "magical" | "mystical" + | "epic" | "historical" | "legendary" + + ::= { "connected with" } + + ::= | "a 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" + + ::= "the country" | "the region" | "the city" | "the street" + | "the house" | "the building" | "the dungeon" + | "the labyrinth" | "the cave" | "the swamp" +``` +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 `` rule allows you to specify a sequence of elements that make up the path through the dungeon, starting at the entrance and ending at the final destination. + +For example, using this grammar, you could generate the following prompt: + +"Imagine a path through the dungeon from the entrance to the end with a magical weapon with a sharp blade and a powerful enchantment in a dark and ominous room connected with a maze of twisty passages leading to a fearsome dragon guarding a hoard of treasure in a deep and foreboding cave." + +This prompt instructs you to create a path through the dungeon that goes from the entrance to the end, and includes a magical weapon with a sharp blade and a powerful enchantment in a dark and ominous room. The path then leads to a maze of twisty passages, which connects to a fearsome dragon guarding a hoard of treasure in a deep and foreboding cave. This prompt provides enough detail for you to create the various elements of the dungeon, but still leaves some room for creativity and interpretation. + +You can modify this grammar as needed to generate different types of prompts or to add more rules and constraints. For example, you could add rules for generating NPCs, puzzles, traps, or other features of a dungeon. You could also add rules for specifying the layout and structure of the dungeon itself, such as rooms, corridors, and other features. The possibilities are endless! + +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_165.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_165.txt new file mode 100644 index 0000000..6081ab4 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_165.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 for generating prompts for creating a dungeon: +```css + ::= "Imagine" "a" "" "" + ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey" + ::= "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" + ::= "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 allows you to generate prompts for creating different types of elements in a dungeon (e.g. weapons, spells, monsters) with different verbs (e.g. role-play, specify, create) and in different places within the dungeon. You can use this grammar as a starting point and add more options to it if you need more variation in your prompts. + +For example, using this grammar, you could generate a prompt like: "Imagine a weapon role-play the country" or "Imagine a treasure create descriptions for an artist the dungeon". This prompts will help you to create the different elements of the dungeon in a systematic way. + +You can also expand the grammar to include more details about the type of element, verb, and place, such as adding attributes (e.g. "a weapon with magical properties" or "a monster with a specific weakness") or variations on the verb (e.g. "create a detailed description" or "create a rough sketch"). + +You can also add more rules to the grammar to generate different paths through the dungeon, such as adding decision points and branching options (e.g. "If you encounter a monster, do you fight it or try to sneak past it?") + +This is just one example of how you could use an EBNF grammar to generate prompts for creating a dungeon. You can modify and expand this grammar as needed to fit your specific needs and requirements. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_166.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_166.txt new file mode 100644 index 0000000..862076d --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_166.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 + ::= | | | + + ::= "From the entrance, the path leads through" {", then through" }* ", to the final room." + + ::= | "" + + ::= "A" "appears in" "and blocks the way." + + ::= "The" "lies hidden in" . + + ::= {", a" | ","}* [".]" ] + + ::= ("dangerous" | "dark" | "twisty" | "secret" | "hidden") + + ::= ("passage" | "hallway" | "door" | "chamber" | "corridor" | "cavern" | "crypt") +``` +This grammar allows for generating prompts that describe a dungeon in terms of paths, rooms, monsters, and treasures. A path consists of one or more connected rooms, with the final room being the destination. Rooms can be described in general terms (e.g. "a secret passage") or in relation to other rooms (e.g. "the hallway connected with the crypt"). Monsters and treasures are associated with specific rooms and are also described using adjectives and nouns. This grammar can be further expanded or modified to fit specific needs. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_167.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_167.txt new file mode 100644 index 0000000..667a242 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_167.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: + +path ::= entrance room* exit +entrance ::= "the entrance" | "the beginning" | "the start" +room ::= "a room" | "a chamber" | "an area" +exit ::= "the exit" | "the end" | "the goal" + +path\_segment ::= path\_item+ +path\_item ::= entrance | room | exit | obstacle | treasure +obstacle ::= "a monster" | "a trap" | "an enemy" +treasure ::= "gold coins" | "a magic item" | "a powerful artifact" + +The grammar consists of two non-terminals, `path` and `path_segment`, which are used to generate the overall structure of the path. The `path` non-terminal is defined as a sequence of one or more `path_item`s, starting with an `entrance` and ending with an `exit`. The `path_segment` non-terminal is used to generate a single segment of the path, consisting of one or more `path_item`s. + +The `path_item` non-terminal can be any of the following: an `entrance`, a `room`, an `exit`, an `obstacle`, or a `treasure`. These elements can be combined in various ways to generate different prompts for creating the path through the dungeon. + +For example, using this grammar, we could generate the following prompt for creating a path segment: "Imagine a room connected with a monster and then an area connected with gold coins. What does it look like?" This prompt would instruct the language model to create a description of a room, followed by a description of a monster, and finally a description of an area containing gold coins. + +Overall, this grammar provides a flexible way to generate prompts for creating a path through a dungeon, allowing for a variety of different elements to be included in the path and the ability to specify their order and connections. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_168.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_168.txt new file mode 100644 index 0000000..d525f0a --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_168.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: +``` +path ::= (room | corridor) + + +room ::= "enter" room_name "and" action + +corridor ::= "traverse" connector + +room_name ::= + +action ::= verb phrase + +verb ::= "explore" | "search" | "fight" | ... + +connector ::= "connecting" room_name +``` +In this grammar, a path is defined as a sequence of one or more rooms and corridors. A room is represented by its name and an action that the player can take in that room. A corridor is simply a connector between two rooms. The connector is represented by the name of the room it connects to. + +This grammar can be used to generate prompts for creating a dungeon by recursively expanding the non-terminal symbols until all elements are terminals. For example, the following prompt could be generated from this grammar: + +"Enter the entrance and explore. Traverse the corridor connecting the entrance to the first room. Enter the first room and fight." + +This prompt can then be used as input for a language model or other AI system to generate text descriptions of the dungeon and its rooms, enemies, and treasures. The grammar can also be extended with additional non-terminal symbols and rules to generate more complex prompts that include elements such as puzzles, traps, NPCs, and quest objectives. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_169.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_169.txt new file mode 100644 index 0000000..4f0acdd --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_169.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 dungeon: +``` + ::= | | | + ::= "From the entrance, " * "to the end." + ::= "Take a left turn into a " , "then " " down the hallway. " | "" + ::= " is here. " "\n" + ::= [a-zA-Z0-9]+ + ::= | + ::= "You see a " * "." + ::= "" | "s" + ::= [a-zA-Z0-9]+ + ::= "Suddenly, " * "!" + ::= "" "the " "." + ::= "A " | "An " + ::= " glimmers in the corner. " "\n" + ::= [a-zA-Z0-9]+ + ::= " lunges at you! " "\n" + ::= [a-zA-Z0-9]+ +``` +This grammar allows for generating a variety of prompts that can be used to create different elements of the dungeon, such as rooms, treasures, and monsters. The `` non-terminal generates a sequence of path segments that lead from the entrance of the dungeon to the end, with each segment describing a turn or action that the player must take. + +You can use this grammar in combination with a parser generator like ANTLR or Yacc to generate code that can parse prompts and create a representation of the dungeon. Additionally you could also use this grammar as a base for creating prompts that are more complex by adding new non-terminals and rules to it. + +You can also add other elements such as weather, time of day, and NPCs (Non-Player Characters) interactions. Also you could add the options of different paths or routes that the player can take, with each path having its own set of rooms, treasures, and monsters. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_170.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_170.txt new file mode 100644 index 0000000..f23bbf4 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_170.txt @@ -0,0 +1,196 @@ + +#+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 + ::= "Imagine" + + ::= * + + ::= "connected with" + + ::= "the end of the path is in" + + ::= | "Consider" + + ::= "doing" + + ::= | "with a" + + ::= | "a" "and a" + + ::= | "in" + + ::= "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" + + ::= "weapon" | "spell" | "armor" | "item" | "monster" | "trap" + + ::= | | + + ::= "powerful" | "magical" | "rare" | "common" | "cursed" | "useful" + + ::= "iron" | "steel" | "mithril" | "gold" | "diamond" | "wooden" + + ::= "small" | "medium" | "large" | "huge" | "tiny" | "colossal" + + ::= "entrance" | "corridor" | "room" | "chamber" | "labyrinth" | "maze" + | "vault" | "treasure-room" | "exit" +``` +This grammar allows for the generation of prompts that describe a path through the dungeon, starting at the entrance and ending at some destination. The path is made up of segments that connect two places, with an optional description of what can be found in each place. At the end of the path, there is a description of the final destination. The action to be performed in the dungeon is described by a verb and a type of object or creature that the verb applies to. This can optionally include a further description of attributes of the object or creature. + +For example, a prompt generated from this grammar might look like this: +```vbnet +Imagine a path starting at the entrance, passing through a small wooden door connected with a narrow corridor, and ending in a treasure-room filled with magical weapons and armor. Consider role-playing as a powerful sorcerer doing magic in a maze of cursed traps. +``` +This prompt describes a path that starts at the entrance, passes through a small wooden door connected to a narrow corridor, and ends in a treasure-room filled with magical weapons and armor. It suggests role-playing as a powerful sorcerer doing magic in a maze of cursed traps. + +The grammar can be easily extended or modified to generate prompts for other aspects of the dungeon, such as descriptions of individual rooms or encounters with monsters. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_171.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_171.txt new file mode 100644 index 0000000..0a7d909 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_171.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 that could be used to generate prompts for creating a dungeon: +```css + ::= | | | | + ::= "Imagine" "a path through the dungeon from the entrance to the end, with:" + ::= ( "," )* + ::= "a " + ::= "weapon" | "spell" | "artifact" | "magic item" | "treasure" | "monster" | "quest" | "challenge" | "theme" | "drama" | "music" | "art" | "secrets" | "occult" | "reveal" | "hero journey" + ::= "Consider" "a challenge for the adventurers to overcome, with:" + ::= "Draw" "a treasure for the adventurers to find, with:" + ::= "Paint" "a monster that the adventurers may encounter, with:" + ::= "Compose" "an artifact for the adventurers to discover, with:" +``` +This grammar allows for generating prompts for creating different elements of a dungeon such as paths, challenges, treasures, monsters and artifacts. Each prompt starts with an action word like "Imagine", "Consider", "Draw" or "Paint" which instructs the language model what to do. The type list specifies the types of elements that should be included in the dungeon and is specified using a comma-separated list of type names. + +You can use this grammar as a starting point and expand it with more options, like the place or other elements, or even add some randomness to generate different prompt each time you run your code. +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_172.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_172.txt new file mode 100644 index 0000000..dfd6128 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_172.txt @@ -0,0 +1,217 @@ + +#+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 = "Enter" place ({"Go" verb place} | {"Take" artifact place})* "Exit" + +place = identifier + +verb = "north" | "south" | "east" | "west" | "up" | "down" + +artifact = "key" | "sword" | "shield" | "scroll" | "potion" + +identifier = ALPHA {ALPHA | DIGIT}* + +This grammar generates a sequence of paths through the dungeon, where each path starts at an entrance and ends at an exit. Each path is made up of one or more steps, where each step involves either going to a new place or taking an artifact from a place. Places are identified by unique names, while verbs describe the direction of movement and artifacts are objects that can be picked up along the way. + +To use this grammar to generate prompts, you could write a program that generates random paths through the dungeon by randomly selecting options at each step according to the grammar rules. For example, the program might select a random place for the entrance and then randomly choose whether to go to a new place or take an artifact from the current place. This process would be repeated until an exit is reached, at which point a new path would be started. + +Here is some sample code that demonstrates how this could work: +``` +let generate_path () = + let entrance = Random.string_of_char (Random.int 26) in + let rec go steps = + if List.length steps > 0 then + match steps.hd with + | "Go" -> + let verb = [|"north"; "south"; "east"; "west"; "up"; "down"|] in + let place = Random.string_of_char (Random.int 26) in + let steps' = steps.tl @ ["Go", verb.(Random.int (Array.length verb)), place] in + go steps' + | "Take" -> + let artifact = [|"key"; "sword"; "shield"; "scroll"; "potion"|] in + let place = Random.string_of_char (Random.int 26) in + let steps' = steps.tl @ ["Take", artifact.(Random.int (Array.length artifact)), place] in + go steps' + | _ -> assert false + else + [["Enter", entrance]; ["Exit"]] in + go [] + +let generate_dungeon count = + List.map generate_path (List.init count Random.int) + +let () = + let dungeons = generate_dungeon 3 in + List.iter print_endline dungeons +``` +This code generates a list of random dungeons, where each dungeon is represented as a sequence of paths through the dungeon. To turn these dungeons into prompts, you could use a template like this: + +"Imagine entering the {entrance} and then {path}. When you reach the end, exit and start over at a new entrance." + +where `entrance` is the name of the entrance place and `path` is a string representation of the path. The code to generate prompts from the dungeons could look like this: +``` +let generate_prompt dungeon = + let entrance = List.hd (List.hd dungeon) in + let path = String.concat " then " (List.map (fun step -> + match step with + | ["Go", verb, place] -> verb ^ " to the " ^ place + | ["Take", artifact, place] -> "take the " ^ artifact ^ " from the " ^ place + ) (List.flatten dungeon)) in + "Imagine entering the " ^ entrance ^ " and then " ^ path ^ ". When you reach the end, exit and start over at a new entrance." + +let () = + let dungeons = generate_dungeon 3 in + List.iter (fun dungeon -> + let prompt = generate_prompt dungeon in + Printf.printf "Prompt: %s\n" prompt; + ) dungeons +``` +This code generates a prompt for each dungeon and prints it to the console. The resulting prompts might look like this: + +"Imagine entering the A and then go to the B then take the sword from the B then exit and start over at a new entrance." +"Imagine entering the Z and then take the potion from the Y then go to the X then exit and start over at a new entrance." +"Imagine entering the Q and then take the scroll from the W then go to the V then take the shield from the V then exit and start over at a new entrance." +#+end_src diff --git a/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_173.txt b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_173.txt new file mode 100644 index 0000000..a525705 --- /dev/null +++ b/data/dungeon/sim_dungeon_1_2024-02-18T12:03:17-05:00_173.txt @@ -0,0 +1,202 @@ + +#+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 + ::= + + + ::= | -> + + ::= + + ::= "You are in" . + + ::= "Exits: " * + + ::= "to" | "none" + + ::= "north" | "south" | "east" | "west" + + ::= +``` +This grammar defines a dungeon as one or more paths, where each path is a sequence of rooms connected by exits. A room consists of a description and a list of exits. The description is a simple sentence indicating the current location, while the exits are represented as a list of directions and the connected rooms. + +You can generate prompts for creating the dungeon by expanding this grammar to include more details about each room, such as monsters, treasures, or quests. For example: +```less + ::= + + + ::= | -> + + ::= + + ::= "You are in" . + + ::= ? ? ? + + ::= "Monsters: " * + + ::= + + ::= "Treasures: " * + + ::= + + ::= "Quests: " * + + ::= + + ::= "Exits: " * + + ::= "to" | "none" + + ::= "north" | "south" | "east" | "west" + + ::= +``` +This extended grammar includes features such as monsters, treasures, and quests in each room. You can generate prompts for creating the dungeon by expanding this grammar even further to include more details about each feature. For example, you could add attributes such as hit points or loot tables for monsters, or rarity levels and value for treasures. + +To use this grammar to generate prompts, simply expand it as needed and then generate a sentence or two for each non-terminal symbol. For example, using the extended grammar above, you could generate the following prompt: +```vbnet +You are in a dark, musty chamber with Monsters: Goblin (easy), Troll (hard); Treasures: Gold Ring (rare), Sword of Power (legendary); Quests: Rescue the Princess (describe here). Exits: north to a dimly lit corridor, east to a secret passage, none. +``` +This prompt provides enough information for an artist or game developer to create a detailed room in the dungeon, complete with monsters, treasures, and quests. By generating many such prompts, you can quickly build up a large and varied dungeon. +#+end_src