*Post by Jim Burns*On Wednesday, November 18, 2020 at 1:27:33 PM UTC-5,

*Post by Jim Burns*This seems to be where the incompatibility with infinity

enters your way of doing things: your imagined computers

only deal with constants, and constants are NOT indefinite

references to one of infinitely many. Even what programmers

call variables are not variables in the sense of which

mathematicians are fond.

There are programs which can verify proofs which use these

mathematicians' variables. It seems to me that these programs

avoid any hint of infinity by only dealing in finite

manipulations of conceivably-meaningless finite strings.

Yes I am fond of the computer style of representation and

am wary of the mathematicians who never had to abide by

a compiler.

There are programs which can verify proofs which use these

https://en.wikipedia.org/wiki/Metamath

You're welcome.

At some point, if you continue your studies, you will

realize mathematicians had to "abide by a compiler"

long before there were any computers. The ideas that we

make physical in our computers are mathematical ideas.

I have little doubt that the details you spare me of have

some wishy-washy content.

I see that you don't have to work vary hard to convince

yourself.

What we mean by "ordinal" is

Every non-empty class C of ordinals contains a first

ordinal, an ordinal c such that, for all b in C, c =< b

Assume that some infinite ordinal exists.

Let C be the class of infinite ordinals.

C is non-empty.

The non-empty class C of infinite ordinals contains

_at least one_ ordinal c such that, for all b in C, c =< b

Suppose that, for both c and c' in C,

for all b in C, c =< b and c'=< b

Then c =< c' and c' =< c.

Thus c = c'.

If any infinite ordinal exists,

the first infinite ordinal omega exists and is unique.

Enjoy.

Already the terminology of ordinal as if it is a pure

concept is trouble.

Maybe "as if it is a pure concept" means something to you.

I've described ordinals.

Every non-empty class of them contains a first.

There are consequences to that description being

true of them.

Perhaps the trouble you refer to is not being able

to assign a decimal numeral to omega.

Well, you can't always get what you want.

But maybe, in this case, you get what you need,

omega without a decimal numeral.

Well, you are free to construct and I am free to construct,

We are both constrained by our desire to be understood,

so we only use well-known words in well-known senses.

Suppose, for example, someone decided that omega = 10

instead of that it was the first infinite ordinal.

would be turned into gibberish. No organization or person

exists to administer this punishment, it's how it is.

And there is no one to appeal to for mercy, either.

and I do accept that you are a higher grade mathematician

than I am.

That sounds flattering.

However, whatever my own grade is, as a mathematician,

what we have before us is not higher-grade mathematics.

These are all pretty much introductory topics. I may have

added my personal touch here or there, in an effort to

explain these topics, but a very large percentage of folks

see them and master them, even without my help, and move on.

The exceptions (most of the world's supply of exceptions post

to sci.logic) seem to be people who, for their own reasons,

are determined to not understand them.

If you want to understand, I'm fairly confident that

you will be able to.

I think all that needed is a radix concept atop your ordinal, which does appear to be very clean. Then you'll have w=10. If this notation is acceptable for a finite ordinal:

( a, b, c, d, e ) = C1

( a, b, c, d, e, f ) = C2

we cannot claim that f is the w of C1. Each ordinal as stated is free standing and demands unique symbolic notation. There is no equality nor comparison possible between the a of C1 and the a of C2 right? Particularly if I were to insert a handy null into C2

( 0, a, b, c, d, e, f ) = C3

then we'd like to think that we could do some things between C2 and C3, but every time you go to do something you have to introduce another unique set description because these things are so primitive that they deny ordinary numerical semantics. They are number-like, and they are enumerable in their finite form, and let's face it, the ones in use in modernity go like:

( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ) = Cten

but you see in another galaxy they are probably using

( 1, 2, 3, 4, 5, 6, 0 ) = Cten

and of course this Cten form carries a return zero at the end which is the place of the w, but this value forms a breakpoint in the progression. We are engaged in a progression and to build atop the Ordinal seems fit enough. We can place a zero at the bottom as well and demand the form

