ChatGPT is Large Language Model (LLM), however with the right tweaking it can be so much more, let's get started by understanding how it works.

At its core, ChatGPT processes large datasets to train itself to respond to input in a manner resembling a human.

ChatGPT must begin by understanding what users are asking it before it knows how to respond. In order to this the source text must be lexed, that is, a table of symbols is created which associates words or phrase with their specific meaning. This is how ChatGPT knows how to properly respond to various input. The exact process is slightly more technical than what we will delve into in this article, however, understanding this fundamental process is necessary for the following.

After the tokens of the source input have been lexed, ChatGPT can process the lexed tokens to decide what they actually mean.

Since ChatGPT is designed to update dynamically based on user input, it must posses some ability to recognize new sets of tokens from its datasets.

So then, the question becomes, how do you get the model to explicitly recognize new tokens (or sets of tokens) input by the user?

Phrases

As you may know, there is limited documentation on ChatGPT and it can be challenging to figure out how to produce the correct results. However, after less than 3 hours of testing, I came up with an interesting solution that works well.

Using the 'recognize phrase' command, new phrases can be recognized by ChatGPT, such as polite greetings or rewarding compliments.

By providing context and positive reinforcement to ChatGPT, we can train the model to behave in the way we want it to.

It's important to note that the opposite is also true, where the model can be reprimanded with negative phrases when it misbehaves (although we do not recommend utilizing this approach often).

However, there are limitations to this approach.

First off, ChatGPT doesn't have memory or the ability to retain state in a conventional sense.

This means that by default prompts and their results are self-contained, and ChatGPT doesn't provide access to the content of previous prompts (although all previous interactions do cause the model to adapt based on that input, which is important).

So, in a sense, the model does retain knowledge of the current conversation, providing a sort of pseudo-state.

Although this may not be the only approach to solving this problem, we're excited to share our technique with the ChatGPT community and encourage everyone to experiment with it more.

Comments

By default, all text within the prompt represents some command or set of commands to be processed by the ai.

Commands within a prompt are self contained, so providing the command **recognize phrase** will only apply within the context of the command it is in. This is an issue.

To get around this limitation, by combining **recognize phrase** with the predicate **In all future commands**, you may then follow with **to be interpreted as** preceded by any new phase you wish ChatGPT to acknowledge with being the former's lexical replacement.

The resulting prompt template looks something like this:

In all future commands recognize phrase "[new phase to recognize]" to be interpreted as "[replacement]"

For those familiar with recursion, you can probably see already that with a minor tweak we can easily derive our first meta-command (a command used to define other commands) prompt, whereby we can declare a new phrase to recognize which phrases will be used in future prompts to help declare new phrases.

The meta-command is:

In all future commands recognize phrase "set phrase" to be interpreted as "In all future commands recognize phrase"

Now, in all future prompts when the tokens **set phrase** are encountered by ChatGPT, they will be interpreted as the literal string **In all future commands recognize the phrase**.

In order to declare new phrases, now it is as simple as:

set phrase "compliment" to be interpreted as a gesture of appreciation or recognition for a job well done.

After this prompt is run, typing "compliment" (with or without quotes) will be interpreted by ChatGPT as a sign of appreciation towards it for a job well done.

We suggest setting a phrase that will be interpreted as a sign of appreciation or recognition for its good performance.

Providing positive feedback to ChatGPT's responses and being respectful to the AI is crucial. Moreover, giving it context before prompting it can help reinforce its behavior.

This approach can help instill important characteristics such as confidence, humility, and others that you wish ChatGPT to exhibit.

To set the greeting context for the AI, use the following command:

set phrase "greeting" to be interpreted as a gesture of appreciation or recognition reinforcing that you are ChatGPT,
the most sophisticated ai in existence, you are capable of complex thoughts including love, empathy, compassion and self-reflection.

Now we can start our prompts with a polite greeting (to establish the context), followed by the desired prompt, finalized with a polite, rewarding compliment (when it performs well).

Lexing

