FANDOM


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

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.