do the math, etc... - What about my idea for a private key that only 7 numbers (Alpha group identifiers)
have to be changed after each message sent whereas both sides could send these
encrypted messages. These 7 group identifiers would be protecting the identity of the onetime
random order set for each of the 7 Alpha characters within each group.
This eliminates any possible outside attack on repeated messages where the identifiers
are not changed they may identify where some Alpha characters are located within each
group after analyzing many messages.
A private key string read from left to right holding 7 random groups of 7 alpha characters
and 7 group identifiers placed only in odd count positions of the string.
When the scan (read) of the string has reached the end of the string it just starts the scan
at the beginning of the string again. This happens as many times as needed for each message.
Only one letter can be drawn from any one particular group on each scan.
The random order of the 7 group identifiers is only changed after each completed message.
The set random order for the Alpha characters within each group of 7 is not changed but could also be.
See below.
A little further explanation of my 7^2 encryption.
49 Alpha characters = 26*2 = 52 minus one X, one Y, and one Z = 49 Alpha characters
and 7 group identifiers 1-7 for a total string length of 56.
The encrypted number (group identifier) reads the string from left(start of scan) to right then identifying
the same identifier in the ciphertext (odd-numbered position) then the next number in the ciphertext is the
Alpha characters position within that group(1-7 positions within all the 7 groups ).
Say the first identifier, the start of the encrypted message is 3. The left-right scan (read)
stops at 3 then from the next number after the identifier is 5 the alpha character in that
position is T or the 5th position of the random Alpha group. So the first letter of the encrypted message is a
(T) and so on. Only drawing a limit of one letter from anyone group on every completed scan.
Some full scans may only produce as little as 1 o 2 matching letters but moat full scans involve more than 2.
Reaching the end of the string and then starting the scan from the start of the string again
until each number in the even positions of the encryption has drawn a letter to complete the
plain text message.

Example of a private key string ---
2KPMJNOL5VQSUWRT4KHMNJIL6IDCGHFE1BECGFDA3SOQUTRP7YAVXBWZ

And an encrypted public message created from the above private key ---
574267274635574767113626554462326431523446632147712454433767163273673657426727177771663274

This message contains all the letters of the Alphabet.

Just follow the K-I-S-S rules above and you can decrypt it very easily
by scanning and comparing the above private key with the public key over and over
from left to right.
The latter part of the encryption shows 4 -7's but it does not break the rule of 1 letter limit from
one particular group per complete scan. So a list of the same numbers in a row is not uncommon in a long encrypted message because one is a group identifier and the next is the position within that group.

A nice little hint. These one-timers (XYZ) also could be spread out a little more in the string where
all 3 Alpha characters now reside in group # 7 identifiers.
An added feature could also be employed on my 7^2 encryption brainstorm to send encrypted messages
back and forth from sender to receiver and visa versa.
I believe Chris passes off the new information on updating the private key string when a ciphertext is
sent by either party, Bob or Alice, it updates the receiver's file which intern gives the private
key new information. In essence, changing the private key of the receiver or how it processes
the new information from a file or some other direct process.
The fractional values on Chris's algorithm that are sent along with the encrypted message are the
catalyst for sending different encrypted messages with different hex to letter conversions from Bob or Alice.
This, I believe, Chris's fractional values sent with the ciphertext do just that.

In my system, it is much simpler.
Instead of a few fractional values sent with the ciphertext, as in Chris's system, a random order of
1,2,3,4,5,6,7 as group identifiers could either update the present private key of the receiver or
choose a whole new string with randomly placed Alpha characters from a database that will match
the new random order of the group identifiers that are sent with the ciphertext.
I would prefer the latter.
For added security, a rational number could be sent with the ciphertext where it's hidden continued
fraction where that could look like [2:7,3,4,6,5,1,18,22,1] or embedded in the CF as say every 3rd term after the
first 2 terms.
The number of combinations for 1,2,3,4,5,6,7 are <7! but still, a good number that could be used
again.
What is the actual number of combinations 1-7 for the number of unique group identifiers?
( 0,8,or 9) can ever be in the body of the number.