0, a, b, c, d, e, f, 0

and we see that the zeros are essentailly the same semantically as braces; they are just another form and a subtly differing meaning. Now we can encode our higher systems from a finite system, and you have no more need of your ordinal fantasy sir. Dismissed. All higher ordinals are representable by lower ordinal systems.

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

| Please note this is not finalized. | (Sorry for the sucky google font)

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

Proof: a high ordinal Cn demands a low ordinal Cten a<b<c<d<e<f<0 so we take a copy of Cn and begin overwriting

Cf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

when we land on Cn we mark this lowest ordinal in a register. We now copy out the zeros which have been marked in our 'false' non-ordinal intermediary and begin marking them

CfCf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

and when we land on the last zero we mark this next ordinal appending the detail in the register. We now copy out the zeros which have been marked in our 'false' non-ordinal intermediary and begin marking them

CfCfCf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

and when we land on the last zero we mark this next lower ordinal c. We now copy out the zeros which have been marked in our 'false' non-ordinal intermediary and begin marking them

CfCfCfCf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

and when we land on the last zero we mark this next lower ordinal d. We now copy out the zeros which have been marked in our 'false' non-ordinal intermediary and begin marking them

CfCfCfCfCf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

and when we land on the last zero we mark this next lower ordinal e. We now copy out the zeros which have been marked in our 'false' non-ordinal intermediary and begin marking them

CfCfCfCfCfCf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

and when we land on the last zero we mark this next lower ordinal f. We now copy out the zeros which have been marked in our 'false' non-ordinal intermediary and begin marking them

CfCfCfCfCfCfCf = a,b,c,d,e,f,0,a,b,c,d,e,f,0, ...

and when we land on the last zero we mark this next lower ordinal 0. This completes the first round of disentangling Cn onto Cten. If we are done, e.g. had we run out of zeros at stage c we simply have to halt, or generate an empty signal which will merely repeat endlessly. Thus we have a formal halting condition here. Our results under this stage c condition could read:

a a b

or any such combination of Cf ordinals. The most extreme or greatest ordinal is

0 0 0 0 0 0 0

which carries a nice semblance with infinity. The first ordinal is

a

which is appropriate enough. It certainly handles ordinals smaller than Cten. I'm really getting tired of all this viciously repetetive typing here so I will stop here. I don't like the Cf^n repetition but I do believe it does have to stop for the moment where it is. The next course of this sytem grows out farther but we should not just keep going here. It is as if we are in a hardware implementation. You must build your next lathe with a lathe, but the first lathe has to be built from scratch; freehand style. I'm wondering where the element ten turns up...

1, 2, 3, 4, 5, 6, 7, 8, 9, 0 : a, b, c, d, e, f, 0

in Cf puts 10 at

0

so I guess I have zero problem, but this will get fixed up. I will prepend a note above to point out that this is not finalized. Still it looks as if in this style you simply append zero to your infinite ordinal, and because it breaks the progression it acts as an omega in this style of system. The zero itself is the aleph and this is my mistake above. Well, sort of; there is still a bit of disambiguation for me to do here, and in time the zero turns to 10, where the one in ten is the first element, and zero is the aleph, in this case of a non-zero originated system.

sage: help( "ordinal" )

No Python documentation found for 'ordinal'.

Use help() to get the interactive help utility.

Use help(str) for help on the str class.

sage: help( "Ordinal" )

No Python documentation found for 'Ordinal'.

Use help() to get the interactive help utility.

Use help(str) for help on the str class.

sage: help( Ordinal )

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

NameError Traceback (most recent call last)

<ipython-input-10-f1751ffbc554> in <module>()

----> 1 help( Ordinal )

NameError: name 'Ordinal' is not defined

sage: help( ordinal )

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

NameError Traceback (most recent call last)

<ipython-input-11-627559457903> in <module>()

----> 1 help( ordinal )

NameError: name 'ordinal' is not defined

sage: