i'm curious if you could tell me more about closure. it seems like a useful shift in thinking when moving higher up the transfinite hierarchy

The closure of a set over an operation is the set you get by repeatedly applying that operation to its elements.

For example, the naturals are the closure of {0} over n → n+1

Formally, define C(0) as the given set and recursively C(n+1) as C(n) U {f(x1, x2, ...) | xi in C(n) for all i}. The closure is the union over all C(n).

It's the basic structure you'll find in any ordinal collapsing function FYI.

ok, i have seen that before

how would i write out what omega is the closure of?

what about omega_1?

You can't

ok..

At least not in terms of less than omega_1 elements or omega_1 functions/operations

As a fun fact, for these kinds of things, I prefer to think of omega_1 in terms of stationary points.

i'm not familiar with stationary points

Uncountable regular ordinals are the ordinals alpha where every function f : alpha → alpha has an ordinal beta < alpha where beta is closed under f.

sounds simple enough

If you're familiar with ordinal collapsing functions, then you can think of them as the theoretical points where "vague recursive function" can never accidentally go all the way up to alpha, but always gets capped out before then

i have mostly seen ocfs that use w_1 - which i presume these will cap out before w_1. i just started seeing ocfs with inaccessibles recently. but i presume these will cap out before inaccessibles. is that correct?

Yes. Ultimately the behavior is usually the same, there is nothing spectacularly different. You should even be able to swap between the usual Veblen function and the modified one with relative ease.

quick aside: how familiar are you with surreal numbers?

not very

ok, i'm most familiar with the veblen function, so perhaps we can talk more in that context. what i'm struggling with is how to swap between the og version & modifications. do i just magically pull things like w_1 or k (an inaccessible) out of a hat or ??

you mentioned listing fundamental sequences is not the right strategy for things like w_1 & k

That's simply not how the Veblen function is defined to begin with

i wish i had a better grasp on veblen, ocfs, ordinals & cardinals so i could more concisely communicate my thinking

You are comfortable with me saying that φ(a, b) is the bth ordinal closed under (x, y) → φ(x, y) restricted to x < a? (At least for a less than φ(1, 0, 0))

more or less

Well you can define the general Veblen as the closure of the sum of its arguments over addition and itself lexicographically.

Except for φ(0) = omega^0 = 1 because that's wonky with the sum of arguments

So for example, φ(1) is the closure of 1 = {0} over addition and (x) → φ(x) for x < 1.

The closure of {0} over (x) → φ(x) gives us {0, 1}, and you can build all the naturals by repeatedly adding 1 with itself

So φ(1) = {0, 1, 2, ...} = omega.

In general, omega^alpha is the alpha-th ordinal closed under addition.

φ(epsilon)?

$\phi_0(\varepsilon_0)=\phi_1(0)$ ?

Well yeah, since they both equal $\varepsilon_0$

so epsilon is the epsilon-th oridnal closed under addition?

Yes, since omega^epsilon = epsilon is the epsilon-th ordinal closed under addition

Also note we get past ε0 in φ(ε0+1) since the sum of the arguments, ε0+1, contains ε0.

You can also easily derive fundamental sequences from closures by looking at what the "most significant operation" is

or something like that

in the case of φ(ε0+1), you can easily see the largest thing is going to come from repeatedly adding ε0 to itself

deriving fundamental sequences from closures is something im going to look into more

maybe this question i asked might give some insight into how im approaching things: math.stackexchange.com/questions/3006787/…

it also might not!

I am not familiar with such @meowzz

no worries.

i gotta run for now. thanks again for taking the time to chat! i might ping you again sometime if i can get my thoughts sorted-

one quick(?) question before i go: what do you make of the xi function from my post?

my idea was to create a veblen esque structure where the 1st tier is the original veblen function

@meowzz as I said in my comment, I can't tell what anything after φ''(0) is supposed to be

As I mentioned in my answer, regardless of what it is though, it likely isn't larger than what the Veblen function can already do

alright. thanks again-

Oh snap, I missed a conversation about Veblen ordinals.

Okay, looks like not a huge one.

