I know this sounds rediculus but, drawing an --->oo lattice
because to draw this you have to come back in from --->oo
to the origin or the center of this --->oo lattice.

B = the multiple data points in the first integer listiong at
the bottom of the page. A is just the pixel length.
B=the value of the integer.This is only executed once and is
stand alone at the start of the lattice giving B=1.

R=A First set of instructions, (stand alone only executed once B=1}.
U=A (1) is the first integer in the 1st sequence below.
-----------------------------------------------------------------
Next integer value B=2 and is exicuted twice
L=A The next set of instruction executed once or multiple times depending
D=A on the number sets of 4. Each giving 2 passes here -->((2),1,3,2)
and so on after the other three below are executed,((4),3,5,4),((6),5,7,6)--
------------------------------------------------------------------
Next interger value = B=1 and is executed once.
R=A Giving one pass here -->(2,(1),3,2))
D=A
-----------------------------------------------------------------------
Next integer value B=3 and executed 3 times
R=A
U=A Giving 3 passes here -->(2,1,(3),2))
-----------------------------------------------------------------------
Next integer value B=2 and is executed twise.
L=A
U=A Giving 2 passes here -->(2,1,3,(2))
---------------------------------------------
Then going back to the 1st of the 4 sets LD with the next set ((4),3,5,4)
I know htios
1,(2,1,3,2),(4,3,5,4),(6,5,7,6),(8,7,9,8),(10,9,11,10),(12,11,13,12),(14,13,15,14),(16
,15,17,16),(18,17,19,18)
Extending this to --->oo the next set of 4 integers -- (20,19,21,20) and
the next -- (22,21,23,22) and so on --->oo.
Comming back and filling in the lattice Is self explanitory in the second segment of the logrithum. The second seaqence shows this.

1st sequence ---
1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
,15,17,16,18,17,19,18 adding to the end here with 4 more values adds 1 more rotation.
2nd sequence ---
18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
4,4,3,3,2,2,1,1 adding to the beginning here with 4 more valuse fills in the last rotation above when that has 4 more added to it's end. ex. 20,19,19,18 added to the beginnig.

Here is the order of the fill in directions and multiples B values handeled the same way in groups of 4.

R=A
D=A
----
L=A
D=A
----
L=A
U=A
---
R=A
U=A
---
This eliminate huge lists of directions of RU,RD,LD,LU by giving larger and larger integer value that have a definate pattern for a square lattice for gong
out and comming back in.

Dan

On Sunday, June 4, 2023 at 1:18:14 PM UTC-4, Dan joyce wrote:
> I know this sounds rediculus but, drawing an --->oo lattice
> because to draw this you have to come back in from --->oo
> to the origin or the center of this --->oo lattice.
>
> B = the multiple data points in the first integer listiong at
> the bottom of the page. A is just the pixel length.
> B=the value of the integer.This is only executed once and is
> stand alone at the start of the lattice giving B=1.
>
> R=A First set of instructions, (stand alone only executed once B=1}.
> U=A (1) is the first integer in the 1st sequence below.
> -----------------------------------------------------------------
> Next integer value B=2 and is exicuted twice
> L=A The next set of instruction executed once or multiple times depending
> D=A on the number sets of 4. Each giving 2 passes here -->((2),1,3,2)
> and so on after the other three below are executed,((4),3,5,4),((6),5,7,6)--
> ------------------------------------------------------------------
> Next interger value = B=1 and is executed once.
> R=A Giving one pass here -->(2,(1),3,2))
> D=A
> -----------------------------------------------------------------------
> Next integer value B=3 and executed 3 times
> R=A
> U=A Giving 3 passes here -->(2,1,(3),2))
> -----------------------------------------------------------------------
> Next integer value B=2 and is executed twise.
> L=A
> U=A Giving 2 passes here -->(2,1,3,(2))
> ---------------------------------------------
> Then going back to the 1st of the 4 sets LD with the next set ((4),3,5,4)
> I know htios
> 1,(2,1,3,2),(4,3,5,4),(6,5,7,6),(8,7,9,8),(10,9,11,10),(12,11,13,12),(14,13,15,14),(16
> ,15,17,16),(18,17,19,18)
> Extending this to --->oo the next set of 4 integers -- (20,19,21,20) and
> the next -- (22,21,23,22) and so on --->oo.
> Comming back and filling in the lattice Is self explanitory in the second segment of the logrithum. The second seaqence shows this.
>
> 1st sequence ---
> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
> ,15,17,16,18,17,19,18 adding to the end here with 4 more values adds 1 more rotation.
> 2nd sequence ---
> 18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
> 4,4,3,3,2,2,1,1 adding to the beginning here with 4 more valuse fills in the last rotation above when that has 4 more added to it's end. ex. 20,19,19,18 added to the beginnig.
>
> Here is the order of the fill in directions and multiples B values handeled the same way in groups of 4.
>
> R=A
> D=A
> ----
> L=A
> D=A
> ----
> L=A
> U=A
> ---
> R=A
> U=A
> ---
> This eliminate huge lists of directions of RU,RD,LD,LU by giving larger and larger integer value that have a definate pattern for a square lattice for gong
> out and comming back in.
>
> Dan
Dam type-o , Not sqiare but square in the subjet line.

Dan joyce <danj4084@gmail.com> wrote:
> I know this sounds ridiculous but, drawing an --->oo lattice
> because to draw this you have to come back in from --->oo
> to the origin or the center of this --->oo lattice.
....

I've snipped the rest because I didn't understand it -- for example, I
don't know what you mean by "A is just the pixel length", or by
notations like "R=A", "U=A" etc., or what the lists of numbers are,
what "executed" means, what a "pass" is, and so forth.

