## **Sequence Generator Code**

I am developing general purpose code to generate long strings of finite integers according to rules that can be written using the correct syntax.

Sequence Generator Code needs to be be **interpreted** using a program in a conventional programming language. I am using **VBA in Microsoft Excel** to do this. The code will be added to this blog shortly. I plan to write a **Javascript** version in due course and make it available online on a web page.

Refer to other links in the my Further References section.

## **Overview**

Sequence Generator Code is intended to follow very general rules for generating long sequences of finite integers.

The main technique used to generate sequences is a type of cloning process where any section of the sequence can be used to build (and restrict) the values of another sequence. This technique is used in a heavily recursive process to generate arbitrary lengths of sequences.
If the code syntax has been used correctly, then the sequence will be guaranteed to be **finite** and every integer will be **finite**.

Here is a very simple illustration of the cloning process used:

SequenceA = (0,1,2,0,0,0,8,1,SequenceB) SequenceB < (2,0,0,0,8)

In this illustration, **SequenceB** will be generated as a clone from a section of **SequenceA** and then appended to **SequenceA**

The cloning process is straight forward. SequenceB integers may be any value from \(0\) up to the value of the relevant integer in the section being cloned.

SequenceA = (0,1,2,0,0,0,8,1,SequenceB) SequenceB < (2,0,0,0,8) SequenceB = (Integer1,...)

Therefore **Integer1** may be either \(0, 1, 2\). The cloning process **collapses** and terminates if any integer in **SequenceB** is less than **SequenceA**. The process therefore would terminate if **Integer1** was either \(0, 1\).

The cloning process **must collapse** and terminate at or before the last integer. Therefore, **Integer4** for **SequenceB** must be either \(0, 1, 2, 3, 4, 5, 6, 7\) and never \(8\).

Using just these concepts we can see that SequenceB is restricted to a small number of valid sequences:

(0) (1) (2,0,0,0,0) (2,0,0,0,1) (2,0,0,0,2) (2,0,0,0,3) (2,0,0,0,4) (2,0,0,0,5) (2,0,0,0,6) (2,0,0,0,7)

Refer to the section on Sequence Generator Code **Syntax** for more detailed explanation. A separate section will be written to explain the **selection process** for each finite integer ... WORK IN PROGRESS.

Sequence Generator Code needs to be be **interpreted** using a program in a conventional programming language. I am using **VBA in Microsoft Excel** to do this. The code will be added to this blog shortly. I plan to write a **Javascript** version in due course and make it available online on a web page.

WORK IN PROGRESS

## **Overview: Example**

Here is a simple example of how to use the code and to read the syntax. Refer to my blog on Version 2 of the Sequence Generator Code for more info on this code example.

s_x = (e_0,[Simple(RealNumber) = [e_0]]) e_x = (C_d<2,C_d>(0:(i_x,[[i_x]]),(i_E,i_M,e_a<C_d..i_E,[10^[i_E]*[i_M]+[e_a]]))) i_x = (C_x<10-U_x,[[C_x]+[U_x]])

This simple example can be used to generate numbers using basic Exponentiation (^), Multiplication (\(*\)) and Addition (\(+\)). This is not intended to be interesting in itself, but helps to illustrate how the Sequence Generator Code does and how it can be used.

## **Overview: Syntax**

Sequence Generator Code is intended to follow very general rules for generating long sequences of finite integers. Long sequences of final integers can be used to describe complex objects and mathematical statements, (Refer to my blog on the Beta Function for detailed code of how to generate very large numbers using the full power of the Veblen ordinals and FGH functions).

Other examples for using sequences can be to generate big numbers using simpler mathematical functions like exponentiation, multiplication and addition. This is what the **Simple Example** code does.

The code has been changed significantly in my latest blog on Version 2 of the Sequence Generator Code. The keywords and symbols used in the code can now be summarised as follows:

Symbols | Description | Example |
---|---|---|

V_x | Variable
(any x) | Can be defined and used separate to the generated sequence |

C_x
(any x) | Integer | Sequence Elements are all integers |

y_x
(any y) (any x) | Sequence Type | Different types of sequences can be defined with separate code |

U_x
(any x) | Uppercase Function | Returns 0 if x is a digit or a lowercase character and Returns 1 if x is an uppercase character |

M_y_x
(any y) (any x) | Minimum Function | Returns 0 if every element in Sequence y_x is 0, otherwise it Returns 1 |

= < >: | Evaluation Symbols | V_x=10 to set the value of a variable
y_x<a_b to limit the elements in one sequence based on the values of another sequence y_x>(0:a_b,1:c_d) to compare the value of a sequence and select next instruction based on the value, e.g. either a_b or c_d |