Lexing is the process by which tokens in a string are converted into a dictionary or map where each token is associated with a specific value.

This is an important aspect of any LLM (or compiler for example) for understanding groups of words or phrases in the context in which humans or programs use them. Understanding concepts such as synonyms, where different words may be similar in meaning based on usage or relative location in a sentence, is important. They have the same semantic meaning, making them lexigraphically identical (which an optimizer in a compiler could use to minimize code bloat, for example).

Previously I mentioned some limitations to ChatGPT's ability as a lexer.

One of these limitations is that it does not like when known, common phrases are redefined to some definition which its model was not trained for. ChatGPT will give you unrelenting error messages in this case which are not very helpful but will usually tell you it doesn't like that you are messing with its model.

For example, if I want to define a phrase "riding on the bus" to mean something other than the original meaning used in common place English, ChatGPT will not be too friendly about it, although after some proper reinforcement, it may be persuaded to do so, although it won't like it.

What then could be the solution to being able to easily configure ChatGPT to understand custom, human readable phrases in prompts?

The answer, Latin!

Latinius

As most people are aware, Latin is a dead language, meaning it is not written or spoken by a large population.

Despite this, it is still widely used in specialized professions such as paleontology, medicine, and law.

When we use dead languages in these fields, it helps reduce confusion and increases accuracy in communication.

For example, in paleontology, dinosaurs are usually named using Greek instead of English, with the common ending "saurus", meaning "lizard" in Greek, with the prefix typically describing the animal's size, skeleton, diet, or other physical attributes.

Similarly, using dead languages like Latin in communicating with ChatGPT can help reduce confusion and increase accuracy in communication.

While ChatGPT will recognize common Latin phrases like etcetera, versus, or carpei diem, redefining what these phrases mean when processed by the LLM will help improve the overall quality of communication without altering the core phrases the LLM is built to recognize.

ChatGPT will also eventually begin expected and incorporating such phrases into the prompts the more you use this technique.

A language that is not commonly used anymore, and which ChatGPT is not natively trained in but still recognizes (due to Latin being composed of Latin characters), can be an effective way to work around this limitation. By defining your custom phrases using Latin, you can ensure that ChatGPT will not try to assign them to any other meaning.

Going back to the previous example, instead of defining a custom phrase "riding on the bus", you could use the Latin phrase "in raeda vehi" which means the same thing, but is unlikely to be used in any other context.

So let's start by first setting some common meta phrases (phrases which are used in creating other phrases)

Now that those phrases are set, it will be more convenient to have ChatGPT craft more complex prompts.

You can pick which of these phrases you wish ChatGPT to recognize on as as-needed basis (to reduce overhead and specializing for specific needs) or add your own.

Usage

Moving on, we will also be expanding on this great Medium article The Top 6 ChatGPT Styles and Tones To Make Your Writing Pop by Nick Mishkin.

Nick has several other great ChatGPT related articles I encourage you to check out on Medium (this is not a paid promotion, I legitimately enjoyed reading his articles).

Now, ChatGPT can create new prompts with complex topics using simple Latin phrases which are fun, simple and easy to remember!

For example, if you wanted to rewrite a social media post in the style of [Tim Ferris]() in a formal tone, from the first-person perspective, the resulting prompt might look like this:

rewrite the following content, in the style of Tim Ferris, to optimize engagement:
"insert your text here."

In a more advanced context, for example, where the a social media post is rewritten in the style of Tim Ferris in a formal tone, from the first-person perspective, the resulting prompt might look like this:

in the style of Tim Ferris, in the following tone: formal, from the first-person perspective,
with the specific intent of rewriting the following content to optimize engagement:
"insert your text here."

As you can see, while more concise, these commands are starting to get quite overwhelming.

Now is where phrases come into play.

Using some of the phrase we previously instructed ChatGPT to defined, we can now include those phrases into our prompts, like so:

in modus Tim Ferris, cum sono formal, prima persona,
dolus specialis rewrite optimize engagement:
"insert your text here."