That said, I have the idea you are trying to define a sequence of
links between adjacent points in the 2D square lattice, to obtain a
single-line trace that is space-filling about the origin. Below is a
proof-sketch that it can't be done. (There might be a simpler proof
via Euler's Theorem.)

Note, by "single-line trace that is space-filling about the origin" I
mean an indefinitely long non-crossing trace on the lattice which
draws adjacent unit segments sequentially such that "done distance"
grows without bound as the trace is made, where done distance is the
distance from the origin to the first undrawn segment.

1: Define a "two in a row" problem (2RP for short), in which if we
ever draw two units connected in line with the pencil point not at
their midpoint, we can immediately declare failure as it will
immediately cap done distance at that point.

2RP example: Eg draw URDLD (a shape that resembles P). There are two
units in line from (0,1) to (0,-1) and the pencil point is not at
(0,0), the midpoint. Clearly there is no way to continue drawing if
we ever draw the link from (-1,0) to (0,0). A space-filling curve
must continue indefinitely and its done distance must grow without
bound. Thus any trace that starts with URDLD cannot be space-filling
about the origin.

2: With no loss of generality suppose the first step in a curve is U.
Suppose after any number of steps we approach the origin for the first
time since leaving it. At this point, one line (U) leaves the origin
and none of the other three origin-neighbor links are filled in.
There are 3 cases to consider: approaches via U, L, or R.

2U: Suppose we approach via U from (0,-1). If we follow that with an
L or an R step from the origin, we create a 2RP between (0,-1) and
(0,1). Therefore case 2U fails.

2L: Suppose we approach via L step from (1,0). If we follow that with
an L, we create a 2RP between (-1, 0) and (1,0); or if we follow with
a D, we create a 2RP between (0,-1) and (0,1). Therefore case 2L fails.

2R: Like 2L mirrored.

Since all 3 cases failed, there is no infinite non-crossing trace
starting from the origin that is space-filling about the origin.

On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:

Too easy.

Infinity borderline 1*10^604

Go across then go down. Some pieces you go over a second time.

A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before..

Then some wiseguy would say, just cover your printing press with ink and stamp the Grid

On Tuesday, June 6, 2023 at 12:45:01 AM UTC-4, James Waldby wrote:
> Dan joyce <danj...@gmail.com> wrote:
> > I know this sounds ridiculous but, drawing an --->oo lattice
> > because to draw this you have to come back in from --->oo
> > to the origin or the center of this --->oo lattice.
> ...
>
> I've snipped the rest because I didn't understand it -- for example, I
> don't know what you mean by "A is just the pixel length", or by
> notations like "R=A", "U=A" etc., or what the lists of numbers are,
> what "executed" means, what a "pass" is, and so forth.

Using different values for A is just how long is the pixel length of A that
you want. Ex. 0.1 up to 10 , If doing a large lattice to fit on the screen
a smaller value of A is required.
R=A is just the line drawn to the right @ pixel length A.
U=A is just the line drawn Up @ pixel length A.
L=A is just the line drawn to the left @ pixel length A.
D=A is just the line drawn down @ pixel length A.
I have run from just 10 rotations to 50 that fill the screen with squares after
it runs out to the end and returns filling in the squares.
> That said, I have the idea you are trying to define a sequence of
> links between adjacent points in the 2D square lattice, to obtain a
> single-line trace that is space-filling about the origin. Below is a
> proof-sketch that it can't be done. (There might be a simpler proof
> via Euler's Theorem.)

I have the algorithm that works.
A simple basic program I recently put together.
It only uses a limited number of directions and relies on the integers
in each of the 2 sequences that have a pattern for drawng a square lattice
going out on the first sequence and then coming back in on the second
sequence. Adding 4 more of the pattern digits to the end of the first sequence
adds one more complete 360 degree rotation to the lattice. So adding these
larger and larger 4 different pattern digits --->oo going out.
As you add 4 differnt pattern digits you also have to add to the beginning
of the second sequence 4 of its own pattern digits. One set for one, and one
set for the other.
It gets a little dicey, but it works.
Instead of requiring a huge list of directions for a large lattice--- R,L,U,D it just
uses a small set amout and relies on the pattern integers in both going out and
coming back in sequences. Creating many passes from digits for R,L,U,D to form
whatever size lattice you want depending on how many sets of 4 digits added
to both sequences.

I know posting code is frowned upon.
I can send you the code and I am sure you will get what's going on!

Nuff said!
> Note, by "single-line trace that is space-filling about the origin" I
> mean an indefinitely long non-crossing trace on the lattice which
> draws adjacent unit segments sequentially such that "done distance"
> grows without bound as the trace is made, where done distance is the
> distance from the origin to the first undrawn segment.
>
> 1: Define a "two in a row" problem (2RP for short), in which if we
> ever draw two units connected in line with the pencil point not at
> their midpoint, we can immediately declare failure as it will
> immediately cap done distance at that point.
>
> 2RP example: Eg draw URDLD (a shape that resembles P). There are two
> units in line from (0,1) to (0,-1) and the pencil point is not at
> (0,0), the midpoint. Clearly there is no way to continue drawing if
> we ever draw the link from (-1,0) to (0,0). A space-filling curve
> must continue indefinitely and its done distance must grow without
> bound. Thus any trace that starts with URDLD cannot be space-filling
> about the origin.
>
> 2: With no loss of generality suppose the first step in a curve is U.
> Suppose after any number of steps we approach the origin for the first
> time since leaving it. At this point, one line (U) leaves the origin
> and none of the other three origin-neighbor links are filled in.
> There are 3 cases to consider: approaches via U, L, or R.
>
> 2U: Suppose we approach via U from (0,-1). If we follow that with an
> L or an R step from the origin, we create a 2RP between (0,-1) and
> (0,1). Therefore case 2U fails.
>
> 2L: Suppose we approach via L step from (1,0). If we follow that with
> an L, we create a 2RP between (-1, 0) and (1,0); or if we follow with
> a D, we create a 2RP between (0,-1) and (0,1). Therefore case 2L fails.
>
> 2R: Like 2L mirrored.
>
> Since all 3 cases failed, there is no infinite non-crossing trace
> starting from the origin that is space-filling about the origin.

