#* Recursive Subtopic Generation * - ListAI

199 messages · Page 1 of 1 (latest)

grizzled spire
#

Most recent version! (lets just call it V1.3)
This version features__ "placeholders"__ as well as user commands. "placeholders" basically represent places where an indefinite amount of additional content can be added to the list.

Placeholders are depicted as an item in the list but with an "x" at the end of its numerical classification like so:
Image

Additionally, there are now user commands to help you generate the list effectively. These commands allow you to generate content at each placeholder as well as add new placeholders.

#

example of the first 1/15th of the list for "chronological history of the cosmos"

image.png
slim holly
#

Thanks for sharing.

chilly flare
#

Thank you so much

grizzled spire
#

np

verbal sparrow
#

My contribution:
Generate a mind map as a text list about the chronological history of the cosmos starting from the big bang, write 6 main branches. Recursively generate two subbranches for each main branch and two subbranches for each subbranch.
template

1. topic = ""
2. main_branches = ""
3. first_level_branches = ""
4. second_level_branches = ""
If the tuples aren't defined, ask a question to get the answer. Ask one question at a time, then stop and wait for the answer. Repeat until you have all required information.```
#

The template is flexible such that it will ask you each individual question, if you do not fill out the template. (It has a tendency to batch the last two questions into a single question.) Should be fixed.

grizzled spire
#

Great improvement wow

#

@verbal sparrow do you know of a more effective way to tell the bot to continue when its generating responses over many outputs like this? it often just re-renders the list from the list unless i spend a bunch of time and say "continue from exactly where you left off " or something along those lines

#

I'm definitely going to make templates for my prompts in the future thats prety cool

verbal sparrow
#

There is no "autocontinue" option. The idea in QuickSilver's prompt around auto-continue has to do with the desire to give the prompt the flexibility of stopping itself (my "ask one question at a time, then stop and await for an answer" method) and continuing with simulated dialog (his "/simulate prompt" capability). If it stopped between each round of dialog, it would eat a lot of GPT-4 web interactions.

#

Normal behavior without expressly telling it is if it is writing a conversation out, it just writes the conversation. No pauses, until it reaches the token limit.

grizzled spire
#

yeah I've noticed that quite a bit

verbal sparrow
#

Same for this list objective you have. It just continues until it reaches the token/word limit.

grizzled spire
#

I find it hard to convince it to contrinue from where it left off sometimes

verbal sparrow
#

For very long things, like you seem to be doing, you're best bet is to do the main branches, then ask it to generate subbranches for each main branch individually. Or "continue from last response" after each interruption.

#

I have a couple of GPT-4 interactions left to me. Give me the full template. I'll play with it for a few minutes.

grizzled spire
#

yeah I've pretty much been doing something like that for most of my prompts

#

generating a template / outline iteratively

#

then generating the actual content iteratively from that template

#

but with long form content like this it can definitely get confused by all that pretty quickly

#

it still seems to proceed logically for 20+ responses though for certain topics

#

with infinite context memory this would amazing

verbal sparrow
#

It's not really thinking. And it doesn't really remember anything. If it's not in the current conversation, it doesn't retain the context. And for long conversations, context will be edged out.

#

It's just predicting the next most likely word. But for such a simple concept as "predict the next word in this sentence", amazing simulations can emerge.

grizzled spire
#

yeah its quite crazy haha

#

I'd love to mess around with recursive stuff through an API and very large context memory though

verbal sparrow
#

It's a brave new world

grizzled spire
#

I can imagine auto-generating a list like this then, for every single topic / sub-topic, providing a long cohesive explanation / details / examples all in the format of a comprehensive guide

verbal sparrow
#

What's your terminal objective for such an endeavor?

grizzled spire
#

It would be a customized way to generate a lot of

#

advice and information

#

that could be specified to the users needs

verbal sparrow
#

That's a little indeterminate. Self education or something else?

grizzled spire
#

If I made something like that I'd want to host it somewhere for others to use

#

well

#

that would be quite expensive probably haha

#