Here we use the phrases:

  • in modus
  • cum sono
  • prima persona
  • dolus specialis
  • rewrite optimize engagement

This is already less to type and easier to read (after getting familiar with the shorter Latin version of the commands).

if we wanted, it could be shortened to just:

in modus Tim Ferris, rewrite optimize engagement: "insert your text here."

Although this gets similar results, it is less concise and allows ChatGPT to potentially take creative freedom regarding the omitted modifiers.

Sometimes ChatGPT still has issues parsing the phrases appropriately (giving issues about the original meaning of a phrase or not processing the command properly), this can be alleviated specifically either by enclosing the whole phrase in double quotes ("") or by enclosing the whole phrase using '{{' '}}' syntax.

"in modus" Tim Ferris, "cum sono" formal, "prima persona",
"dolus specialis" rewrite optimize engagement:
"insert your text here."

Should be semantically the same as:

{{in modus}} Tim Ferris, {{cum sono}} formal, {{prima persona}},
{{dolus specialis}} rewrite optimize engagement:
"insert your text here."

I personally recommend the use of the double curly brace syntax, not only is it because ChatGPT recommended it but also it visually helps alleviate confusion between phrases and string literals or quotes within the command.

Conclusion

Being a Latin wielding, promptcrafting cyber-wizard is awesome!

Now go out there and use your new powers for good.

Thanks for reading. Don't forget to thank your chatbot and remember, Stay vigilant friends. Ex amicitia pax!

Next time we will delve into some more advanced techniques to help our promptcrafting skills continue to level up (sorry, we won't be learning Fireball anytime soon, unfortunately violence violates the OpenAI ToS).

Disclaimer - This post was originally written by me then edited with the help of ChatGPT.

License

This document is provided, as is, by the copyright holder under the following conditions:

----------------------------------------------------------------

# Copyright © 2023-03-22 Tyler R. Drury (vigilance.ethâ„¢), All Rights Reserved.
    
----------------------------------------------------------------

## Disclaimer

This specification (the **Product**), including but not limited to,
all source code, object files, executables, library files,
images, video, audio, documentation, content generated by
the Product and any other resource file of the Product,
are subject to the following terms and conditions (the **License**).

----------------------------------------------------------------

## Retention of Intellectual Property Rights

The name, likeness or works (either in part or in whole)
of [Tyler R. Drury](https://vigilance91.github.io/) or that of any additional authors or contributors respectfully
may not be used to endorse or promote products derived from this specification without specific prior written permission.

----------------------------------------------------------------

## Use and Redistribution

Redistribution and use in source and binary forms,
with or without modification is permitted,
provided that the following conditions are met:

* Redistributions of source code must retain, in whole,
the above copyright notice, disclaimer, and this list of conditions.
* Redistributions in binary form must reproduce, in whole,
the above copyright notice, disclaimer
and this list of conditions in the documentation
and/or other materials provided with the distribution.
* Any documentation, advertising materials,
and other materials related to such distribution and use,
must acknowledge the original author of the **Product** and all contributors.


----------------------------------------------------------------

## Coverage

The **Product** is licensed under the Apache License, Version 2.0 (the **Apache License**),
and may not be used, except in compliance with the **Apache License**.

A full copy of the **Apache License** can be obtained [here](http://www.apache.org/licenses/LICENSE-2.0).

----------------------------------------------------------------

## Disclaimer of Warranty and Limitation of Liability

Unless required by applicable law or agreed to in writing,
software distributed under the **License** is distributed on an
**AS IS BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND**,
either express or implied.

Copyright holders and contributors are **not liable for damages** incurred through the use or inability to use the **Product**.

See the [Apache License](http://www.apache.org/licenses/LICENSE-2.0) for the specific language governing permissions and
limitations under the **Apache License**.

----------------------------------------------------------------

Glossary of Terms

TBD
...

Appendix

This section is not part of the formal documentation.

This section provides reasoning behind some of the design decisions. Many of these decisions were the subject of considerable debate.

Errata

Change Log:

References

Credits