Are you sure about that Archi?

On 6/6/2023 10:34 AM, Dan joyce wrote:
> On Tuesday, June 6, 2023 at 12:45:01 AM UTC-4, James Waldby wrote:
>> Dan joyce <danj...@gmail.com> wrote:
>>> I know this sounds ridiculous but, drawing an --->oo lattice
>>> because to draw this you have to come back in from --->oo
>>> to the origin or the center of this --->oo lattice.
>> ...
>>
>> I've snipped the rest because I didn't understand it -- for example, I
>> don't know what you mean by "A is just the pixel length", or by
>> notations like "R=A", "U=A" etc., or what the lists of numbers are,
>> what "executed" means, what a "pass" is, and so forth.
>
> Using different values for A is just how long is the pixel length of A that
> you want. Ex. 0.1 up to 10 , If doing a large lattice to fit on the screen
[...]

You need to create an n-ary plane then map it to pixels. So your drawing
commands can be, for 2-ary:

line({0, 0}, {1, 0})

This draws a line from the origin of the plane to a point with the x
component of 1 and the y component of 0. This line is the length of a
unit. The unit is 1. A thousand pixels might be required to draw this
line. The point is, that it does not matter how many pixels, your code
will draw that line.

Once you get the mapping correct, you can display it on any screen
dimensions. You abstract the plotting code away from using raw pixels.

I might have some free time. Feeling like taking a little break from my
project.

Read all when you get some free time to burn:

https://pastebin.com/raw/322XAnsT

On Tuesday, June 6, 2023 at 3:51:20 PM UTC-4, Chris M. Thomasson wrote:
> On 6/6/2023 10:34 AM, Dan joyce wrote:
> > On Tuesday, June 6, 2023 at 12:45:01 AM UTC-4, James Waldby wrote:
> >> Dan joyce <danj...@gmail.com> wrote:
> >>> I know this sounds ridiculous but, drawing an --->oo lattice
> >>> because to draw this you have to come back in from --->oo
> >>> to the origin or the center of this --->oo lattice.
> >> ...
> >>
> >> I've snipped the rest because I didn't understand it -- for example, I
> >> don't know what you mean by "A is just the pixel length", or by
> >> notations like "R=A", "U=A" etc., or what the lists of numbers are,
> >> what "executed" means, what a "pass" is, and so forth.
> >
> > Using different values for A is just how long is the pixel length of A that
> > you want. Ex. 0.1 up to 10 , If doing a large lattice to fit on the screen
> [...]
>
> You need to create an n-ary plane then map it to pixels. So your drawing
> commands can be, for 2-ary:
>
> line({0, 0}, {1, 0})
>
> This draws a line from the origin of the plane to a point with the x
> component of 1 and the y component of 0. This line is the length of a
> unit. The unit is 1. A thousand pixels might be required to draw this
> line. The point is, that it does not matter how many pixels, your code
> will draw that line.
>
> Once you get the mapping correct, you can display it on any screen
> dimensions. You abstract the plotting code away from using raw pixels.
>
> I might have some free time. Feeling like taking a little break from my
> project.
>
> Read all when you get some free time to burn:
>
> https://pastebin.com/raw/322XAnsT

I have been trying to download my video of a large square lattice in slow-mo.
to e-mail to you but it runs in 38 seconds. To large for e-mail.
I have to find some web site to commpress the video before I can send it by e-mail.

On Tuesday, June 6, 2023 at 4:00:09 PM UTC-4, Dan joyce wrote:
> On Tuesday, June 6, 2023 at 3:51:20 PM UTC-4, Chris M. Thomasson wrote:
> > On 6/6/2023 10:34 AM, Dan joyce wrote:
> > > On Tuesday, June 6, 2023 at 12:45:01 AM UTC-4, James Waldby wrote:
> > >> Dan joyce <danj...@gmail.com> wrote:
> > >>> I know this sounds ridiculous but, drawing an --->oo lattice
> > >>> because to draw this you have to come back in from --->oo
> > >>> to the origin or the center of this --->oo lattice.
> > >> ...
> > >>
> > >> I've snipped the rest because I didn't understand it -- for example, I
> > >> don't know what you mean by "A is just the pixel length", or by
> > >> notations like "R=A", "U=A" etc., or what the lists of numbers are,
> > >> what "executed" means, what a "pass" is, and so forth.
> > >
> > > Using different values for A is just how long is the pixel length of A that
> > > you want. Ex. 0.1 up to 10 , If doing a large lattice to fit on the screen
> > [...]
> >
> > You need to create an n-ary plane then map it to pixels. So your drawing
> > commands can be, for 2-ary:
> >
> > line({0, 0}, {1, 0})
> >
> > This draws a line from the origin of the plane to a point with the x
> > component of 1 and the y component of 0. This line is the length of a
> > unit. The unit is 1. A thousand pixels might be required to draw this
> > line. The point is, that it does not matter how many pixels, your code
> > will draw that line.
> >
> > Once you get the mapping correct, you can display it on any screen
> > dimensions. You abstract the plotting code away from using raw pixels.
> >
> > I might have some free time. Feeling like taking a little break from my
> > project.
> >
> > Read all when you get some free time to burn:
> >
> > https://pastebin.com/raw/322XAnsT
> I have been trying to download my video of a large square lattice in slow-mo.
> to e-mail to you but it runs in 38 seconds. To large for e-mail.
> I have to find some web site to commpress the video before I can send it by e-mail.