[ ] ( ) | Brackets | [ ] to identify the text to be used to render the string output
( ) to identify the next instruction to be processed |

, .. | Delimiters | , to separate instriuctions in one line of code
.. to separate the start and finish elements in a sequence range |

The syntax for Sequence Generator Code will be explained by following this simple example closely.

**Building Different Sequence Types**

s_x = (e_0,[Simple(RealNumber) = [e_0]])

The code has been changed significantly in my latest blog on Version 2 of the Sequence Generator Code. The original Syntax explanation may be helpful to read until I update this blog. The original Syntax explanation can be found on my Version 1 blog.

WORK IN PROGRESS

## **Overview: String Rendering**

Version 2 of the code has introduced a fairly straight-forward extension to the syntax to automatically render the sequences into a readable string. Any sequence generating code can be extended to include instructions for how the integers should be translated (rendered) into a string or words or mathematical symbols.

The rules to do this are:

WORK IN PROGRESS

**Sequences in JSON format**

A good example of String Rendering is this following example which makes it easier to read complex sequences by rendering them as a string in JSON format. This example will also capture the original structure of the string using the general purpose JSON object model syntax. This makes the sequences significantly easier to read and inspect. A good JSON Viewer can be found here.

Here is the Sequence Generating Code required to render the JSON formatted string for the simple example used in this blog.

s_x = ("e_0,[{""V_r"":RealNumber,""e_0"":[e_0]}]) e_x = (C_d<2,C_d>(0:(i_x,[[i_x]]),(i_E,i_M,e_a<C_d..i_E,[{""i_E"":[i_E],""i_M"":[i_M],""e_a"":[e_a]}]))) i_x = (C_x<10-U_x,[[C_x]+[U_x]])

Here is one JSON format example derived from this code:

{"V_r":9.5,"e_0":{"i_E":9,"i_M":6,"e_a":7}}

Refer to my blog on Version 2 of the Sequence Generator Code for more info on this code example.

## **Sequence Generator Code: Input Parameter**

Sequence Generator Code is intended to be a set of general purpose rules that can be used to succinctly describe the generation of any type of **finite** sequences of **finite** integers.

The Syntax explains how to understand and write Sequence Generator Code but does not explain what input parameter is required or how inputs are processed by the code. To best understand this, refer back to the cloning process used at the core of this coding language. The premise is that every subsequent integer in the sequence will be restricted by one of the previous integers in the sequence. In the rare occurrences when this is not the case then the syntax allows for an integer to be explicitly constrained by a maximum value by using the \(<\) symbol.

Therefore any integer in the sequence must fall in the range of \(0\) to a Maximum Integer. The following input parameters can be used:

Input | Processing Option | Output |
---|---|---|

Real Number | Integer Selection | 0 to Max Integer |

\(0\) | Force Minimum Integer | 0 |

\(-1\) | Force Maximum Integer | Max Integer |

Random Number Generator | Random Selection could be used but isn't at this time
| 0 to Max Integer |

The next section will explain the Integer Selection process using Real Number inputs. The other two methods are also used for specific purposes in the code ... and will be explained ... WORK IN PROGRESS

## **Sequence Generator Code: Integer Selection**

Every integer element in a sequence is bound to a range of \(0\) to a Max Integer. This section will explain how a number in this range is selected when using Real Number input parameters.

WORK IN PROGRESS

## **Sequence Generator Code: Limitations**

Sequence Generator Code can in principle generate any **finite** sequence of **finite** integers. The following limitations still apply due to:

Limitation | Effect on the Output of the Code |
---|---|

Precision of any Real Number Input | Using ordinary real number precision options of a typical computer program will limit real number inputs to approx 10 to 15 decimal places. This can be improved by writing specific algorithms to construct real numbers of arbitrary levels of precision. However this would still be impacted by the next limitation. |

Processing Time & Memory | Typically, I have used Sequence Generator Code to access sequences with up to 500 integers (Sequence Depth = 500). This is usually more that can be generated using ordinary real number precision, but I find this depth to be adequate and any more than this makes manual inspection of the output sequences very difficult.
I find that it is actually more important to force an elegant end to the sequence rather than persevere with an an unlimited depth. Therefore, the code will switch its Integer Selection method when it has reached the maximum depth (e.g. 500) and force all subsequent integers to be the minimum value of 0. This has the neat result of generating a valid sequence according to the code used. |

## **Sequence Generator Code: Interpreter**

Sequence Generator Code needs to be be **interpreted** using a program in a conventional programming language. I am using **VBA in Microsoft Excel** to do this. The code will be added to this blog shortly. I plan to write a **Javascript** version in due course and make it available online on a web page.

**Further References**

Further references to relevant blogs can be found here: User:B1mb0w