(I was crossing my fingers there was more talk about the ternary Veblen function, because I don't really understand it at all yet.)

@MaliceVidrine it was about arbitrarily many arguments

Most of everything is explained above, except for what lexicographical ordering is

@MaliceVidrine Not sure what is "ternary veblen", but the large veblen ordinal hierarchy can be understood by some prototypical examples. First the terms are 0 and φ(m,x) where x is a term and m is a finite list of pairs of terms where each pair (i,k) represents that the i-th parameter of φ is k. φ([[0,k]],x) represents the binary φ function; the Feferman-Schutte ordinal is Γ = sup { 0 , φ([[0,0]],0) , φ([[0,φ([[0,0]],0)]],0) , ... }.

If i<ω in each pair (i,k) in m, then the small veblen ordinal is sup { φ([[n,1]],0) : n<ω }.

The large veblen ordinal is sup { 0 , φ([[0,1]],0) , φ([[φ([[0,1]],0),1]],0) , ... }.

The examples are:

φ([],0) = 1.

φ([],1) = ω.

φ([],2) = ω^2.

φ([],x) = ω^x.

φ([[0,1]],0) = { 0 | φ([],~) }, meaning sup { 0 , φ([],0) , φ([],φ([],0)) , ... }

φ([[0,1]],1) = { φ([[0,1]],0)+1 | φ([],~) }, meaning sup { x , φ([],x) , φ([],φ([],x)) , ... } where x = φ([[0,1]],0)+1.

φ([[0,1]],2) = { φ([[0,1]],1)+1 | φ([],~) }.

φ([[0,1]],x) = sup { { φ([[0,1]],y)+1 | φ([],~) } : y<x }.

φ([[0,2]],0) = { 0 | φ([[0,1]],~) }.

φ([[0,2]],x) = sup { { φ([[0,2]],y)+1 | φ([],~) } : y<x }.

φ([[0,k]],0) = sup { { 0 | φ([[0,k']],~) } : k'<k }.

φ([[0,k]],x) = sup { { φ([[0,k]],y)+1 | φ([],~) } : y<x }.

By the way, φ(m,x) ignores any pairs in m of the form [i,0]. So φ([[0,0]],x) = φ([],x).

φ([[1,1]],0) = { 0 | φ([[0,~]],0) } = Γ.

φ([[1,1]],1) = { φ([[1,1]],0)+1 | φ([[0,~]],0) }.

φ([[1,1]],2) = { φ([[1,1]],1)+1 | φ([[0,~]],0) }.

φ([[1,1]],x) = sup { { φ([[1,1]],y)+1 | φ([[0,~]],0) } : y<x }.

φ([[1,1],[0,1]],0) = { 0 | φ([[1,1]],~) }.

φ([[1,1],[0,1]],x) = sup { { φ([[1,1],[0,1]],y)+1 | φ([[1,1]],~) } : y<x }.

Just to compare with the simpler multivariable φ function, φ([[1,j],[0,k]],x) represents φ[j,k](x).

φ([[2,1]],0) = { 0 | φ([[1,~]],0) }.

Now time to accelerate.

φ([[ω,1]],0) = sup { { 0 | φ([[i,~]],0) } : i<ω } = small veblen ordinal.

φ([[ω+1,1]],0) = { 0 | φ([[ω,~]],0) }.

Note that ω = φ([],1) so these are actually terms! For example φ([[ω+1,1]],0) = φ([[φ([],1)+1,1]],0).

And this should give an idea of how it can grow extremely fast, because we are diagonalizing within the parameters of φ themselves, where the index of each parameter is itself given by a term!

In general, the rules for non-trivial m (not all parameters are zero) are:

◇ φ(t+[[i,0]],0) = φ(t,0).

◇ φ(t+[[i,k]],0) = sup { { 0 | φ(t+[[i,k'],[i',~]],0) } : i'<i ∧ k'<k }, where k>0.

◇ φ(t+[[i,k]],x) = sup { { φ(t+[[i,k]],y)+1 | φ(t+[[i,k']],~) } : k'<k ∧ y<x }, where k>0 and x>0.

@MaliceVidrine: Sorry I made a mistake in some of the examples:

φ([[0,2]],x) = sup { { φ([[0,2]],y)+1 | φ([[0,1]],~) } : y<x }.

φ([[0,k]],x) = sup { { φ([[0,k]],y)+1 | φ([[0,k']],~) } : k'<k ∧ y<x }.

And of course in the examples k,x are nonzero.

Oops, the second and third rules above are for i>0. There is one more for i=0. Let me repost them.

◇ φ([],0) = ω^x.

@MaliceVidrine: If my dense symbols look too scary, you can reconstruct the large veblen ordinal on your own based on the following informal idea:

φ takes parameters indexed by ordinals, represented by a list m of pairs of the form (i,k) where i is the index and k is the ordinal. Each φ(m,x) is the least upper bound of iterating something on some starting point. The starting point is 0 if x=0, otherwise it is φ(m,x')+1 for some x'<x. Find the last nonzero parameter of m, decrease it, then iterate by nesting at some point after that.

@user21820 xd I think my definition is must simpler and covers things without countable cofinality

@SimplyBeautifulArt I don't get what you mean. I did not see any definition that you provided.

@user21820 if we define φ(0) = 1 and otherwise φ(...) as the closure of the sum of its arguments over addition and φ with lexicographical ordering (recursion based on most significant arguments) then you should get the usual φ

@SimplyBeautifulArt No...

?

I'm taking the Von Neumann definition of the ordinal here FYI.

Your description is too vague, and even if I interpret it in a way that makes sense you only get the small veblen ordinal.

No you don't?

The ordering used for the recursion is easy to define. You just compare the largest indexed argument of each, and if they're equal, you look at the next argument.

$(3, 2) >_L (3,1) >_L (3,0) >_L (2,\beta) >_L (1,\beta) >_L (0,\beta)$

Unless you write down a mathematically precise definition, there is nothing in your vague English that can get you past the small veblen ordinal.

So $\varphi(3,2)$ starts out with $3+2 = 5 = \{0,1,2,3,4\}$, and closes it by adding the elements and applying $\varphi(\alpha,\beta)$ recursively to make more elements from there, as long as it falls under one of the above.

Which part do you want a more specific definition of?

What?! That makes no sense. Are you saying φ(3,2) includes φ(3,3) just because 3∈5?

No, that's where the lexicographical ordering comes in.

As I said, your vague English makes no sense. Please write down a precise definition.

The ordering over tuples is defined as $(a@x,\dots_1) >_L (b@y,\dots_2)$ iff $x>y$ or $(x=y \land a>b)$ or $(\dots_1) > (\dots_2)$, where $\dots_1$ and $\dots_2$ represent the rest of the arguments.

Is that fine for you?

What on earth is "a@x"?

$a$ at the $x$th argument

Small Veblen ordinal $= \varphi(1@\omega)$ for example

Then firstly that is not lexicographic ordering, and secondly you are using a list of pairs exactly as I did. The difference is that mine is precise and yours was too imprecise to convey the idea correctly.

Furthermore, you will find that if you actually write down the definition of the recursion cases, you will have exactly the same set of cases.

Essentially the 5 cases I gave above. It may be possible to streamline it a bit to 4 cases, at the cost of it becoming less transparent.

Well it's a generalization of lexicographical ordering, if that's more clear.

And I'm not saying you get different cases if you try to write it out in a recursive manner like you had done.

I'm saying that the description simply covers all of the cases in an intuitive manner imho, without splitting the definition into looking at several cases

Of course you can remember it that way. What I was objecting to was you saying that yours was "simpler", when you didn't even mention that φ used a list of parameters indexed by ordinals.....

The natural interpretation of the vague English you wrote only gets you the φ with a finite parameter list and that gives the small veblen ordinal, as you know.

I still fail to see how it is restricted to finite lists, unless you are interpreting this:

54522118:

how do we quote messages again I forgot lol

This was all I had to go on.

:54522118

No indication of indexed arguments.

xd been a while since I've done that

There we go

That was what you wrote later.

You don't get my point, do you?

If you want to convey your ideas to others, you should learn to precisely express them. Even now, although you say "a@x" means "a at the x-th argument", it is actually not at all precise, and I understand you only because I already know what the large veblen ordinal is!

Hmm

Mathematics has very standard ways of being able to express such notions that you want, using standard constructions such as lists and pairs and things like that. You'd have to use them, even as you give 'intuition' alongside.

Alternatively, since you know programming, you can use programming languages.

That's fine too.

Well I've seen my notation used over yours (@'s over listing the entire thing out) more often, as it's unclear what something like [1, ..., 0, 0, 0] is supposed to be, whereas 1@100 isn't ambiguous.

nvm, my bad, you're using lists of 2-tuples

Exactly; that's the correct way to do it. A finite list of pairs.

Note that in my entire mathematical experience I have never come across functions with indexed arguments except in this large countable ordinal business. I can bet with you that almost every mathematician would have the same confusion as I had at your notation.

Hmmm, well although it is clear what you've written, I've not seen anyone else formulate the Veblen function with that notation.

Rather, I've usually seen anyone discuss it with my notation, at least for transfinitely many arguments.

Well it's definitely possible that a small community interested in big numbers and such stuff have been using some non-standard notation. However, the point here is about being precise enough that normal mathematically trained people can understand you easily.

Suppose you want to define your notation. You can opt to do it syntactically as follows:

A parameter list is a finite list of parameters where each parameter is denoted a@x, which is to be interpreted as "the x-th parameter is a".

At least it would be clear to most people what this means, once you've written such a definition down.

(Though it's not a completely good idea if you want to formalize it, because in ZFC you cannot have functions with too many arguments..., but let's not get into that now.)

And then you define your (generalized) lexicographic ordering on parameter lists, and you are good to go.

I gtg for now, but I'll say that I still think summarizing all of your recursive cases as simply "recursion with this simple ordering" is more intuitive and digestible for readers. At least, that's how I feel about it. But yeah, it could've been formalized more properly.

Note that I avoided having to even define lexicographic ordering because I used an ordered list and the recursion mechanism already ensures that the parameters have decreasing indices...

@SimplyBeautifulArt Sure see you next time. You could always experiment by giving your one-line definition to any mathematician (who does not know about the veblen φ) and see whether they understand it. =P

@user21820 as a fun little point of interest, which @meowzz might be interested in as well, it's somewhat easy to extend the Veblen function by considering lists of 3-tuples instead of 2-tuples so that [0, x, y] refers to the old [x, y], and otherwise behaves with the same structure as extending the Veblen function past two arguments.

also how've you been holding up, with recent events and all that, @user21820

@SimplyBeautifulArt I've been fine, thanks for asking. I hope you're safe and sound too!

Same, though I have so many things to do this summer D:

@SimplyBeautifulArt Haha homework?

Or extra activities?

@user21820 something like that :x

Are you an undergraduate now?

also parents are doing house stuff a lot, since they don't have work.

@user21820 Think I have been for a year or two I think ;)

@user21820 those too

Haha I think so too.. Hard to track where everyone is and advance every counter automatically. =P

Feels exhausting for a summer break x.x

Oh, did I mention the generalization to the symmetric difference quotient I found?

@SimplyBeautifulArt Yes I thought of various possible extensions before, but none were very satisfying to me, as if I could not get a clear grasp of the next milestone. Indeed, your mechanism using triples instead of pairs would mean that we can diagonalize the 'index' using the 'super-index'. But it feels underwhelming even if we go all the way up. The closest milestone seems to be at least nested maps.

Namely, instead of just a map from indices to parameters you have a map from indices to maps!

And arbitrarily finite nesting of such maps.

That should go quite high, but not sure whether that is still short of the next milestone.

@user21820 yes of course :P and that's where ordinal collapsing functions are much nicer. I think nestings could go up to the Bachmann-Howard ordinal if done right though.

It looks to me like a close correspondence to higher powers within an ordinal collapsing function such as Madore's

@SimplyBeautifulArt Really? I felt like it wouldn't reach all the way. Could you ask Deedlit for me?

@user21820 sure sure

In terms of Madore's ψ, we have small-veblen = ψ(Ω^(Ω^ω)) and large-veblen = ψ(Ω^(Ω^Ω)), and this nested-map thing feels like only ψ(Ω^(Ω^(Ω^Ω)))...

Though I have no intuition whatsoever about ψ.

If it's just one further nesting then yeah I think that's what you'd get

I meant this should get to the Bachmann-Howard ordinal

Unless I'm misinterpreting

I know, but it would be really interesting if it did, because I had the impression that Bachmann-Howard was really really high.

LoL

I mean

yes if you're trying to reach it with really simple recursion

but not really, at least how I feel about it now =P

as far as ordinal collapsing functions go at least, more like the smallest milestone

It's interesting because ordinal collapsing functions are really impredicative.

This nested-map idea feels more constructive.

That's why I doubted its strength.

Maybe it's even only ψ(Ω^(Ω^(Ω^ω))). Tell you what. I guess it's this. Ask Deedlit if it's wrong. =D

hmm, well I feel like the nested-map idea sounds really optimal and should corresponded to nested power towers (in terms of structure)

Really?

I don't see where else you would fit so much structure in

though our ideas might not be exactly the same =P

Ok let me be more precise. A nested map is like a tree where the indices are on the branches and the values are the subtrees. So for the large veblen φ(m,x) the m is a tree with height 1. Single nesting makes it have height 2, and so on.

Normally, you just decrease a leaf and iterate. But if the leaf is the only leaf, then you have to go up the tree and iterate inside the tree.

Is that sufficient for you to match with your idea?

Not sure whether I can simplify it or not, but that was my idea.

test because I forgot how the markdown is here

rip lol

comparison of the ((2, 7), (0, 5)) and ((2, 6), (0, 5)) is done by repeatedly getting the left-most thing:

((2, 7), (0, 5)) ? ((2, 6), (0, 5))

(2, 7) ? (2, 6)

2 = 2, so go back up and check the next thing:

(2, 7) ? (2, 6)

7 > 6

so the first one is greater than the second one.

I was thinking that the ordering would work like that lol

Yes we compare by most-significant index first.

But that's not actually necessary to construct the ordinal.

then yeah I think we should have the same idea

I mean, we can just look at the last nonzero index.

And get everything underneath it.

But it's not really an extension in the same manner as the triples thing.

Though the triples one embeds into the general one.

I also don't like how the 0's work lol

feels weird to have the large Veblen ordinal be something like φ([[1, 0, 1]], 0) in your notation

bbl8r again xd

Let me write each tree as [a:x,...,b:y] to denote that its first subtree is x connected by edge a, and so on. So φ([1:1],0) would be Γ, and φ([0:[0:1]],0) would be the large veblen ordinal.

@user21820 I like that :-)

Haha..

I think it can be simplified though I haven't thought much about it.

Is Madore's ordinal collapsing function the only ordinal collapsing function you're familiar with?

Well, I did consider some extensions before, but at that point it feels like just using set theory.

lol

At least, ψ is only once impredicative, in that you can take Ω as a placeholder for iteration, and sort of 'see' that it works.

you really prefer using things you can break down to simple fundamental sequences?

Yea!!

I want to see it go down to zero. =D

xP

Just like coronavirus cases.

lol

Well there's a completely differently structured kind of ordinal collapsing function that behaves more like the Veblen function which you might be interested in

The idea is to have ψ_x(y) be the yth ordinal which is closed under the usual recursion

then ψ_x(y) looks like your φ(x, y)

also hey @MaliceVidrine

@user21820 - I'll catch up on all this in a bit, but what I was referring to is the version of the Veblen function that I've seen in a number of places that takes three arguments. "ternary Veblen" was not the phrase; "ternary" is a modifier of "Veblen function".

o/

Yo

@SimplyBeautifulArt You mean ψ[x](y) is the y-th closure under all ψ[x'] for all x'<x, where ψ[0] is the usual Madore's ψ?

Is x allowed to have Ω inside?

I'll write a proper definition in a moment

@MaliceVidrine If you have some context it would be helpful, otherwise I would guess that it is just φ[a,b](x), much less than the small veblen ordinal.

φ[1,0](0) = Γ.

φ[0,1](0) = ε0.

You can define it like so, where enum(A) returns a function f where f(x) is the x-th smallest ordinal in A.

=P I prefer having all my Veblen arguments together though

@user21820 - It could just be that; I have no idea. I'm thinking about the function used in, say, the "meta predicative systems" listed on this page.

@MaliceVidrine Yup then it's definitely what I said.

I would consult wikipedia, but the article there for Veblen functions is hot garbage.

Hmmm, what I posted seems to have a minor flaw, the last line should have $\beta \notin C(\alpha, \beta)$ instead, unless we wish to restrict the output to countable ordinals.

Just above "meta-predicative" we have Γ0 = φ[1,0](0).

@MaliceVidrine hahaha it really is xd

And ATR's p.t.o is known to be Γ[ε0] = φ[1,0](ε0).

@user21820 - Cool, then I will backtrack through the chat and see if I can finally understand the more general Veblen functions...

I feel almost offended by how much I've started to like ordinal analysis. I was trying to dig in to the topic for a project then forget about it, but it's actually turned out to be fun.

lmao

well that's an oof

Hahaha..

Alright I got to go soon.

See you all next time!

Later!

o/

if you're into japanese music I've been loving this one

I'm into a lot of music. Though this week about the only things I've been listening to involve Jeon Soyeon. :P

I'll give that a listen!

:-)

Also if I may, you could try seeing if my explanation of the Veblen function is intuitive for you as it is for me.

Oh snap, that song just got a bounce.

xD

And sure, I'll let you know when I wake up properly and read through the discussion.

Well I'm off to watch kaguya-sama

Take care!

o/ @DaveL.Renfro

@SimplyBeautifulArt FYI, I clicked on "chat" when I saw some comments were moved there, glanced at the comments, then got back to "day job stuff", and later saw a notification. I think this is my first ever Stack Exchange explicit-to-chat comment, although some of my comments (along with other people's comments) have been moved to chat from time to time.

@DaveL.Renfro well you're always welcome

@SimplyBeautifulArt made an update to my MO post. hopefully it is more clear.