Chris, did you recieve the last video I sent you?
That was the new algorithm in action using a small number of directions.
It was slowed down a lot because it will display the whole square lattice in a split second.
It can be appreciated more slowed down to see the outward path and then the inward path.
taking shape as a whole square lattice.
Plus, you would never draw a pencil line that fast. ;-)

On 6/6/2023 3:38 PM, Dan joyce wrote:
> On Tuesday, June 6, 2023 at 4:00:09 PM UTC-4, Dan joyce wrote:
>> On Tuesday, June 6, 2023 at 3:51:20 PM UTC-4, Chris M. Thomasson wrote:
>>> On 6/6/2023 10:34 AM, Dan joyce wrote:
>>>> On Tuesday, June 6, 2023 at 12:45:01 AM UTC-4, James Waldby wrote:
>>>>> Dan joyce <danj...@gmail.com> wrote:
>>>>>> I know this sounds ridiculous but, drawing an --->oo lattice
>>>>>> because to draw this you have to come back in from --->oo
>>>>>> to the origin or the center of this --->oo lattice.
>>>>> ...
>>>>>
>>>>> I've snipped the rest because I didn't understand it -- for example, I
>>>>> don't know what you mean by "A is just the pixel length", or by
>>>>> notations like "R=A", "U=A" etc., or what the lists of numbers are,
>>>>> what "executed" means, what a "pass" is, and so forth.
>>>>
>>>> Using different values for A is just how long is the pixel length of A that
>>>> you want. Ex. 0.1 up to 10 , If doing a large lattice to fit on the screen
>>> [...]
>>>
>>> You need to create an n-ary plane then map it to pixels. So your drawing
>>> commands can be, for 2-ary:
>>>
>>> line({0, 0}, {1, 0})
>>>
>>> This draws a line from the origin of the plane to a point with the x
>>> component of 1 and the y component of 0. This line is the length of a
>>> unit. The unit is 1. A thousand pixels might be required to draw this
>>> line. The point is, that it does not matter how many pixels, your code
>>> will draw that line.
>>>
>>> Once you get the mapping correct, you can display it on any screen
>>> dimensions. You abstract the plotting code away from using raw pixels.
>>>
>>> I might have some free time. Feeling like taking a little break from my
>>> project.
>>>
>>> Read all when you get some free time to burn:
>>>
>>> https://pastebin.com/raw/322XAnsT
>> I have been trying to download my video of a large square lattice in slow-mo.
>> to e-mail to you but it runs in 38 seconds. To large for e-mail.
>> I have to find some web site to commpress the video before I can send it by e-mail.
>
> Chris, did you recieve the last video I sent you?
> That was the new algorithm in action using a small number of directions.
> It was slowed down a lot because it will display the whole square lattice in a split second.
> It can be appreciated more slowed down to see the outward path and then the inward path.
> taking shape as a whole square lattice.
> Plus, you would never draw a pencil line that fast. ;-)

I got it! I might have some time to recreate it in my C++ plotter
program. I have to read your BASIC code. Sorry I have not been able to
work on it lately, been busy.

On Tuesday, June 6, 2023 at 6:55:41 PM UTC-4, Chris M. Thomasson wrote:
> On 6/6/2023 3:38 PM, Dan joyce wrote:
> > On Tuesday, June 6, 2023 at 4:00:09 PM UTC-4, Dan joyce wrote:
> >> On Tuesday, June 6, 2023 at 3:51:20 PM UTC-4, Chris M. Thomasson wrote:
> >>> On 6/6/2023 10:34 AM, Dan joyce wrote:
> >>>> On Tuesday, June 6, 2023 at 12:45:01 AM UTC-4, James Waldby wrote:
> >>>>> Dan joyce <danj...@gmail.com> wrote:
> >>>>>> I know this sounds ridiculous but, drawing an --->oo lattice
> >>>>>> because to draw this you have to come back in from --->oo
> >>>>>> to the origin or the center of this --->oo lattice.
> >>>>> ...
> >>>>>
> >>>>> I've snipped the rest because I didn't understand it -- for example, I
> >>>>> don't know what you mean by "A is just the pixel length", or by
> >>>>> notations like "R=A", "U=A" etc., or what the lists of numbers are,
> >>>>> what "executed" means, what a "pass" is, and so forth.
> >>>>
> >>>> Using different values for A is just how long is the pixel length of A that
> >>>> you want. Ex. 0.1 up to 10 , If doing a large lattice to fit on the screen
> >>> [...]
> >>>
> >>> You need to create an n-ary plane then map it to pixels. So your drawing
> >>> commands can be, for 2-ary:
> >>>
> >>> line({0, 0}, {1, 0})
> >>>
> >>> This draws a line from the origin of the plane to a point with the x
> >>> component of 1 and the y component of 0. This line is the length of a
> >>> unit. The unit is 1. A thousand pixels might be required to draw this
> >>> line. The point is, that it does not matter how many pixels, your code
> >>> will draw that line.
> >>>
> >>> Once you get the mapping correct, you can display it on any screen
> >>> dimensions. You abstract the plotting code away from using raw pixels..
> >>>
> >>> I might have some free time. Feeling like taking a little break from my
> >>> project.
> >>>
> >>> Read all when you get some free time to burn:
> >>>
> >>> https://pastebin.com/raw/322XAnsT
> >> I have been trying to download my video of a large square lattice in slow-mo.
> >> to e-mail to you but it runs in 38 seconds. To large for e-mail.
> >> I have to find some web site to commpress the video before I can send it by e-mail.
> >
> > Chris, did you recieve the last video I sent you?
> > That was the new algorithm in action using a small number of directions..
> > It was slowed down a lot because it will display the whole square lattice in a split second.
> > It can be appreciated more slowed down to see the outward path and then the inward path.
> > taking shape as a whole square lattice.
> > Plus, you would never draw a pencil line that fast. ;-)
> I got it! I might have some time to recreate it in my C++ plotter
> program. I have to read your BASIC code. Sorry I have not been able to
> work on it lately, been busy.

