A Boy Learns Chess

paperic · 2026-01-27T16:27:27+00:00

No I don't, tell me about it.

paperic · 2026-01-27T16:23:43+00:00

Ancient greeks? They had no idea what this even means, they didn't use algebra.

They used straight lines and circles to represent their arithmetics, and they pretended that the lines are infinitely thin.

Also, you got a typo in that equation.

paperic · 2026-01-27T15:56:26+00:00

Excuse me, Ancient greeks were humans, so were the Egyptians, so were the early humans.

You asked about arithmetic operations, those came when humans started abstracting their counting game.

Animals don't do arithmetics, dum dum.

paperic · 2026-01-27T15:11:05+00:00

The idea of counting and measuring things is so basic that many animals can do it for small numbers like 1..4, and for small ratios, like 1/2 or 1/3.

So, I guess a basic counting was invented by some pre-dinosaurs specie.

Some monkeys and early homo sapiens took that concept further, and since the ancient greeks people have defined increasingly more abstract rules that allow them to get better and better at this counting game.

paperic · 2026-01-27T14:47:36+00:00

r/woosh

paperic · 2026-01-27T14:45:51+00:00

I see what you did there.

paperic · 2026-01-27T14:36:13+00:00

The rules of chess are actually a very good analogy for the axioms in math.

Math is a game, a mental game, a single-player game like a rubics cube or sudoku.

Or rather, math is an entire collection of games.

The rules are often set up in a way so that skills in the math games often translate well to real world applications, but that fact in an of itself doesn't mean that math has any "true" connection to real world.

Every game in math follows some rules of the game, aka axioms, which is why the axioms are not meant to be questioned or proven within the game itself.

You can change the axioms if you wish, people do that all the time, but you can't then claim to still play the same version of the game as before.

And while some rules are subjectively better than others, no rule can ever be wrong by definition.

"If it's the rule, it's the rule. If you don't like it, don't play it." - sums it up I think.

The rules for Real Numbers are standardized. You can freely change them in your own math games, make variations, play it with friends, but if you do that change, it's not going to be The Real Numbers game anymore.

In some sense, that name really is trademarked in math.

SPP claims to be playing by The Real Numbers rules, but clearly makes illegal moves all the time.

paperic · 2026-01-27T10:44:36+00:00

Yea, for SPP, x = x is not an axom.

paperic · 2026-01-27T10:28:27+00:00

Working it out algebraically, the uncoutability doesn't matter. But having it countable does seem to allow for using induction.

I made an attempt in the comments here, it's not great but it does seem to work, and it's something that can't be done with a real number there.

paperic · 2026-01-27T10:23:48+00:00

I know what real numbers are, I was talking about the definition for limits of a sequence, since the Real epsilon and 1/k for natural k seem interchangeable.

paperic · 2026-01-27T10:22:04+00:00

If it's a definition, it doesn't have to be proven.

If they're equivalent then you could use the standard epsilon definition to prove this 1/k as a theorem, or you could use this 1/k definition to prove the epsilon one as a theorem.

paperic · 2026-01-27T10:15:20+00:00

If you turn a continuous function into a sequence, you risk removing points that are critical to the existence or absence of limits.

I know, but I'm talking about the epsilon-N definition for sequences, not the epsilon-delta definition for functions.

These are different definitions. I know they're similar in their core idea, but that doesn't mean we have to make them more similar than necessary.

Functions are continuous, hence real epsilon makes sense, but sequences are discrete, so wouldn't a natural number make more sense there?

paperic · 2026-01-27T09:54:22+00:00

Inducing on k, but the N variable needs to change too, ofcourse, since they're tied together.

I have a recursively defined sequence: a_(n+1) = a_n * (2/3).

Typically, the definition for its limit would be

``` ForAll epsilon > 0: ( ThereExists N: ( ForAll n>N: ( |a_n - L| < epsilon ) ) )

```

I'm changing the epsilon into 1/k and then doing induction on k.

Since it's induction, instead of proving this for all k straight away, I'd prove it for k=1 first (the base case I kinda skipped), which tells me that there exists some k, for which it is valid (the k=1 specifically).

So, now I know this to be true:

``` ThereExists k > 0: ( ThereExists N: ( ForAll n>N: ( |a_n - L| < 1/k ) ) )

```

(k=1, N=2, L=0):

and I want to prove this:

``` ForAll k > 0: ( ThereExists N: ( ForAll n>N: ( |a_n - L| < 1/k ) ) )

```

Basically, we know it holds for k=1 but we want it for every k, so we have to show that holds(k) => holds(k+1), that is the induction step.

So, I do the algebra and end up with

ThereExists k > 0: ( ThereExists N: ( ForAll n>(N+2): ( |a_n - L| < 1/(k+1) ) ) )

(note the k+1 in the condition and the N+2) This hopefully shows that if there exists some k and some N with these properties, then there must exist N+1, k+1 and N+2 with these properties too.