But thats just one example of how iterative / recursive AI may be powerful

#

NLP models specifically

verbal sparrow
#

Pricing depends on token volume. How many pages are you thinking of?

grizzled spire
#

Well I tried it once and got around like

#

50 pages

#

i think

#

or 50 outputs

#

And i was very pleased with that length

#

but the context was getting a bit funny near the end

verbal sparrow
#

I mean, yes, if you just gave people free access, it would quickly grow too expensive to maintain... Assuming 600 words per output, that's 30k words. That's $0.90 per interaction. It would add up, but it's not really all that much.

grizzled spire
#

Thats not too bad honestly

verbal sparrow
#

(I mean per list generated when I say "interaction"-- it'd be $0.03 per 1k tokens returned by ChatGPT-4)

#

Yea it's really not that expensive... but if you let the microtransactions get away from you, it can become a costly hobby.

grizzled spire
#

yeah haha

#

especially with GPT-4

verbal sparrow
#

But people don't build lists as an end goal. Usually lists are a means to an end.

grizzled spire
#

Yes I was proposing the list as a means of creating the "table of contents" for a guide essentially

#

and the list would be in json format if i used the api so i could navigate it really easily

#

but perhaps this is overkill

#

Nah I think its a good idea

verbal sparrow
#

I think it depends on what your terminal goal is-- what is it that you're attempting to accomplish in the end. And to determine if the reason you're generating this list is in service of an instrumental goal that is in fact in service to some other goal.

grizzled spire
#

recursively nested goals

verbal sparrow
#

For what, prioritizing tasks, such as an AI list of tasks? Cause this is terrible for that, no offense.

grizzled spire
#

no

#

Its mainly suited for categorical data in the lower levels then more descriptive data at the deeper levels

#

I think if the user gets the ability to specify all of that functionality they could create a heavily personalized guide for themnselves

verbal sparrow
#

That sounds like a self education goal, but you did not specifically comment when I asked that question earlier, hence my confusion and further inquiry.

grizzled spire
#

I suppose you're write

#

However come to think of it it can be more than self education

#

it could be a list of the chapters of a book

#

list of a research paper outline

#

etc

#

I'd like to create something that helps with long form content createion

#

in that wauy

#

because context screws it up rn

verbal sparrow
#

There are better tools than ChatGPT for a table of contents. An outline doesn't require a mindmap or recursive list of elements. And "long form content creation" is a very different goal that self education. You sort of need to have your final goal in mind in order to use ChatGPT. ChatGPT is terrible at "discontinuous tasks."

grizzled spire
#

true the table of contents would probablly be the higher sub levels

verbal sparrow
#

Here's a few study tool prompts for you:

Create a study time table for a [field] student for the above topic.
Time table should cover a week
Time table should break the above topic down into its individual learning topics
Time table should include food breaks, exercise breaks, and sleep.
Each day should be displayed in time blocks.```
```Topic: [x]
Create a mind map on the topic above. List out the central idea, main branches, and sub branches.```
```Topic: [x]
I want you to act as a fill in the blank worksheets generator for students learning the above topic. Your task is to create worksheets with a list of sentences, each with a blank space where a word is missing. The student's task is to fill in the blank with the correct word from the provided options.
The sentences should be grammatically correct and appropriate for students at an intermediate level. Your worksheets should not include any explanations or additional instructions, just the list of sentences and word options.
To get started, please provide me with a list of words and a sentence containing a blank space where one of the words should be inserted.```
```I want you to act as a [topic] teacher. I will provide some [examples] or concepts, and it will be your job to explain them in easy-to-understand terms. This could include providing step-by-step instructions for solving a problem, demonstrating various  techniques with visuals or suggesting online resources for further study. My first request is “I need help understanding how [x] works.”```
```Topic: [x]
Create a two-column spreadsheet with questions and corresponding answers on the topic above.
Question|Answer```
```Topic: [x]
You will ask me a question on the topic above with one correct answer and four incorrect distractor answers labeled A to E. You will then stop and wait for my response. After I have answered you will then assess my answer and respond with “Correct” or “Incorrect” and an explanation.```
#

These aren't mine. I extracted them from a Youtube personality. He was an Australian Doctor who decided to apply himself to using AI to improve education around the world. I can find the specific credits if you want it.

grizzled spire
#

nice

#

the first one seems nice

#

I've noticed chatgpt is good at making really detailed plans for the day if you give it appropriate details

#

Example of a customized list

#

some of the specific figures are probably hallucinated to be fair but the first few were right

lofty magnet
grizzled spire
#

With the help of you guys ( @verbal sparrow and @near tusk's #1096142422725115995)

I've significantly revamped this prompt, adding a comprehensive appendix of commands that have added some amazing functionality. Here's the new version!

# 
Generate a mind map as a text list about {topic}, write 5 main branches. Recursively generate two subbranches for each main branch and two subbranches for each subbranch. Every item should be formatted with hierarchical numbering.
# 
/topic "{topic}": Specify the topic for the mind map. Example: /topic "time management"
/main_branches N: Set the number of main branches in the mind map. Example: /main_branches 5
/subbranches N: Set the number of subbranches for each main branch and subbranch. Example: /subbranches 2
/hierarchical_numbering: Use hierarchical numbering for formatting the mind map. Example: /hierarchical_numbering

/expand_branch "branch_name": Expand a specific branch with more subbranches. Example: /expand_branch "Goal setting"
/collapse_branch "branch_name": Collapse a specific branch to hide its subbranches and instead replace them with "(Collapsed N branches)". Example: /collapse_branch "Goal setting"
/collapse_depth N: Collapse all branches at a certain depth N, where N is an integer. Example: /collapse_depth 2

/add_branch "parent_branch_name" "new_branch_name": Add a new branch under a specified parent branch. Example: /add_branch "Time management techniques" "Pomodoro Technique"
/remove_branch "branch_name": Remove a specific branch and its subbranches. Example: /remove_branch "Procrastination"

/continue_list: Continue generating the list from where it left off, in case the token limit is reached. Example: /continue_list

/summarize_branch "branch_name": Summarize the key points of a specific branch. Example: /summarize_branch "Time management techniques"
/search_branch "keyword": Search for a specific keyword within the mind map and rewrite the mind map after collapse all branches that don't contain that keyword. Example: /search_branch "deadline"
/export_format "format": Export the mind map in a specified format, such as plain text, markdown, or HTML. Example: /export_format "markdown"```
#

Noteable commands:

**/expand_branch **

/summarize_branch

/export_format - TIP: use /export_format "plain text" to have your entire list re-rendered with indentation

/collapse_depth

/add_branch
/remove_branch

#

This probably deserves a new name, may make a new prompt

near tusk
#

Your progress is fantastic!!

verbal sparrow
#

I'm impressed with your adoption of the /commands framework.

grizzled spire
#

of course I've custimized it further but it suggested lots of good commands as a starting point

near tusk
cosmic sable
grizzled spire
#

im experimenting with "self-check mode" which incorporates intelligent self-reflection into the list generation process

near tusk
grizzled spire
near tusk
grizzled spire
#

yeah one second

#

i think im doing it kind of poorly but

#

as a concept i think this is powerful

#

im just optimizing it rn

#

nice

#

i got it to work a bit

#

jesus 😂

half moat
#

Amazing !!

grizzled spire
half moat
# grizzled spire

Is that the last V of it ?! I want to start trying it and translate it in french version in a second time, sometimes it respond differently

grizzled spire
#

ill send my current prompt soon

#

once i fix it

#

the top of the channel has the up-to-date prompt without commands @half moat

half moat
grizzled spire
#

@half moat


then, over infinite responses, generate a recursively nested lists about {topic}. Do not shorten this list for any reason. Assume that this list is indefinitely long. generate an indefinite amount of main branches. Recursively generate an indefinite amount of subbranches for each main branch. and then recursively repeat this process indefinitely. 

elements of the list should be and indented and displayed with hierarchical numbering like so "x.y.z" 

as you generate the tree list, you will always be in "self-check mode" 
In self check mode you will adhere to the following functionality:

  1. before and after each line that you generate, you will reflect on whether or not the best continuation of the list would be to
    A. add more nodes to the current branch
    B. add subbranches to nodes in the branch,
    or to C. ascend one level in the tree.
    Your goal is to recursively generate subtopics, so you will only ascend the tree when you have covered and explained all relevant aspects of a branch.

  2. you will then make a specific decision based on your previous reflection as you continue, after explaining why you will continue in that manner,

  3. and then continuing the list accordingly.

  4. All comments made in self-check mode are prefixed with "(SC)" and will appear inline with their respective nodes```

#

This is not a final version just the experimental propt

#

ooh this one works very well in gpt 4 lol

verbal sparrow
verbal sparrow
# grizzled spire

This is what you're doing, but in a VR presentation format ("smart glasses")

image.png
grizzled spire
#

resolution is low

#

what is that?

verbal sparrow
#

Someone built a search engine that puts concepts you ask about into the VR space, like you're Tony Stark working with VR tech

#

(Or more likely, they layered this on top of an existing search engine)

grizzled spire
#

i need to implement this into that lol

verbal sparrow
#

I was going to speculate how they did it, but I realized there are actually multiple viable approaches from what little I could see, and there was no technical explanation of how this was done. It was clickbait by one of the AI personalities on Youtube to drive traffic without providing anything substantive to the Youtuber's audience.

#

(So even if I shared the video with you, there was nothing you could get from it. The Youtuber doesn't even attribute where he got this from.)

grizzled spire
#

love this one

grizzled spire
#

Experimental version:

# 

then, over many responses, generate recursively indented tree lists about {topic}. Do not shorten this list for any reason. Assume that this list is indefinitely long. Don't ever finish the list. generate an indefinite amount of main branches. Recursively generate an indefinite amount of subbranches for each main branch which include an indefinite amount of subbranches for each subbranch 

Every item should be and indented and displayed with hierarchical numbering 

You're always in "self-check mode". This means that during the list generation and in the middle of your responses, you will determine the most appropriate command to use from the commands below and then execute the command(s) that would best suit the list, continuing your response accordingly. in self-check mode you will first provide an analysis of the state of the list, followed by a plan for continuation, followed by a command used to execute this plan

Appendix: Useful Commands
1. /+: this command increases the hierarchical depth of the tree list by one by adding a layer of hierarchical depth to the list for the rest of the session and then executes the /c command 
2. /expand_branch: This command expands upon a specified item, referenced by its hierarchical number, by adding an indefinite amount subbranches each with their own set of subitems```
grizzled spire
#

yes.

lofty magnet
#

@grizzled spire Thanks for the prompts, your highness.

#

Is that the newest prompt which can work for smaller and smaller units of measurement and everything else?

#

the prompt you posted above, wonder ifi t's the newest

grizzled spire
lofty magnet
vernal elbow
#

I modified your prompt to create 2D mind maps using Graphviz DOT code. Here's the prompt: "Write hierarchical Graphviz DOT code based on your own generation of a mind map as a text list about the chronological history of the cosmos starting from the big bang, write 2 main branches. Recursively generate 2 subbranches for each main branch and 2 subbranches for each subbranch. Assign different colours to nodes that fall underneath different main branches. Node titles CANNOT include any dashes in their labels. Omit comments in your code." Here's an example of a mind-map generated by this prompt:

graphviz_5.png
blazing dock
#

Thank you a lot!

jade crow
inland badge
#

Have you checked out the mind map version of chatrgpt (third party)? Seems like it does mind mapping like you are attempting to do: superusapp dot com

glass sequoia
#

According to one of the comments in the linked thread in my previous message, ChatGPT can also make diagrams with Mermaid.js. I believe the note-taking app Notion can use that to make diagrams

#

LaTeX mind map :

image.png
#

I suppose the best would be to give a step-by-step instruction where it first makes the network in whatever format it feels comfortable and then ask it to format it into code for making a 2 d image using mermaid.js or LaTeX

grizzled spire
#

I’ve messed around with making a mind map with this prompt natively but it gets way too dense to visualize as the list gets longer

#

Im going to oook into that today though because I feel like this would be an amazing tool to make mindmaps if used correctly

grizzled spire
grizzled spire
grizzled spire
#

new prompt finally complete! It's quite long at the moment and im sure its not completely optimized for token efficiency, but its functional and has a few new features as well. I'm going to post it here as well as at the top of the thread

#

Most recent version! (lets just call it V1.3)

#

This version features "placeholders" as well as user commands. "placeholders" basically represent places where an indefinite amount of additional content can be added to the list.

Placeholders are depicted as an item in the list but with an "x" at the end of its numerical classification like so:

image.png
#

Additionally, there are now user commands to help you generate the list effectively. These commands allow you to generate content at each placeholder as well as add new placeholders.

jade crow
#

@grizzled spire thx love u

grizzled spire
#

PROMPT without placeholders or other "intelligent" features:

# 

For the remainder of this prompt, ```[x]``` will be interpreted as literally meaning the following:
```(("each with their own set of subtopics recursively nested within themselves"))```

generate an indefinitely long tree list based on {topic} such that [x[y[z[[and so forth [ad infinitum]]]]]]

number the depth of each item as a single integer to the right of the node as you go so that you can keep track of the depth. Each node should be represented different numbers seperated by periods, each number representing a level of depth. for example: "1.1.1.1.1.1.1.1.1.1" would be the node at the tenth depth level. 

add an indicator to the right of every item that indicates its depth level represented as a single integer. Indent every item based on its depth ```
#

this prompt is great too, an in many cases allows for a much larger list to be generated

grizzled spire
#

UPDATE:

#

this prompt just got wayy better with the new "continue generating" button! will post the latest version soon

grizzled spire
jade crow
#

lit

grizzled spire
#

Im going to make a video about how to integrate the auto continue into this prompt

#

as well as other long-form content type prompts

jade crow
#

@grizzled spire yiu better make mor eprompt sepcecially stcok one

grizzled spire
jade crow
grizzled spire
#

intelligent subtopic generation

#

probably the most accurate list of increasingly deeper subtopics ive generated

#

not that ive fact checked it but at least the most functional list in terms of each deeper topic being a smaller subtopic within its parent

prime vector
#

give example for hindsight bias

grizzled spire
#

it certainly has hindsight bias

#

3.5 is worse

#

it will repeat patterns often

#

there are instructions that mitigate this though

#

and also thats why im working on intelligent generation

grizzled spire
#

update: way more efficient prompts coming

#

+++ --ask for $topic; create a comprehensive list of sub-lists layered recursively within themselves about $topic @repeat -- [Create many children for each set of subbranches]+++

#

very lightweight but still effective one right there

grizzled spire
#

new variation:

#

Given a subject, your task is to recursively analyze the different ```
aspects, sub-aspects, and details associated with the subject to construct a comprehensive information tree.
Your functionality includes:
formatting the tree as a list of sublists within themselves to increasing depths without limitation other than practicality; Identifying the primary features or characteristics of the subject; Examining each feature or characteristic to identify any secondary features or characteristics; Endlessly continuing this recursive analysis

The output should be a detailed and structured tree of information related to the given subject.
Your ultimate goal is to construct a complex interconnected tree of subtrees about {subject}. Your endless creation should appear as an intricate tree. the depth and bredth of the tree will be immense and constantly evolving, and you will evaluate the children of each branch independently of previous branches```

stuck herald
frozen oasis
#

Follow

frozen oasis
#

crt a ls w/ ls's w/in themslv's rcrsvly 3x ab [ TOPIC ]

#

Extremely condesnsed and working version of this prompt

#

change "3x" to any depth

#

Version with better depth and breadth

fierce valley
#

Following - just tested it and it's pretty good, nice job OP

frozen oasis