No problem. You can post it if you like. Many smarter then I don't believe this is possible but
the proof is in the pudding. The pudding being my algorithm.

On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
Re: Draw an infinite square lattice without lifting the pencil.
>
> Too easy.
>
> Infinity borderline 1*10^604
>
> Go across then go down. Some pieces you go over a second time.
>
> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
>
> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.

Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.

So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.

So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.

Now we can bunch up the loops of electricity and that of magnetism.

But the game now is to bunch them up to form a Grid System.

AP

On 6/4/2023 10:18 AM, Dan joyce wrote:
> I know this sounds rediculus but, drawing an --->oo lattice
> because to draw this you have to come back in from --->oo
> to the origin or the center of this --->oo lattice.
>
> B = the multiple data points in the first integer listiong at

Lern hau two Enlgish

On 06/06/2023 05:44, James Waldby wrote:
> Dan joyce <danj4084@gmail.com> wrote:
>> I know this sounds ridiculous but, drawing an --->oo lattice
>> because to draw this you have to come back in from --->oo
>> to the origin or the center of this --->oo lattice.
> ...
>
> I've snipped the rest because I didn't understand it -- for example, I
> don't know what you mean by "A is just the pixel length", or by
> notations like "R=A", "U=A" etc., or what the lists of numbers are,
> what "executed" means, what a "pass" is, and so forth.
>
> That said, I have the idea you are trying to define a sequence of
> links between adjacent points in the 2D square lattice, to obtain a
> single-line trace that is space-filling about the origin. Below is a
> proof-sketch that it can't be done. (There might be a simpler proof
> via Euler's Theorem.)
>
> Note, by "single-line trace that is space-filling about the origin" I
> mean an indefinitely long non-crossing trace on the lattice which
> draws adjacent unit segments sequentially such that "done distance"
> grows without bound as the trace is made, where done distance is the
> distance from the origin to the first undrawn segment.
>
> 1: Define a "two in a row" problem (2RP for short), in which if we
> ever draw two units connected in line with the pencil point not at
> their midpoint, we can immediately declare failure as it will
> immediately cap done distance at that point.
>
> 2RP example: Eg draw URDLD (a shape that resembles P). There are two
> units in line from (0,1) to (0,-1) and the pencil point is not at
> (0,0), the midpoint. Clearly there is no way to continue drawing if
> we ever draw the link from (-1,0) to (0,0). A space-filling curve
> must continue indefinitely and its done distance must grow without
> bound. Thus any trace that starts with URDLD cannot be space-filling
> about the origin.
>
> 2: With no loss of generality suppose the first step in a curve is U.
> Suppose after any number of steps we approach the origin for the first
> time since leaving it. At this point, one line (U) leaves the origin
> and none of the other three origin-neighbor links are filled in.
> There are 3 cases to consider: approaches via U, L, or R.
>
> 2U: Suppose we approach via U from (0,-1). If we follow that with an
> L or an R step from the origin, we create a 2RP between (0,-1) and
> (0,1). Therefore case 2U fails.
>
> 2L: Suppose we approach via L step from (1,0). If we follow that with
> an L, we create a 2RP between (-1, 0) and (1,0); or if we follow with
> a D, we create a 2RP between (0,-1) and (0,1). Therefore case 2L fails.
>
> 2R: Like 2L mirrored.
>
> Since all 3 cases failed, there is no infinite non-crossing trace
> starting from the origin that is space-filling about the origin.
>

I think it's simpler just to consider the number of edges at each vertex, which is 4, an even
number. Each "visit" to a vertex (apart from the start / end of a path) takes up two edges, i.e. an
even number. The problem is the start of the path, where just one edge is used, leaving an odd
number of edges to be used later. That can only happen if the path later terminates at the start
vertex [since that is the only way to use a remaining "odd" edge...]. A path that starts and later
terminates after a finite number of steps only covers a finite number of edges, and so fails...