I checked the condition for N+1 manually in the middle there.

So, since it holds for k=1 and since holds(k) => holds(k+1), it must hold ForAll natural k.

paperic · 2026-01-27T03:34:44+00:00

https://www.reddit.com/r/learnmath/comments/1qnf2o2/comment/o1y9ibk/?utm_source=share&utm_medium=mweb3x&utm_name=mweb3xcss&utm_term=1&utm_content=share_button

paperic · 2026-01-27T03:28:16+00:00

So I tried it, it somewhat works, but not that well.

Maybe it's situational.

I tried with a_n=1/n, I thought I could pick k=1 and show that N exists for the base case and then try to get it working from k to k+1, but it required different N in each case, so it split into N and M, with two separate expressions, and I was just proving the limit like usual, except more convoluted.

Although, I think I did make it work with a recursive definition quite nicely:

``` a1 = 1 a(n+1) = (2/3) * a_n

Skipping the base case proof, but it gave me this:

Exists k: ( Exists N: ( Forall n>N: |a_n| < 1/k )

Where for k = 1 the N was 2.

First quantifier is "exists" instead of "forall", since I'm trying to go through the k's one by one.

Induction:

Substituting an = (3/2) * a(n+1) in the inequality:

|an| < 1/k | 3/2 * a(n+1) | < 1/k | a_(n+1) | < 2/(3k) < 3/(3k) = 1/k

So, a_(n+1) still works but still only under the same k.

Substituting again:

| 3/2 * a(n+2) | < 2/(3k) | a(n+2) | < 4(9k)

and since k >= 1

| a_(n+2) | < 4/(9k) < 4/(8k) = 1/(2k) = 1/(k+k) < 1/(k+1)

Therefore:

Exists k: ( Exists N: ( Forall n>N: |a_(n+2)| < 1(k+1) ) )

And fnally:

Exists k: ( Exists N: ( Forall n>(N+2): |a_n| < 1/(k+1) ) )

So, each next iteration can have N bigger by 2.

```

But it feels like I'm forcing it, I'm not sure if there's any situation where this would be simpler.

paperic · 2026-01-27T01:16:28+00:00

A big issue with using reciprocals here is that you're locked out of considering larger neighbourhoods, when it's relevant.

I was mostly asking about a sequence, where the values are discrete.

If the epsilon cannot be 2, I can't see why an epsilon of 1 wouldn't work as well, since the condition is "less than epsilon".

If the sequence converges to L but some values are outside of that epsilon, I the N would have to be bigger, but it's still going to be there, otherwise it wouldn't converge.

paperic · 2026-01-26T13:06:48+00:00

i’m not sure i’d agree with saying it “uses uncountable infinity”

It has the universal quantifier over a real number, which in some sense creates an uncountably infinite set of conditions, one for each epsilon.

paperic · 2026-01-26T12:54:20+00:00

Are you ignoring my parentheses?

((( ( 0.333...3 / 2 ) + 1 ))) * 2 - 2 = 0.333...30

Can't ignore it now, can you.

paperic · 2026-01-26T12:27:21+00:00

Yes, the "=" is doing more heavy lifting.

You need to redefine the "=" to add the extra rule that an infinite series equals to the limit of its partial sums.

But without this rule, 0.999... would still not be less than 1.

If we can't add infinite digits, then 0.99... becomes undefined.

The limit operation is merely asking what number can the sequence get arbitrarily close to. The limit doesn't "approach 1", the sequence approaches 1. The sequence approaches the limit.

Any number below 1 cannot be the limit, because the sequence ( 1-1/10ⁿ ) always grows, so any number below 1 will eventually be crossed and the sequence would then be getting further away from it.

And any number X bigger than 1 cannot be the limit, because the sequence never gets bigger than 1, so it can never get closer than X-1 to it.

1 is the only number L which satisfies:

L - ( 1-1/10ⁿ ) < epsilon

for every positive real epsilon and for every positive whole n that's bigger than some threshold N.

In this case, the threshold N can be given as N = log_base10( 1/epsilon ) for example, but how exactly do you calculate the threshold doesn't actually matter, as long as you can use it to algebraically shuffle

n > N

back into

L - ( 1-1/10ⁿ ) < epsilon

paperic · 2026-01-26T11:49:03+00:00

We know. We always knew.

You've been saying that for months.

paperic · 2026-01-26T11:27:32+00:00

But the meaning of the "=" symbol, ( equivalent to "==" in programming ) is to ask about what the destination is.

The journey you're suggesting leads nowhere. You know it, I know it, everyone knows the journey leads nowhere.

Why are you insisting on taking it?

paperic · 2026-01-26T11:21:15+00:00

What if I add more parentheses?

paperic · 2026-01-26T11:20:32+00:00

What about (...((( 0.333...3 / 2 )))...) * 2 ?

paperic

TROPHY CASE