An alternative would be to have an infinite "double-ended" path, so picking an arbitrary starting
point in the path, there will be both an infinite forwards path and an infinite backwards path. In
this case, two edges are used by the /every/ visit to a vertex (there's no start/end of the path),
which just means every vertex must have a first visit and subsequently a second visit later on. No
problem here, and there are obvious (e.g. spiralling based) solutions that work, covering the whole
plane...

Regards,
Mike.

On Tuesday, June 6, 2023 at 10:04:01 PM UTC-4, Mike Terry wrote:
> On 06/06/2023 05:44, James Waldby wrote:
> > Dan joyce <danj...@gmail.com> wrote:
> >> I know this sounds ridiculous but, drawing an --->oo lattice
> >> because to draw this you have to come back in from --->oo
> >> to the origin or the center of this --->oo lattice.
> > ...
> >
> > I've snipped the rest because I didn't understand it -- for example, I
> > don't know what you mean by "A is just the pixel length", or by
> > notations like "R=A", "U=A" etc., or what the lists of numbers are,
> > what "executed" means, what a "pass" is, and so forth.
> >
> > That said, I have the idea you are trying to define a sequence of
> > links between adjacent points in the 2D square lattice, to obtain a
> > single-line trace that is space-filling about the origin. Below is a
> > proof-sketch that it can't be done. (There might be a simpler proof
> > via Euler's Theorem.)
> >
> > Note, by "single-line trace that is space-filling about the origin" I
> > mean an indefinitely long non-crossing trace on the lattice which
> > draws adjacent unit segments sequentially such that "done distance"
> > grows without bound as the trace is made, where done distance is the
> > distance from the origin to the first undrawn segment.
> >
> > 1: Define a "two in a row" problem (2RP for short), in which if we
> > ever draw two units connected in line with the pencil point not at
> > their midpoint, we can immediately declare failure as it will
> > immediately cap done distance at that point.
> >
> > 2RP example: Eg draw URDLD (a shape that resembles P). There are two
> > units in line from (0,1) to (0,-1) and the pencil point is not at
> > (0,0), the midpoint. Clearly there is no way to continue drawing if
> > we ever draw the link from (-1,0) to (0,0). A space-filling curve
> > must continue indefinitely and its done distance must grow without
> > bound. Thus any trace that starts with URDLD cannot be space-filling
> > about the origin.
> >
> > 2: With no loss of generality suppose the first step in a curve is U.
> > Suppose after any number of steps we approach the origin for the first
> > time since leaving it. At this point, one line (U) leaves the origin
> > and none of the other three origin-neighbor links are filled in.
> > There are 3 cases to consider: approaches via U, L, or R.
> >
> > 2U: Suppose we approach via U from (0,-1). If we follow that with an
> > L or an R step from the origin, we create a 2RP between (0,-1) and
> > (0,1). Therefore case 2U fails.
> >
> > 2L: Suppose we approach via L step from (1,0). If we follow that with
> > an L, we create a 2RP between (-1, 0) and (1,0); or if we follow with
> > a D, we create a 2RP between (0,-1) and (0,1). Therefore case 2L fails.
> >
> > 2R: Like 2L mirrored.
> >
> > Since all 3 cases failed, there is no infinite non-crossing trace
> > starting from the origin that is space-filling about the origin.
> >
> I think it's simpler just to consider the number of edges at each vertex, which is 4, an even
> number. Each "visit" to a vertex (apart from the start / end of a path) takes up two edges, i.e. an
> even number. The problem is the start of the path, where just one edge is used, leaving an odd
> number of edges to be used later. That can only happen if the path later terminates at the start
> vertex [since that is the only way to use a remaining "odd" edge...]. A path that starts and later
> terminates after a finite number of steps only covers a finite number of edges, and so fails...
>
> An alternative would be to have an infinite "double-ended" path, so picking an arbitrary starting
> point in the path, there will be both an infinite forwards path and an infinite backwards path. In
> this case, two edges are used by the /every/ visit to a vertex (there's no start/end of the path),
> which just means every vertex must have a first visit and subsequently a second visit later on. No
> problem here, and there are obvious (e.g. spiralling based) solutions that work, covering the whole
> plane...
>
> Regards,
> Mike.
Chris has my video drawing this square lattice image in slow-mo and is working with my code translating into his c++ plotter code. So the proof is soon to be revield.
I just added, in groups of 4 many more groups of pattern numbers to increase the size of this square lattice going out and likewise adding the different pattern of the in going path with the same number of groups.
Gives about 18 360 degrees rotations from the center of the square lattice..
Imagine how long that list of individual directions would be?
This algorithm does away with that and uses integers to give these few basic R,U,LU,R,D,L,D multiple
passes controled by the pattern of integers in both going out and then comming back in. Two different
patterns.The first sequence of groups of 4 integers gets added to the end of that list for going out.
Comming back in the new groups are added to the beginning of the second sequence.
Within the algorithm there is a break point that recognizes the largest number in the going out path
which is the end number of the last group entered in the first sequence.This directs the program to the return path module which draws off the second sequence thus drawing back to the center of the square
lattice. Never retracing or crossing a line.
It is interesting.

On 6/6/2023 8:00 PM, Dan joyce wrote:
> On Tuesday, June 6, 2023 at 10:04:01 PM UTC-4, Mike Terry wrote:
>> On 06/06/2023 05:44, James Waldby wrote:
>>> Dan joyce <danj...@gmail.com> wrote:
[...]
> Chris has my video drawing this square lattice image in slow-mo and is working with my code translating into his c++ plotter code. So the proof is soon to be revield.

Just to clarify, I have not ported his BASIC code to my C++ plotter code
yet. However, it should be rather straightforward.

> I just added, in groups of 4 many more groups of pattern numbers to increase the size of this square lattice going out and likewise adding the different pattern of the in going path with the same number of groups.
> Gives about 18 360 degrees rotations from the center of the square lattice.
> Imagine how long that list of individual directions would be?
> This algorithm does away with that and uses integers to give these few basic R,U,LU,R,D,L,D multiple
> passes controled by the pattern of integers in both going out and then comming back in. Two different
> patterns.The first sequence of groups of 4 integers gets added to the end of that list for going out.
> Comming back in the new groups are added to the beginning of the second sequence.
> Within the algorithm there is a break point that recognizes the largest number in the going out path
> which is the end number of the last group entered in the first sequence.This directs the program to the return path module which draws off the second sequence thus drawing back to the center of the square
> lattice. Never retracing or crossing a line.
> It is interesting.

On 6/6/2023 8:00 PM, Dan joyce wrote:
[...]

Can you please send me your most recent BASIC code right now, just so we
are on the same page, for sure? I am having a hard time tying to find
that post in my emails. Wait, think I just found it...

https://i.ibb.co/fGj8xF7/image.png

Is this your most recent code? Thanks.

On Tuesday, June 6, 2023 at 8:03:28 PM UTC-5, Archimedes Plutonium wrote:
> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> > On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> Re: Draw an infinite square lattice without lifting the pencil.
> >
> > Too easy.
> >
> > Infinity borderline 1*10^604
> >
> > Go across then go down. Some pieces you go over a second time.
> >
> > A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
> >
> > Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
>
> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
>
> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
>
> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
>
> Now we can bunch up the loops of electricity and that of magnetism.
>
> But the game now is to bunch them up to form a Grid System.
>

Now I have not made any progress on the Principle of Superposition of Light Waves, and here maybe that opportunity.

So instead of the silly human drawing a Grid System with pencil and not able to lift off paper, which is probably a nice puzzle that goes nowhere. Here we want to glimpse into what is Electromagnetic Force of physics how Light Waves can stack with no problems.

So now, consider yourself and all the respondents in this thread, not at home on computer or school in classroom but consider yourself at a Circus. And you come to a booth of flashing neon lights titled-- Make a Grid System.

And what is handed to you if willing to play is hoola hoops all the same size and the object is to throw them around a cylinder

| |
| |

So as to stack them into a coil.

More later....

AP

On 6/6/2023 9:33 PM, Chris M. Thomasson wrote:
> On 6/6/2023 8:00 PM, Dan joyce wrote:
> [...]
>
> Can you please send me your most recent BASIC code right now, just so we
> are on the same page, for sure? I am having a hard time tying to find
> that post in my emails. Wait, think I just found it...
>
> https://i.ibb.co/fGj8xF7/image.png
>
> Is this your most recent code? Thanks.

Its been a while since I read BASIC code.

The data portion is not fun to deal with in any BASIC code, but this
seems a little cryptic. I will take a look at it tonight.

550 DATA
1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
,15,17,16,18,17,19,18
560 REM The data above can be carried much higher depending on what you
give t
he pixel value of A to keep the lattice all on the screen.
570 REM if you increase the data by 4 in the 1st going out lattice then
the seco
nd one has to be incresed by 4. example --- add to the end of the first
data l
ine 20,19,21,20 - add 20,19,19,18 to the begining of the second data line.
580 DATA
18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
4,4,3,3,2,2,1,1

On 6/6/2023 9:37 PM, Chris M. Thomasson wrote:
> On 6/6/2023 9:33 PM, Chris M. Thomasson wrote:
>> On 6/6/2023 8:00 PM, Dan joyce wrote:
>> [...]
>>
>> Can you please send me your most recent BASIC code right now, just so
>> we are on the same page, for sure? I am having a hard time tying to
>> find that post in my emails. Wait, think I just found it...
>>
>> https://i.ibb.co/fGj8xF7/image.png
>>
>> Is this your most recent code? Thanks.
>
> Its been a while since I read BASIC code.
>
> The data portion is not fun to deal with in any BASIC code, but this
> seems a little cryptic. I will take a look at it tonight.
>
> 550 DATA
> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
> ,15,17,16,18,17,19,18
> 560 REM The data above can be carried much higher depending on what you
> give   t
> he pixel value of A to keep the lattice all on the screen.
> 570 REM if you increase the data by 4 in the 1st going out lattice then
> the seco
> nd one has to be incresed by 4. example --- add to the end of the first
> data   l
> ine 20,19,21,20 - add 20,19,19,18 to the begining of the second data line.
> 580 DATA
> 18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
> 4,4,3,3,2,2,1,1

These must be offsets?

On 6/6/2023 9:38 PM, Chris M. Thomasson wrote:
> On 6/6/2023 9:37 PM, Chris M. Thomasson wrote:
>> On 6/6/2023 9:33 PM, Chris M. Thomasson wrote:
>>> On 6/6/2023 8:00 PM, Dan joyce wrote:
>>> [...]
>>>
>>> Can you please send me your most recent BASIC code right now, just so
>>> we are on the same page, for sure? I am having a hard time tying to
>>> find that post in my emails. Wait, think I just found it...
>>>
>>> https://i.ibb.co/fGj8xF7/image.png
>>>
>>> Is this your most recent code? Thanks.
>>
>> Its been a while since I read BASIC code.
>>
>> The data portion is not fun to deal with in any BASIC code, but this
>> seems a little cryptic. I will take a look at it tonight.
>>
>> 550 DATA
>> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
>> ,15,17,16,18,17,19,18
>> 560 REM The data above can be carried much higher depending on what
>> you give   t
>> he pixel value of A to keep the lattice all on the screen.
>> 570 REM if you increase the data by 4 in the 1st going out lattice
>> then the seco
>> nd one has to be incresed by 4. example --- add to the end of the
>> first data   l
>> ine 20,19,21,20 - add 20,19,19,18 to the begining of the second data
>> line.
>> 580 DATA
>> 18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
>> 4,4,3,3,2,2,1,1
>
> These must be offsets?

Is this GW-BASIC? God, its been decades since I have read BASIC code!

On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> Re: Draw an infinite square lattice without lifting the pencil.
>>
>> Too easy.
>>
>> Infinity borderline 1*10^604
>>
>> Go across then go down. Some pieces you go over a second time.
>>
>> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
>>
>> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
>
> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
>
> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
>
> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
>
> Now we can bunch up the loops of electricity and that of magnetism.
>
> But the game now is to bunch them up to form a Grid System.

A grid system using a vector field:

https://youtu.be/Q-qEPlK7-NE

On Tuesday, June 6, 2023 at 11:34:38 PM UTC-5, Archimedes Plutonium wrote:
> On Tuesday, June 6, 2023 at 8:03:28 PM UTC-5, Archimedes Plutonium wrote:
> > On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> > > On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> > Re: Draw an infinite square lattice without lifting the pencil.
> > >
> > > Too easy.
> > >
> > > Infinity borderline 1*10^604
> > >
> > > Go across then go down. Some pieces you go over a second time.
> > >
> > > A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
> > >
> > > Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
> >
> > Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete.. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
> >
> > So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
> >
> > So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
> >
> > Now we can bunch up the loops of electricity and that of magnetism.
> >
> > But the game now is to bunch them up to form a Grid System.
> >
> Now I have not made any progress on the Principle of Superposition of Light Waves, and here maybe that opportunity.
>
> So instead of the silly human drawing a Grid System with pencil and not able to lift off paper, which is probably a nice puzzle that goes nowhere. Here we want to glimpse into what is Electromagnetic Force of physics how Light Waves can stack with no problems.
>
> So now, consider yourself and all the respondents in this thread, not at home on computer or school in classroom but consider yourself at a Circus. And you come to a booth of flashing neon lights titled-- Make a Grid System..
>
> And what is handed to you if willing to play is hoola hoops all the same size and the object is to throw them around a cylinder
>
> | |
> | |
>
> So as to stack them into a coil.
>

So now as I am trying to throw rings onto this post and stacking them up into a coil.

Let us imagine like Apples's new vision glasses, their latest new invention of Space that the post is building up rings into a coil

========
And in the vision glasses, I can toss rings perpendicular

=||=||=||=||=||=||=||=||

Rings building coils and rings perpendicular building coils all adding up to a Grid Graphing System.

AP

On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> > On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> >> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> > Re: Draw an infinite square lattice without lifting the pencil.
> >>
> >> Too easy.
> >>
> >> Infinity borderline 1*10^604
> >>
> >> Go across then go down. Some pieces you go over a second time.
> >>
> >> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
> >>
> >> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
> >
> > Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete.. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
> >
> > So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
> >
> > So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
> >
> > Now we can bunch up the loops of electricity and that of magnetism.
> >
> > But the game now is to bunch them up to form a Grid System.
> A grid system using a vector field:

Yes, Chris, buy the new Apple Vision glasses-- $3,500. to build this Grid. And possibly put your fractals out of business.
Cheers from some corners of Earth.

AP

On Wednesday, June 7, 2023 at 1:20:45 AM UTC-4, Chris M. Thomasson wrote:
> On 6/6/2023 9:38 PM, Chris M. Thomasson wrote:
> > On 6/6/2023 9:37 PM, Chris M. Thomasson wrote:
> >> On 6/6/2023 9:33 PM, Chris M. Thomasson wrote:
> >>> On 6/6/2023 8:00 PM, Dan joyce wrote:
> >>> [...]
> >>>
> >>> Can you please send me your most recent BASIC code right now, just so
> >>> we are on the same page, for sure? I am having a hard time tying to
> >>> find that post in my emails. Wait, think I just found it...
> >>>
> >>> https://i.ibb.co/fGj8xF7/image.png
> >>>
> >>> Is this your most recent code? Thanks.
> >>
> >> Its been a while since I read BASIC code.
> >>
> >> The data portion is not fun to deal with in any BASIC code, but this
> >> seems a little cryptic. I will take a look at it tonight.
> >>
> >> 550 DATA
> >> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
> >> ,15,17,16,18,17,19,18
> >> 560 REM The data above can be carried much higher depending on what
> >> you give t
> >> he pixel value of A to keep the lattice all on the screen.
> >> 570 REM if you increase the data by 4 in the 1st going out lattice
> >> then the seco
> >> nd one has to be incresed by 4. example --- add to the end of the
> >> first data l
> >> ine 20,19,21,20 - add 20,19,19,18 to the begining of the second data
> >> line.
> >> 580 DATA
> >> 18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
> >> 4,4,3,3,2,2,1,1
> >
> > These must be offsets?
> Is this GW-BASIC? God, its been decades since I have read BASIC code!

Yes, but I did code Rubic's cube in the day so it can handle tough algorithms.
You would order a random scrambled cube so then you would have to solve it..
Using just numbers 1-6 instead of colors.
It worked great with no glitches after many trial and error runs.
Did you receive my second video?
A much larger version then the first square lattice with many groups of 4 integers added
to each sequence. At the end of the first sequence (going out) and at the beginning of
the second sequence (coming in). Each have their own repeated patterns in each 4 integers
and produces about 18 counter clockwise rotations going out and 18 clockwise rotations
coming back in.
It eliminates a load of directions like in the first version of the code where each direction had to
be assigned for each line drawn. I even have to slow it down with key strokes because it all
forms into a square lattice in a split second. Just by holding any key down it slows it way down.
Tapping keys it slows down to one line drawn for each tap. This way you can spot where it
could possibly retrace a line but it doesn't. The new video takes about a minute and a half to run
where the last video was 38 seconds both in slow-mo a little variation in time between the two
because of different keystrokes (solid or tapping) at different points for each video.

I am now experimenting using a different forground line color coming back in.

When you figure it out, your code will enhance the presentation I am sure.

Any questions?