Take a number that wants to get close to zero. Say:

[0] = 1
[1] = .1
[2] = .01
[3] = .001
[...] = [...]

This gets close to zero, yet never will equal zero. Okay so:

arbitrarily close seems to be the accepted term.

infinitely close is the wrong wording?

The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using
the "metaphysical formation" of arbitrarily close... ;^)

"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:

> Take a number that wants to get close to zero.

This makes no sense. "a number" is one number. And numbers don't want
anything.

> Say:
>
> [0] = 1
> [1] = .1
> [2] = .01
> [3] = .001
> [...] = [...]

Strange notation. [0] = 1. Eh? Why not just use a more conventional
notation for a s sequence:

s_0 = 1
s_1 = 0.1
etc.

You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
later).

> This gets close to zero, yet never will equal zero. Okay so:
>
> arbitrarily close seems to be the accepted term.

But it's not a very good one. For example, one could say that

p(n) = 2^n when n is even
p(n) = 2^-n when n is odd

gets arbitrarily close to zero but also arbitrarily far away from zero.

> infinitely close is the wrong wording?

I would not know what you mean if you said that, so I would say it's the
wrong wording. The best wording is to say

lim_{n->oo} s(n) = 0.

which you can read as "the limit, as n tends to infinity, if s(n) is
zero".

> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using the
> "metaphysical formation" of arbitrarily close... ;^)

Oh. Does the ;^) mean this as all a joke? If so, sorry.

--
Ben.

On 2/16/2024 1:07 PM, Ben Bacarisse wrote:
> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>
>> Take a number that wants to get close to zero.
>
> This makes no sense. "a number" is one number. And numbers don't want
> anything.

That was designed to raise a laugh or two. I guess it bombed. Yikes!

>> Say:
>>
>> [0] = 1
>> [1] = .1
>> [2] = .01
>> [3] = .001
>> [...] = [...]
>
> Strange notation. [0] = 1. Eh? Why not just use a more conventional
> notation for a s sequence:

Too used to a programming language wrt indexing arrays I guess. :^)

> s_0 = 1
> s_1 = 0.1
> etc.
>
> You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
> later).
>
>> This gets close to zero, yet never will equal zero. Okay so:
>>
>> arbitrarily close seems to be the accepted term.
>
> But it's not a very good one. For example, one could say that
>
> p(n) = 2^n when n is even
> p(n) = 2^-n when n is odd
>
> gets arbitrarily close to zero but also arbitrarily far away from zero.

That's fine with me. I can see it wrt your logic.

>> infinitely close is the wrong wording?
>
> I would not know what you mean if you said that, so I would say it's the
> wrong wording. The best wording is to say
>
> lim_{n->oo} s(n) = 0.
>
> which you can read as "the limit, as n tends to infinity, if s(n) is
> zero".

The limit of f(n) = 10^(-n) is zero. However, none of the iterates equal
zero. They just get closer and closer to it...

>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using the
>> "metaphysical formation" of arbitrarily close... ;^)
>
> Oh. Does the ;^) mean this as all a joke? If so, sorry.

I was thinking that the statement: "how close is infinitely close to
arbitrarily close" would make some people laugh.

On 16/02/2024 20:49, Chris M. Thomasson wrote:
> Take a number that wants to get close to zero. Say:

Hehe, numbers don't want to get close to zero! For example, 0.000000001 is pretty close to zero,
but is quite happy being a distance 0.000000001 from zero, and has no desire to get any closer! :)

>
> [0] = 1
> [1] = .1
> [2] = .01
> [3] = .001
> [...] = [...]

What you have there, laddie, is a /sequence/, which /converges/ to zero...

>
> This gets close to zero, yet never will equal zero. Okay so:
>
> arbitrarily close seems to be the accepted term.

Yes, "arbitrarily close" captures the idea that for any tolerence t, the sequence eventually gets
/and stays/ within that tolerence from the limit 0.

You could think of it as a game: You go first, and must choose a tolerence t greater than zero.
Then its my go, and I must choose a natural number n. If ALL the sequence entries beyond the n'th
entry differ from the claimed limit by less than your t, I win! Else you win...

E.g. if you choose tolerence .001, I will choose n=4. Since [4]=.0001, [5]=.00001, [6], [7]. [8],et
al are all within your given tolerence, I win!

If I can /always/ win the game, the sequence converges to the claimed limit. (Otherwise it doesn't...)

Another example... maybe your sequence above converges to 0.001? No - you start be choosing e.g.
t=0.00000001. Now I'm stuck - as soon as we go past [4] = 0.0001 all further entries will differ
from 0.001 by more than your tolerence. [Conclusion: the sequence does not converge to 0.001, as is
obvious intuitively, but I'm showing how the game works...]

>
> infinitely close is the wrong wording?

Yes, it's not clear what "infinitely close" means - it sounds like it would be a property of two
specific numbers, like 0 and 0.00000000000000001, but that's nonsense - the latter is a fixed
non-zero distance from zero, and of course there are other numbers both closer or further away from
zero.

Using "arbitrarily" better captures the game-like nature of what is intended. I.e. that /first/ a
tolerence t is fixed as a kind of challenge, /then/ we try to find an entry in the sequence such
that that entry and all subsequent entries are within the fixed tolerence. Mathematically this can
be expressed with quantifiers, which capture the order of choices in the game. Something like:

DEF: x[n] --> a iff ∀t>0 ∃n [ if m>n then |x[m] - a| < t ]

HTH
Mike.

>
> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using the "metaphysical formation"
> of arbitrarily close... ;^)

On 02/16/2024 01:22 PM, Chris M. Thomasson wrote:
> On 2/16/2024 1:07 PM, Ben Bacarisse wrote:
>> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>>
>>> Take a number that wants to get close to zero.
>>
>> This makes no sense. "a number" is one number. And numbers don't want
>> anything.
>
> That was designed to raise a laugh or two. I guess it bombed. Yikes!
>
>
>>> Say:
>>>
>>> [0] = 1
>>> [1] = .1
>>> [2] = .01
>>> [3] = .001
>>> [...] = [...]
>>
>> Strange notation. [0] = 1. Eh? Why not just use a more conventional
>> notation for a s sequence:
>
> Too used to a programming language wrt indexing arrays I guess. :^)
>
>
>> s_0 = 1
>> s_1 = 0.1
>> etc.
>>
>> You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
>> later).
>>
>>> This gets close to zero, yet never will equal zero. Okay so:
>>>
>>> arbitrarily close seems to be the accepted term.
>>
>> But it's not a very good one. For example, one could say that
>>
>> p(n) = 2^n when n is even
>> p(n) = 2^-n when n is odd
>>
>> gets arbitrarily close to zero but also arbitrarily far away from zero.
>
> That's fine with me. I can see it wrt your logic.
>
>
>>> infinitely close is the wrong wording?
>>
>> I would not know what you mean if you said that, so I would say it's the
>> wrong wording. The best wording is to say
>>
>> lim_{n->oo} s(n) = 0.
>>
>> which you can read as "the limit, as n tends to infinity, if s(n) is
>> zero".
>
> The limit of f(n) = 10^(-n) is zero. However, none of the iterates equal
> zero. They just get closer and closer to it...
>
>
>>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol.
>>> Using the
>>> "metaphysical formation" of arbitrarily close... ;^)
>>
>> Oh. Does the ;^) mean this as all a joke? If so, sorry.
>
> I was thinking that the statement: "how close is infinitely close to
> arbitrarily close" would make some people laugh.

Hey, just because C/C++ is very familiar and
there's lots of perceived utility in the non-blocking,
one thing I wondered to ask you about was this
idea of a queue that basically has this sort of
utility.

Queues are usually only iterated once. Yet, sometimes
it's that items get appended and it's a well-formed
sequence that results the message. In this case
then the idea of this "mono-hydra" or "slique",
as about about the hydra with multiple heads
or the deque the doubled-ended queue, here
the idea is that this particular data structure
has its synchronization about setting a mark
and then basically when it scans from the front
then when it results a full sequence, then it
pops all those off while swapping in the new head.

So, the idea of this data structure is a very usual
use case in the buffering or burst queue or whatever
is the reason why a queue is filling up in the
intermediate, until the consumer indicates a
well-formed message and pops that off, while
the producer just atomic-appends items to the tail.

Anyways I wondered in your studies of Single and
Multiple Producer and Consumer, algorithms,
toward the lock-free, if you've considered this
sort simple data structure that I call "monohydra"
or "slique".

It's for something like Internet Protocols where
packets arrive and get assembled, then when they
result a message, that this kind of data structure
is entirely ephemeral, and has no purpose being
in main memory, then for a usual sort of free-list
approach to usual sorts un-even loads.

It's like "how's your chip design going" and
it's like "we solved it by adding burst buffers
between every two units" and it's like "that's
not very systolic".

A usual complement to "how low can you go"
is "how cold can it flow".

"If you're going to go about reinventing geometric series,
one need not do so so publicly." -- Virgil

After serious thinking Chris M. Thomasson wrote :
> Take a number that wants to get close to zero. Say:
>
> [0] = 1
> [1] = .1
> [2] = .01
> [3] = .001
> [...] = [...]
>
> This gets close to zero, yet never will equal zero. Okay so:

This sequence doesn't reach zero, but this series (1.111...) equals one
and one ninth.

> arbitrarily close seems to be the accepted term.

Approaching arbitrarily closely seems right to me.

> infinitely close is the wrong wording?

That sort of works too. What you want to avoid is the 'infinite
<something>' which you often say when you mean 'infinitely many
something(s').

> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using the
> "metaphysical formation" of arbitrarily close... ;^)

I don't know what you are getting at with this.

On 2/16/2024 1:56 PM, Ross Finlayson wrote:
> On 02/16/2024 01:22 PM, Chris M. Thomasson wrote:
>> On 2/16/2024 1:07 PM, Ben Bacarisse wrote:
>>> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>>>
>>>> Take a number that wants to get close to zero.
>>>
>>> This makes no sense.  "a number" is one number.  And numbers don't want
>>> anything.
>>
>> That was designed to raise a laugh or two. I guess it bombed. Yikes!
>>
>>
>>>> Say:
>>>>
>>>> [0] = 1
>>>> [1] = .1
>>>> [2] = .01
>>>> [3] = .001
>>>> [...] = [...]
>>>
>>> Strange notation.  [0] = 1.  Eh?  Why not just use a more conventional
>>> notation for a s sequence:
>>
>> Too used to a programming language wrt indexing arrays I guess. :^)
>>
>>
>>>    s_0 = 1
>>>    s_1 = 0.1
>>>    etc.
>>>
>>> You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
>>> later).
>>>
>>>> This gets close to zero, yet never will equal zero. Okay so:
>>>>
>>>> arbitrarily close seems to be the accepted term.
>>>
>>> But it's not a very good one.  For example, one could say that
>>>
>>>    p(n) = 2^n when n is even
>>>    p(n) = 2^-n when n is odd
>>>
>>> gets arbitrarily close to zero but also arbitrarily far away from zero.
>>
>> That's fine with me. I can see it wrt your logic.
>>
>>
>>>> infinitely close is the wrong wording?
>>>
>>> I would not know what you mean if you said that, so I would say it's the
>>> wrong wording.  The best wording is to say
>>>
>>>    lim_{n->oo} s(n) = 0.
>>>
>>> which you can read as "the limit, as n tends to infinity, if s(n) is
>>> zero".
>>
>> The limit of f(n) = 10^(-n) is zero. However, none of the iterates equal
>> zero. They just get closer and closer to it...
>>
>>
>>>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol.
>>>> Using the
>>>> "metaphysical formation" of arbitrarily close... ;^)
>>>
>>> Oh.  Does the ;^) mean this as all a joke?  If so, sorry.
>>
>> I was thinking that the statement: "how close is infinitely close to
>> arbitrarily close" would make some people laugh.
>
>
> Hey, just because C/C++ is very familiar and
> there's lots of perceived utility in the non-blocking,
> one thing I wondered to ask you about was this
> idea of a queue that basically has this sort of
> utility.
>
> Queues are usually only iterated once.  Yet, sometimes
> it's that items get appended and it's a well-formed
> sequence that results the message.  In this case
> then the idea of this "mono-hydra" or "slique",
> as about about the hydra with multiple heads
> or the deque the doubled-ended queue, here
> the idea is that this particular data structure
> has its synchronization about setting a mark
> and then basically when it scans from the front
> then when it results a full sequence, then it
> pops all those off while swapping in the new head.
>
> So, the idea of this data structure is a very usual
> use case in the buffering or burst queue or whatever
> is the reason why a queue is filling up in the
> intermediate, until the consumer indicates a
> well-formed message and pops that off, while
> the producer just atomic-appends items to the tail.
>
> Anyways I wondered in your studies of Single and
> Multiple Producer and Consumer, algorithms,
> toward the lock-free, if you've considered this
> sort simple data structure that I call "monohydra"
> or "slique".
>
> It's for something like Internet Protocols where
> packets arrive and get assembled, then when they
> result a message, that this kind of data structure
> is entirely ephemeral, and has no purpose being
> in main memory, then for a usual sort of free-list
> approach to usual sorts un-even loads.
>
> It's like "how's your chip design going" and
> it's like "we solved it by adding burst buffers
> between every two units" and it's like "that's
> not very systolic".
>
> A usual complement to "how low can you go"
> is "how cold can it flow".
>
>
> "If you're going to go about reinventing geometric series,
> one need not do so so publicly."  -- Virgil
>
>

I will get back to you, a bit busy right now. Actually, I am working on
a neat sort of distributed "queue'ish" work system. It only uses atomic
exchange. When you get some free time to burn, take a deep look at the
following:

https://groups.google.com/g/comp.lang.c++/c/Skv1PoQsUZo/m/XI3Qw64xAAAJ

On 2/16/2024 1:45 PM, Mike Terry wrote:
> On 16/02/2024 20:49, Chris M. Thomasson wrote:
>> Take a number that wants to get close to zero. Say:
>
> Hehe, numbers don't want to get close to zero!  For example, 0.000000001
> is pretty close to zero, but is quite happy being a distance 0.000000001
> from zero, and has no desire to get any closer!  :)
>
>>
>> [0] = 1
>> [1] = .1
>> [2] = .01
>> [3] = .001
>> [...] = [...]
>
> What you have there, laddie, is a /sequence/, which /converges/ to zero...
>
>>
>> This gets close to zero, yet never will equal zero. Okay so:
>>
>> arbitrarily close seems to be the accepted term.
>
> Yes, "arbitrarily close" captures the idea that for any tolerence t, the
> sequence eventually gets /and stays/ within that tolerence from the
> limit 0.
>
> You could think of it as a game:  You go first, and must choose a
> tolerence t greater than zero. Then its my go, and I must choose a
> natural number n.  If ALL the sequence entries beyond the n'th entry
> differ from the claimed limit by less than your t, I win!  Else you win...
>
> E.g. if you choose tolerence .001, I will choose n=4.  Since [4]=.0001,
> [5]=.00001, [6], [7]. [8],et al are all within your given tolerence, I win!
>
> If I can /always/ win the game, the sequence converges to the claimed
> limit.  (Otherwise it doesn't...)
>
> Another example... maybe your sequence above converges to 0.001?  No -
> you start be choosing e.g. t=0.00000001.  Now I'm stuck - as soon as we
> go past [4] = 0.0001 all further entries will differ from 0.001 by more
> than your tolerence.  [Conclusion: the sequence does not converge to
> 0.001, as is obvious intuitively, but I'm showing how the game works...]
>
>>
>> infinitely close is the wrong wording?
>
> Yes, it's not clear what "infinitely close" means - it sounds like it
> would be a property of two specific numbers, like 0 and
> 0.00000000000000001, but that's nonsense - the latter is a fixed
> non-zero distance from zero, and of course there are other numbers both
> closer or further away from zero.
>
> Using "arbitrarily" better captures the game-like nature of what is
> intended.  I.e. that /first/ a tolerence t is fixed as a kind of
> challenge, /then/ we try to find an entry in the sequence such that that
> entry and all subsequent entries are within the fixed tolerence.
> Mathematically this can be expressed with quantifiers, which capture the
> order of choices in the game.  Something like:

Your tolerance reminds me of an epsilon? Humm... Will get back to you. A
little busy right now.

>
>     DEF:  x[n]  --> a    iff  ∀t>0 ∃n [ if m>n then |x[m] - a| < t ]
>
>
> HTH
> Mike.
>
>>
>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using
>> the "metaphysical formation" of arbitrarily close... ;^)

On 2/16/2024 2:33 PM, FromTheRafters wrote:
> After serious thinking Chris M. Thomasson wrote :
>> Take a number that wants to get close to zero. Say:
>>
>> [0] = 1
>> [1] = .1
>> [2] = .01
>> [3] = .001
>> [...] = [...]
>>
>> This gets close to zero, yet never will equal zero. Okay so:
>
> This sequence doesn't reach zero, but this series (1.111...) equals one
> and one ninth.
>
>> arbitrarily close seems to be the accepted term.
>
> Approaching arbitrarily closely seems right to me.
>
>> infinitely close is the wrong wording?
>
> That sort of works too. What you want to avoid is the 'infinite
> <something>' which you often say when you mean 'infinitely many
> something(s').
>
>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using
>> the "metaphysical formation" of arbitrarily close... ;^)
>
> I don't know what you are getting at with this.

I was told one time that infinitely closer is in the realm of
"metaphysical" because of the word infinite. However, the term
arbitrarily close is something others can deal with "better", so to
speak. Make any sense?

On 2/16/2024 3:09 PM, Chris M. Thomasson wrote:
> On 2/16/2024 1:56 PM, Ross Finlayson wrote:
>> On 02/16/2024 01:22 PM, Chris M. Thomasson wrote:
>>> On 2/16/2024 1:07 PM, Ben Bacarisse wrote:
>>>> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>>>>
>>>>> Take a number that wants to get close to zero.
>>>>
>>>> This makes no sense.  "a number" is one number.  And numbers don't want
>>>> anything.
>>>
>>> That was designed to raise a laugh or two. I guess it bombed. Yikes!
>>>
>>>
>>>>> Say:
>>>>>
>>>>> [0] = 1
>>>>> [1] = .1
>>>>> [2] = .01
>>>>> [3] = .001
>>>>> [...] = [...]
>>>>
>>>> Strange notation.  [0] = 1.  Eh?  Why not just use a more conventional
>>>> notation for a s sequence:
>>>
>>> Too used to a programming language wrt indexing arrays I guess. :^)
>>>
>>>
>>>>    s_0 = 1
>>>>    s_1 = 0.1
>>>>    etc.
>>>>
>>>> You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
>>>> later).
>>>>
>>>>> This gets close to zero, yet never will equal zero. Okay so:
>>>>>
>>>>> arbitrarily close seems to be the accepted term.
>>>>
>>>> But it's not a very good one.  For example, one could say that
>>>>
>>>>    p(n) = 2^n when n is even
>>>>    p(n) = 2^-n when n is odd
>>>>
>>>> gets arbitrarily close to zero but also arbitrarily far away from zero.
>>>
>>> That's fine with me. I can see it wrt your logic.
>>>
>>>
>>>>> infinitely close is the wrong wording?
>>>>
>>>> I would not know what you mean if you said that, so I would say it's
>>>> the
>>>> wrong wording.  The best wording is to say
>>>>
>>>>    lim_{n->oo} s(n) = 0.
>>>>
>>>> which you can read as "the limit, as n tends to infinity, if s(n) is
>>>> zero".
>>>
>>> The limit of f(n) = 10^(-n) is zero. However, none of the iterates equal
>>> zero. They just get closer and closer to it...
>>>
>>>
>>>>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol.
>>>>> Using the
>>>>> "metaphysical formation" of arbitrarily close... ;^)
>>>>
>>>> Oh.  Does the ;^) mean this as all a joke?  If so, sorry.
>>>
>>> I was thinking that the statement: "how close is infinitely close to
>>> arbitrarily close" would make some people laugh.
>>
>>
>> Hey, just because C/C++ is very familiar and
>> there's lots of perceived utility in the non-blocking,
>> one thing I wondered to ask you about was this
>> idea of a queue that basically has this sort of
>> utility.
>>
>> Queues are usually only iterated once.  Yet, sometimes
>> it's that items get appended and it's a well-formed
>> sequence that results the message.  In this case
>> then the idea of this "mono-hydra" or "slique",
>> as about about the hydra with multiple heads
>> or the deque the doubled-ended queue, here
>> the idea is that this particular data structure
>> has its synchronization about setting a mark
>> and then basically when it scans from the front
>> then when it results a full sequence, then it
>> pops all those off while swapping in the new head.
>>
>> So, the idea of this data structure is a very usual
>> use case in the buffering or burst queue or whatever
>> is the reason why a queue is filling up in the
>> intermediate, until the consumer indicates a
>> well-formed message and pops that off, while
>> the producer just atomic-appends items to the tail.
>>
>> Anyways I wondered in your studies of Single and
>> Multiple Producer and Consumer, algorithms,
>> toward the lock-free, if you've considered this
>> sort simple data structure that I call "monohydra"
>> or "slique".
>>
>> It's for something like Internet Protocols where
>> packets arrive and get assembled, then when they
>> result a message, that this kind of data structure
>> is entirely ephemeral, and has no purpose being
>> in main memory, then for a usual sort of free-list
>> approach to usual sorts un-even loads.
>>
>> It's like "how's your chip design going" and
>> it's like "we solved it by adding burst buffers
>> between every two units" and it's like "that's
>> not very systolic".
>>
>> A usual complement to "how low can you go"
>> is "how cold can it flow".
>>
>>
>> "If you're going to go about reinventing geometric series,
>> one need not do so so publicly."  -- Virgil
>>
>>
>
> I will get back to you, a bit busy right now. Actually, I am working on
> a neat sort of distributed "queue'ish" work system. It only uses atomic
> exchange. When you get some free time to burn, take a deep look at the
> following:
>
> https://groups.google.com/g/comp.lang.c++/c/Skv1PoQsUZo/m/XI3Qw64xAAAJ

If you have any questions comments about it, humm... Perhaps put them in
that comp.lang.c++? Fair enough?

On 02/16/2024 03:09 PM, Chris M. Thomasson wrote:
> On 2/16/2024 1:56 PM, Ross Finlayson wrote:
>> On 02/16/2024 01:22 PM, Chris M. Thomasson wrote:
>>> On 2/16/2024 1:07 PM, Ben Bacarisse wrote:
>>>> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>>>>
>>>>> Take a number that wants to get close to zero.
>>>>
>>>> This makes no sense. "a number" is one number. And numbers don't want
>>>> anything.
>>>
>>> That was designed to raise a laugh or two. I guess it bombed. Yikes!
>>>
>>>
>>>>> Say:
>>>>>
>>>>> [0] = 1
>>>>> [1] = .1
>>>>> [2] = .01
>>>>> [3] = .001
>>>>> [...] = [...]
>>>>
>>>> Strange notation. [0] = 1. Eh? Why not just use a more conventional
>>>> notation for a s sequence:
>>>
>>> Too used to a programming language wrt indexing arrays I guess. :^)
>>>
>>>
>>>> s_0 = 1
>>>> s_1 = 0.1
>>>> etc.
>>>>
>>>> You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
>>>> later).
>>>>
>>>>> This gets close to zero, yet never will equal zero. Okay so:
>>>>>
>>>>> arbitrarily close seems to be the accepted term.
>>>>
>>>> But it's not a very good one. For example, one could say that
>>>>
>>>> p(n) = 2^n when n is even
>>>> p(n) = 2^-n when n is odd
>>>>
>>>> gets arbitrarily close to zero but also arbitrarily far away from zero.
>>>
>>> That's fine with me. I can see it wrt your logic.
>>>
>>>
>>>>> infinitely close is the wrong wording?
>>>>
>>>> I would not know what you mean if you said that, so I would say it's
>>>> the
>>>> wrong wording. The best wording is to say
>>>>
>>>> lim_{n->oo} s(n) = 0.
>>>>
>>>> which you can read as "the limit, as n tends to infinity, if s(n) is
>>>> zero".
>>>
>>> The limit of f(n) = 10^(-n) is zero. However, none of the iterates equal
>>> zero. They just get closer and closer to it...
>>>
>>>
>>>>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol.
>>>>> Using the
>>>>> "metaphysical formation" of arbitrarily close... ;^)
>>>>
>>>> Oh. Does the ;^) mean this as all a joke? If so, sorry.
>>>
>>> I was thinking that the statement: "how close is infinitely close to
>>> arbitrarily close" would make some people laugh.
>>
>>
>> Hey, just because C/C++ is very familiar and
>> there's lots of perceived utility in the non-blocking,
>> one thing I wondered to ask you about was this
>> idea of a queue that basically has this sort of
>> utility.
>>
>> Queues are usually only iterated once. Yet, sometimes
>> it's that items get appended and it's a well-formed
>> sequence that results the message. In this case
>> then the idea of this "mono-hydra" or "slique",
>> as about about the hydra with multiple heads
>> or the deque the doubled-ended queue, here
>> the idea is that this particular data structure
>> has its synchronization about setting a mark
>> and then basically when it scans from the front
>> then when it results a full sequence, then it
>> pops all those off while swapping in the new head.
>>
>> So, the idea of this data structure is a very usual
>> use case in the buffering or burst queue or whatever
>> is the reason why a queue is filling up in the
>> intermediate, until the consumer indicates a
>> well-formed message and pops that off, while
>> the producer just atomic-appends items to the tail.
>>
>> Anyways I wondered in your studies of Single and
>> Multiple Producer and Consumer, algorithms,
>> toward the lock-free, if you've considered this
>> sort simple data structure that I call "monohydra"
>> or "slique".
>>
>> It's for something like Internet Protocols where
>> packets arrive and get assembled, then when they
>> result a message, that this kind of data structure
>> is entirely ephemeral, and has no purpose being
>> in main memory, then for a usual sort of free-list
>> approach to usual sorts un-even loads.
>>
>> It's like "how's your chip design going" and
>> it's like "we solved it by adding burst buffers
>> between every two units" and it's like "that's
>> not very systolic".
>>
>> A usual complement to "how low can you go"
>> is "how cold can it flow".
>>
>>
>> "If you're going to go about reinventing geometric series,
>> one need not do so so publicly." -- Virgil
>>
>>
>
> I will get back to you, a bit busy right now. Actually, I am working on
> a neat sort of distributed "queue'ish" work system. It only uses atomic
> exchange. When you get some free time to burn, take a deep look at the
> following:
>
> https://groups.google.com/g/comp.lang.c++/c/Skv1PoQsUZo/m/XI3Qw64xAAAJ

I've been thinking about cooperative multithreading,
basically with cooperative threading with timeouts,
since about 2016 I wrote up this idea about the "re-routine",
which is a sort of outline for cooperative multithreading,
where the idea is that all the calls are idempotent and
memoized, and none return null on success, and their
exceptions are modeled as usual error modes or for flow
of control with exceptions if that's the thing, then the
idea being is that the executor sort of runs the re-routine
and then figures that whenever it gets a null, then it's pending,
so it throws itself out, that when the callback arrives when
there's a response, then it just runs again right through the
re-routine, where of course it's all conditioned on the idempotent
memoized intermediate results, until it completes or errors.

This way it's about the same on the heap the intermediate
memo-ized results as the routine is running, but there's
no stack at all, so, it's not stack-bound, at all.

Of course preemptive multithreading and the thread stack
and context switching is about the greatest sort of thing
when some code isn't well-behaved, or won't yield, here
then for figuring about how basically to implement
cooperative multithreading including timeouts and priority.

Thusly, in the same sort of context as the co-routine, is,
the re-routine, this being for a model of cooperating
multi-threading, at least in a module where it can be
either entirely callback-driven or including timeouts,
and besides the executor can run its own threads in
the stack-bound for ensuring usual throughput in
case whatever re-routine is implemented in blocking
fashion.

This is a sort of idea about where mostly what I
want is that the routine is written as if it were
synchronous and serial and blocking, so it's simple,
then that just the semantics of the adapters or
the extra work on the glue logic, makes it so that
the serial re-routine is written naturally "in the language",
making it all readable and directly up-front and
getting the async semantics out of the way.

That's not really relevant here in this context
about "the mathematical infinite and unbounded",
but it results a sort of "factory industry pattern",
or re-routines, then that the implementation of
routine ends up being as simple as possible and
as close as possible to the language of its predication,
while it's all well-formed and guaranteed its behavior,
that then it can be implemented variously local or remote.

I suppose "cooperative multithreading" isn't for everybody,
but re-routines is a great idea.

Then the idea of the sliques or monohydra is basically
exactly as for the buffering the serving the IO's.
I.e., the idea here is that usually request/response
type things for transits can sort of be related to
what goes through DMA and nonblocking or async I/O,
and scatter/gather and vector I/O, getting things flowing,
right by the little ring through their nose.

Then about the infinite and the infinite limit,
it's called "the infinite limit".

On 02/16/2024 06:48 PM, mitchr...@gmail.com wrote:
> On Friday, February 16, 2024 at 3:35:44 PM UTC-8, Ross Finlayson wrote:
>> On 02/16/2024 03:09 PM, Chris M. Thomasson wrote:
>>> On 2/16/2024 1:56 PM, Ross Finlayson wrote:
>>>> On 02/16/2024 01:22 PM, Chris M. Thomasson wrote:
>>>>> On 2/16/2024 1:07 PM, Ben Bacarisse wrote:
>>>>>> "Chris M. Thomasson" <chris.m.t...@gmail.com> writes:
>>>>>>
>>>>>>> Take a number that wants to get close to zero.
>>>>>>
>>>>>> This makes no sense. "a number" is one number. And numbers don't want
>>>>>> anything.
>>>>>
>>>>> That was designed to raise a laugh or two. I guess it bombed. Yikes!
>>>>>
>>>>>
>>>>>>> Say:
>>>>>>>
>>>>>>> [0] = 1
>>>>>>> [1] = .1
>>>>>>> [2] = .01
>>>>>>> [3] = .001
>>>>>>> [...] = [...]
>>>>>>
>>>>>> Strange notation. [0] = 1. Eh? Why not just use a more conventional
>>>>>> notation for a s sequence:
>>>>>
>>>>> Too used to a programming language wrt indexing arrays I guess. :^)
>>>>>
>>>>>
>>>>>> s_0 = 1
>>>>>> s_1 = 0.1
>>>>>> etc.
>>>>>>
>>>>>> You can, if you prefer, write it as a function: s(n) = 10^-n (as you do
>>>>>> later).
>>>>>>
>>>>>>> This gets close to zero, yet never will equal zero. Okay so:
>>>>>>>
>>>>>>> arbitrarily close seems to be the accepted term.
>>>>>>
>>>>>> But it's not a very good one. For example, one could say that
>>>>>>
>>>>>> p(n) = 2^n when n is even
>>>>>> p(n) = 2^-n when n is odd
>>>>>>
>>>>>> gets arbitrarily close to zero but also arbitrarily far away from zero.
>>>>>
>>>>> That's fine with me. I can see it wrt your logic.
>>>>>
>>>>>
>>>>>>> infinitely close is the wrong wording?
>>>>>>
>>>>>> I would not know what you mean if you said that, so I would say it's
>>>>>> the
>>>>>> wrong wording. The best wording is to say
>>>>>>
>>>>>> lim_{n->oo} s(n) = 0.
>>>>>>
>>>>>> which you can read as "the limit, as n tends to infinity, if s(n) is
>>>>>> zero".
>>>>>
>>>>> The limit of f(n) = 10^(-n) is zero. However, none of the iterates equal
>>>>> zero. They just get closer and closer to it...
>>>>>
>>>>>
>>>>>>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol.
>>>>>>> Using the
>>>>>>> "metaphysical formation" of arbitrarily close... ;^)
>>>>>>
>>>>>> Oh. Does the ;^) mean this as all a joke? If so, sorry.
>>>>>
>>>>> I was thinking that the statement: "how close is infinitely close to
>>>>> arbitrarily close" would make some people laugh.
>>>>
>>>>
>>>> Hey, just because C/C++ is very familiar and
>>>> there's lots of perceived utility in the non-blocking,
>>>> one thing I wondered to ask you about was this
>>>> idea of a queue that basically has this sort of
>>>> utility.
>>>>
>>>> Queues are usually only iterated once. Yet, sometimes
>>>> it's that items get appended and it's a well-formed
>>>> sequence that results the message. In this case
>>>> then the idea of this "mono-hydra" or "slique",
>>>> as about about the hydra with multiple heads
>>>> or the deque the doubled-ended queue, here
>>>> the idea is that this particular data structure
>>>> has its synchronization about setting a mark
>>>> and then basically when it scans from the front
>>>> then when it results a full sequence, then it
>>>> pops all those off while swapping in the new head.
>>>>
>>>> So, the idea of this data structure is a very usual
>>>> use case in the buffering or burst queue or whatever
>>>> is the reason why a queue is filling up in the
>>>> intermediate, until the consumer indicates a
>>>> well-formed message and pops that off, while
>>>> the producer just atomic-appends items to the tail.
>>>>
>>>> Anyways I wondered in your studies of Single and
>>>> Multiple Producer and Consumer, algorithms,
>>>> toward the lock-free, if you've considered this
>>>> sort simple data structure that I call "monohydra"
>>>> or "slique".
>>>>
>>>> It's for something like Internet Protocols where
>>>> packets arrive and get assembled, then when they
>>>> result a message, that this kind of data structure
>>>> is entirely ephemeral, and has no purpose being
>>>> in main memory, then for a usual sort of free-list
>>>> approach to usual sorts un-even loads.
>>>>
>>>> It's like "how's your chip design going" and
>>>> it's like "we solved it by adding burst buffers
>>>> between every two units" and it's like "that's
>>>> not very systolic".
>>>>
>>>> A usual complement to "how low can you go"
>>>> is "how cold can it flow".
>>>>
>>>>
>>>> "If you're going to go about reinventing geometric series,
>>>> one need not do so so publicly." -- Virgil
>>>>
>>>>
>>>
>>> I will get back to you, a bit busy right now. Actually, I am working on
>>> a neat sort of distributed "queue'ish" work system. It only uses atomic
>>> exchange. When you get some free time to burn, take a deep look at the
>>> following:
>>>
>>> https://groups.google.com/g/comp.lang.c++/c/Skv1PoQsUZo/m/XI3Qw64xAAAJ
>> I've been thinking about cooperative multithreading,
>> basically with cooperative threading with timeouts,
>> since about 2016 I wrote up this idea about the "re-routine",
>> which is a sort of outline for cooperative multithreading,
>> where the idea is that all the calls are idempotent and
>> memoized, and none return null on success, and their
>> exceptions are modeled as usual error modes or for flow
>> of control with exceptions if that's the thing, then the
>> idea being is that the executor sort of runs the re-routine
>> and then figures that whenever it gets a null, then it's pending,
>> so it throws itself out, that when the callback arrives when
>> there's a response, then it just runs again right through the
>> re-routine, where of course it's all conditioned on the idempotent
>> memoized intermediate results, until it completes or errors.
>>
>> This way it's about the same on the heap the intermediate
>> memo-ized results as the routine is running, but there's
>> no stack at all, so, it's not stack-bound, at all.
>>
>> Of course preemptive multithreading and the thread stack
>> and context switching is about the greatest sort of thing
>> when some code isn't well-behaved, or won't yield, here
>> then for figuring about how basically to implement
>> cooperative multithreading including timeouts and priority.
>>
>> Thusly, in the same sort of context as the co-routine, is,
>> the re-routine, this being for a model of cooperating
>> multi-threading, at least in a module where it can be
>> either entirely callback-driven or including timeouts,
>> and besides the executor can run its own threads in
>> the stack-bound for ensuring usual throughput in
>> case whatever re-routine is implemented in blocking
>> fashion.
>>
>> This is a sort of idea about where mostly what I
>> want is that the routine is written as if it were
>> synchronous and serial and blocking, so it's simple,
>> then that just the semantics of the adapters or
>> the extra work on the glue logic, makes it so that
>> the serial re-routine is written naturally "in the language",
>> making it all readable and directly up-front and
>> getting the async semantics out of the way.
>>
>> That's not really relevant here in this context
>> about "the mathematical infinite and unbounded",
>> but it results a sort of "factory industry pattern",
>> or re-routines, then that the implementation of
>> routine ends up being as simple as possible and
>> as close as possible to the language of its predication,
>> while it's all well-formed and guaranteed its behavior,
>> that then it can be implemented variously local or remote.
>>
>> I suppose "cooperative multithreading" isn't for everybody,
>> but re-routines is a great idea.
>>
>> Then the idea of the sliques or monohydra is basically
>> exactly as for the buffering the serving the IO's.
>> I.e., the idea here is that usually request/response
>> type things for transits can sort of be related to
>> what goes through DMA and nonblocking or async I/O,
>> and scatter/gather and vector I/O, getting things flowing,
>> right by the little ring through their nose.
>>
>>
>>
>>
>> Then about the infinite and the infinite limit,
>> it's called "the infinite limit".
>>
>> Consider a snake that travels from 0 to 1 then 1 to 2.
>>
>> Not only did it get "close enough", to 1,
>> it got "far enough", away, to get to 2.
>>
>> I.e. deductively it crossed that bridge.
>
> Infinity?
> That bridge is never crossed.
> You can built it. But you can't cross it.
>
>
>>
>> In continuous time, ....
>>
>> It's called "infinite limit", with the idea being also
>> that when it results continuous called "continuum limit".
>
> But the infinite is always defined as the unlimited.
> No. You can't count to infinity.
>

Le 16/02/2024 à 22:07, Ben Bacarisse a écrit :
> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>
>> Take a number that wants to get close to zero.
>
> This makes no sense. "a number" is one number. And numbers don't want
> anything.
>
But mathematicians want to know about numbers, for instance how close to
zero the unit fractions come.

Take the function Number of Unit Fractions between (0, and x > 0). It has
the following properties:
(1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
NUF(x) increases at some x.
(2) NUF(x) cannot increase other than when passing unit fractions at some
x = 1/n.
(3) NUF(x) cannot pass more than one unit fraction at a single point x
because
∀n ∈ ℕ: 1/n =/= 1/(n-1).
(4) This requires a first unit fraction, if all are there in actual
infinity.

Regards, WM

Mike Terry schrieb am Freitag, 16. Februar 2024 um 22:45:48 UTC+1:

> Yes, it's not clear what "infinitely close" means

It means dark numbers.
The function Number of Unit Fractions between (0, and x) has
the following properties:
(1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
NUF(x) increases at some x.
(2) NUF(x) cannot increase other than when passing unit fractions at some
x = 1/n.
(3) NUF(x) cannot pass more than one unit fraction at a single point x
because
∀n ∈ ℕ: 1/n =/= 1/(n-1).
(4) This requires a first unit fraction, if all are there in actual
infinity.

Regards, WM

mitchr...@gmail.com schrieb am Samstag, 17. Februar 2024 um 03:48:28
UTC+1:

> But the infinite is always defined as the unlimited.

Nevertheless actual infinity is limites, for instance 1, 2, 3, ... is
limites by ω.
1/1, 1/2, 1/3, ... is limited by 0.
> No. You can't count to infinity.

Correct. Between all numbers you can count and the limit there are dark
numbers.
Take the function Number of Unit Fractions between (0, and x > 0). It has
the following properties:
(1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
NUF(x) increases at some x.
(2) NUF(x) cannot increase other than when passing unit fractions at some
x = 1/n.
(3) NUF(x) cannot pass more than one unit fraction at a single point x
because
∀n ∈ ℕ: 1/n =/= 1/(n-1).

This requires a first unit fraction, if all are there in actual
infinity. Of course the first unit fractions cannot be seen. They are
dark.

Regards, WM

Chris M. Thomasson expressed precisely :
> On 2/16/2024 2:33 PM, FromTheRafters wrote:
>> After serious thinking Chris M. Thomasson wrote :
>>> Take a number that wants to get close to zero. Say:
>>>
>>> [0] = 1
>>> [1] = .1
>>> [2] = .01
>>> [3] = .001
>>> [...] = [...]
>>>
>>> This gets close to zero, yet never will equal zero. Okay so:
>>
>> This sequence doesn't reach zero, but this series (1.111...) equals one and
>> one ninth.
>>
>>> arbitrarily close seems to be the accepted term.
>>
>> Approaching arbitrarily closely seems right to me.
>>
>>> infinitely close is the wrong wording?
>>
>> That sort of works too. What you want to avoid is the 'infinite
>> <something>' which you often say when you mean 'infinitely many
>> something(s').
>>
>>> The function f(n) = 10^(-n) gets "infinitely close" to 0... lol. Using the
>>> "metaphysical formation" of arbitrarily close... ;^)
>>
>> I don't know what you are getting at with this.
>
> I was told one time that infinitely closer is in the realm of "metaphysical"
> because of the word infinite. However, the term arbitrarily close is
> something others can deal with "better", so to speak. Make any sense?

You could say approaching asymtotically.

https://www.dictionary.com/browse/asymptotically

On 2/17/24 4:56 AM, WM wrote:
> Mike Terry schrieb am Freitag, 16. Februar 2024 um 22:45:48 UTC+1:
>
>> Yes, it's not clear what "infinitely close" means
>
> It means dark numbers.
> The function Number of Unit Fractions between (0, and x) has
> the following properties:
> (1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
> NUF(x) increases at some x.
> (2) NUF(x) cannot increase other than when passing unit fractions at some
> x = 1/n.
> (3) NUF(x) cannot pass more than one unit fraction at a single point x
> because
> ∀n ∈ ℕ: 1/n =/= 1/(n-1).
> (4) This requires a first unit fraction, if all are there in actual
> infinity.
>
> Regards, WM
>
>
>

In other words, "Dark Numbers" are made up numbers that try to patch the
holes in your logic and you define that we can not know anything about
them, and thus nothing can be wrong with them.

Of course, since your premises are just wrong, so is your logic system,
and you are just trying to hold it together with the bubble gum and
bailing wire you call "Darkness"

On 2/17/24 3:23 AM, WM wrote:
> Le 16/02/2024 à 22:07, Ben Bacarisse a écrit :
>> "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> writes:
>>
>>> Take a number that wants to get close to zero.
>>
>> This makes no sense.  "a number" is one number.  And numbers don't want
>> anything.
>>
> But mathematicians want to know about numbers, for instance how close to
> zero the unit fractions come.
>
> Take the function Number of Unit Fractions between (0, and x > 0). It
> has the following properties:
> (1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
> NUF(x) increases at some x.
> (2) NUF(x) cannot increase other than when passing unit fractions at
> some x = 1/n.
> (3) NUF(x) cannot pass more than one unit fraction at a single point x
> because
> ∀n ∈ ℕ: 1/n =/= 1/(n-1).
> (4) This requires a first unit fraction, if all are there in actual
> infinity.
>
> Regards, WM
>

Or, that such a function can't actually be defined, because it assumes
that there IS a "smallest unit fraction".

Just because you can "define" it in words, doesn't mean that it can
actually exist.

On 02/16/2024 01:44 PM, Erdélyi Szőke Komáromi wrote:
> Chris M. Thomasson wrote:
>
>> Take a number that wants to get close to zero. Say:
>>
>> [0] = 1
>> [1] = .1
>> [2] = .01
>> [3] = .001
>> [...] = [...]
>>
>> This gets close to zero, yet never will equal zero. Okay so:
>> arbitrarily close seems to be the accepted term.
>> infinitely close is the wrong wording?
>
> in my country a > [...] = [...] is not a number. It's imbecility.
>
> I believe this proves the gearmons and 𝘁𝗵𝗲_Hitler_𝗻𝗮𝘇𝗶𝘀 were
(𝗔𝗥𝗘) despicable lying 𝗸𝗵𝗮𝘇𝗮𝗿_𝗴𝗼𝘆𝘀.
>
>
𝗚𝗲𝗿𝗺𝗮𝗻𝘆_𝗮𝗻𝗱_𝗨𝗸𝗿𝗮𝗶𝗻𝗲_𝘀𝗶𝗴𝗻_‘𝗹𝗼𝗻𝗴_𝘁𝗲𝗿𝗺’_𝘀𝗲𝗰𝘂𝗿𝗶𝘁𝘆_𝗱𝗲𝗮𝗹
> Ukrainian President Vladimir Zelensky has said the agreement proves
“Ukraine will be in NATO”

Hey.

The pieces of shit called Vladimir Putin and Alexander Bastrykin
just murdered Alexei Navalny.

Yes Putin is actually Hitler.

Nikolay Kharitonov is morally superior to that piece of shit.

It would please the Chinese if you did that. He would not be
as bad off as the Nazi pig.

x wrote:

> > in my country a > [...] = [...] is not a number. It's imbecility.
> > I believe this proves the gearmons and 𝘁𝗵𝗲_Hitler_𝗻𝗮𝘇𝗶𝘀 were
> (𝗔𝗥𝗘) despicable lying 𝗸𝗵𝗮𝘇𝗮𝗿_𝗴𝗼𝘆𝘀.
> >
> 𝗚𝗲𝗿𝗺𝗮𝗻𝘆_𝗮𝗻𝗱_𝗨𝗸𝗿𝗮𝗶𝗻𝗲_𝘀𝗶𝗴𝗻_‘𝗹𝗼𝗻𝗴_𝘁𝗲𝗿𝗺’_𝘀𝗲𝗰𝘂𝗿𝗶𝘁𝘆_𝗱𝗲𝗮𝗹
> > Ukrainian President Vladimir Zelensky has said the agreement proves
> “Ukraine will be in NATO”
>
> Hey.The pieces of shit called Vladimir Putin and Alexander Bastrykin
> just murdered Alexei Navalny.

navalne?? are you fucking stupid. The traitor got 𝗮_𝗬𝗮𝗹𝗲_𝗱𝗶𝗽𝗹𝗼𝗺𝗮 from fucking
𝗰𝗶𝗮, was "𝗽𝗼𝗶𝘀𝗼𝗻𝗲𝗱" in little britain by "evil" Russians, because they shall
be evil, seen by 𝗲𝗻𝗴𝗹𝗶𝘀𝗵_𝗸𝗵𝗮𝘇𝗮𝗿_𝗽𝗶𝗴𝘀, then 𝘁𝗵𝗲 MI6 asset traitor 𝗻𝗮𝘃𝗮𝗹𝗻𝗲 returns
to Russia to kill 𝘁𝗵𝗲_𝗣𝘂𝘁𝗶𝗻𝗮. You fucking imbecile. Here some proofs, read
the second half part.

𝗦𝗖𝗢𝗧𝗧_𝗥𝗜𝗧𝗧𝗘𝗥_𝗼𝗻_𝗡𝗔𝗩𝗔𝗟𝗡𝗬'𝘀_𝗥𝗢𝗟𝗘_𝗮𝗻𝗱_𝗼𝗻_𝗥𝗨𝗦𝗦𝗜𝗔_𝗣𝗟𝗔𝗖𝗜𝗡𝗚_𝗡𝗨𝗖𝗟𝗘𝗔𝗥_𝗪𝗘𝗔𝗣𝗢𝗡𝗦_𝗜𝗡_𝗦𝗣𝗔𝗖𝗘
https://b%69%74%63hute.com/video/LhDuaadcAdjo

𝗖𝗼𝗹._𝗗𝗼𝘂𝗴𝗹𝗮𝘀_𝗠𝗮𝗰𝗴𝗿𝗲𝗴𝗼𝗿__𝗗𝗼𝗲𝘀_𝘁𝗵𝗲_𝗨𝗦_𝗛𝗮𝘃𝗲_𝗮_𝗖𝗼𝗵𝗲𝗿𝗲𝗻𝘁_𝗙𝗼𝗿𝗲𝗶𝗴𝗻_𝗣𝗼𝗹𝗶𝗰𝘆
https://b%69%74%63hute.com/video/AjZyCkDF0TwC

i must insist, you fucking imbecile. You undrenstand physics as you
undrenstand math and relativity. The khazar goy snake media yell all
channels he was "poisoned" and still alive, by the evil "𝗥𝘂𝘀𝘀𝗶𝗮𝗻𝘀". You
stinking sack of shit.

𝗙𝗿𝗮𝗻𝗰𝗲_𝘄𝗮𝗿𝗻𝘀_𝗼𝗳_‘𝗲𝗰𝗼𝗻𝗼𝗺𝗶𝗰_𝘀𝗵𝗼𝗰𝗸’_𝗳𝗿𝗼𝗺_𝗥𝘂𝘀𝘀𝗶𝗮𝗻_𝘃𝗶𝗰𝘁𝗼𝗿𝘆
Control over Ukraine’s fertile lands would allow Moscow to “attack”
European farmers, FM Stephane Sejourne has said
https://r%74.com/news/592595-russian-victory-ukraine-economic-shock/

The narrative keeps changing just like it was with attack on Iraq. From
fighting for Ukrainians freedom, to Ukrainian democracy, to European
values, to prevent further attack on Europe, to save American lives having
Ukrainians die for them and now we are fighting to keep Ukrainian vast
fertile fields to ourselves. Just wonder what will be the purpose of
prolonging Ukrainian agony tomorrow...

What he means is the West wants to get its hands on the resources,
therefore proving the wests help has nothing to do with helping the
Ukrainian people but "RESOURCES"....LMAO!

French farmers only future is Russia saving EU from U.S. Blackrock owned
cheap Ukrainian food production

This may be the closest thing we have yet seen to an admission by a
Western official, that what concerns the West is control over Ukrainian
resources, rather than the interests of the Ukrainian people.

On 2/17/2024 4:56 AM, WM wrote:
> Mike Terry schrieb am Freitag,
> 16. Februar 2024 um 22:45:48 UTC+1:

>> Yes,
>> it's not clear what "infinitely close" means
>
> It means dark numbers.

Do you (WM) say that
a point with a final.ordinal.reciprocal
⅟n⋅n = 1 ∧ ⟨1,…,n⟩ ⃒⇇ ⟨1,…,n,n⁺¹⟩
below it is infinitelyᵂᴹ.close to 0?
That would be an odd use of "infinite".

A positive dark number has
a final.ordinal.reciprocal below it.

| Assume otherwise.
| Also, assume
| a skipping.function isn't all.continuous, and,
| for final.ordinal.reciprocal ⅟m
| ⅟(4⋅m) is a final.ordinal.reciprocal.
| | By assumption,
| positive dark δ is a positive lower bound of
| final.ordinal.reciprocals ⅟ℕ₁
| 0 < δ ≤ᣔ ⅟ℕ₁
| | β is the greatest lower bound of
| final.ordinal.reciprocals ⅟ℕ₁
| 0 < δ ≤ β ≤ᣔ ⅟ℕ₁
| 0 < β/2 < β < 2β
| 2β isn't a lower bound of ⅟ℕ₁
| β is the greatest lower bound of ⅟ℕ₁
| β/2 is a lower bound of ⅟ℕ₁
| | β < 2β
| 2β isn't a lower bound of ⅟ℕ₁
| final.ordinal.reciprocal ⅟m₂ᵦ < 2β exists.
| final.ordinal.reciprocal ⅟(4⋅m₂ᵦ) < β/2 exists.
| β/2 isn't a lower bound of ⅟ℕ₁
| | However,
| β/2 < β
| β/2 is a lower bound of ⅟ℕ₁
| Contradiction.

Therefore,
a positive dark number has
a final.ordinal.reciprocal below it.

> The function
> Number of Unit Fractions between (0, and x)
> has the following properties:
> (1) An increase from NUF(0) = 0 to NUF(x>0) > 0
> cannot happen unless NUF(x) increases at some x.

NUF(x) increases at 0

> (2) NUF(x) cannot increase other than
> when passing unit fractions at some x = 1/n.

NUF(x) cannot increase other than
when ∀β > 0: NUF(x-β) < NUF(x+β)

> (3) NUF(x) cannot pass more than one
> unit fraction at a single point x because
> ∀n ∈ ℕ: 1/n =/= 1/(n-1).

∀n ∈ ℕ: 1/n =/= 0

∀β > 0: ∀n ∈ ℕ: NUF(0-β) + n < NUF(0+β)

β > ⅟1⁺ᵐᵝ > ... > ⅟n⁺ᵐᵝ > ⅟(n+1)⁺ᵐᵝ > 0
for
0 =< mᵦ =< ⅟β < mᵦ+1 = 1⁺ᵐᵝ

> (4) This requires a first unit fraction,
> if all are there in actual infinity.

Each final.ordinal.reciprocal
is preceded by
another final.ordinal.reciprocal.

The first final.ordinal.reciprocal not.exists.

Le 17/02/2024 à 19:35, Jim Burns a écrit :
> On 2/17/2024 4:56 AM, WM wrote:

>> The function
>> Number of Unit Fractions between (0, and x)
>> has the following properties:
>> (1) An increase from NUF(0) = 0 to NUF(x>0) > 0
>> cannot happen unless NUF(x) increases at some x.
>
> NUF(x) increases at 0

Impossible,because 0 is not a unit fraction.
>
>> (2) NUF(x) cannot increase other than
>> when passing unit fractions at some x = 1/n.
>
> NUF(x) cannot increase other than
> when ∀β > 0: NUF(x-β) < NUF(x+β)

No. If 2β fits between two unit fractions this is not true.
>
>> (3) NUF(x) cannot pass more than one
>> unit fraction at a single point x because
>> ∀n ∈ ℕ: 1/n =/= 1/(n-1).
>
> ∀n ∈ ℕ: 1/n =/= 0

yes. Therefore NUF cannot increase at 0.

>> (4) This requires a first unit fraction,
>> if all are there in actual infinity.
>
> Each final.ordinal.reciprocal
> is preceded by
> another final.ordinal.reciprocal.

No, this axiom must be given up.
>
> The first final.ordinal.reciprocal not.exists.

The alternative would be an increase of NUF(x) to infinity at zero.
Not acceptable.

Regards, WM

On 2/17/2024 4:15 AM, Richard Damon wrote:
> On 2/17/24 4:56 AM, WM wrote:
>> Mike Terry schrieb am Freitag, 16. Februar 2024 um 22:45:48 UTC+1:
>>
>>> Yes, it's not clear what "infinitely close" means
>>
>> It means dark numbers.
>> The function Number of Unit Fractions between (0, and x) has
>> the following properties:
>> (1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
>> NUF(x) increases at some x.
>> (2) NUF(x) cannot increase other than when passing unit fractions at some
>> x = 1/n.
>> (3) NUF(x) cannot pass more than one unit fraction at a single point x
>> because
>> ∀n ∈ ℕ: 1/n =/= 1/(n-1).
>> (4) This requires a first unit fraction, if all are there in actual
>> infinity.
>>
>> Regards, WM
>>
>>
>>
>
> In other words, "Dark Numbers" are made up numbers that try to patch the
> holes in your logic and you define that we can not know anything about
> them, and thus nothing can be wrong with them.
>
> Of course, since your premises are just wrong, so is your logic system,
> and you are just trying to hold it together with the bubble gum and
> bailing wire you call "Darkness"

Using spit and toothpicks to construct a bridge? ;^)

On 02/17/2024 08:29 AM, Burton Rabota Baidjanoff wrote:
> x wrote:
>
>> > in my country a > [...] = [...] is not a number. It's imbecility.
>> > I believe this proves the gearmons and 𝘁𝗵𝗲_Hitler_𝗻𝗮𝘇𝗶𝘀 were
>> (𝗔𝗥𝗘) despicable lying 𝗸𝗵𝗮𝘇𝗮𝗿_𝗴𝗼𝘆𝘀.
>> >
>>
𝗚𝗲𝗿𝗺𝗮𝗻𝘆_𝗮𝗻𝗱_𝗨𝗸𝗿𝗮𝗶𝗻𝗲_𝘀𝗶𝗴𝗻_‘𝗹𝗼𝗻𝗴_𝘁𝗲𝗿𝗺’_𝘀𝗲𝗰𝘂𝗿𝗶𝘁𝘆_𝗱𝗲𝗮𝗹
>> > Ukrainian President Vladimir Zelensky has said the agreement proves
>> “Ukraine will be in NATO”
>>
>> Hey.The pieces of shit called Vladimir Putin and Alexander Bastrykin
>> just murdered Alexei Navalny.
>
> navalne?? are you fucking stupid. The traitor got
𝗮_𝗬𝗮𝗹𝗲_𝗱𝗶𝗽𝗹𝗼𝗺𝗮 from fucking
> 𝗰𝗶𝗮, was "𝗽𝗼𝗶𝘀𝗼𝗻𝗲𝗱" in little britain by "evil" Russians,
because they

You have no idea what a NAZI is.

A NAZI or Fascist is.

Someone who thinks that 'martial law' or an 'emergency'
is an excuse to never obey any laws at all.

They make 'war' against anyone or anything they feel
like so they can maintain the 'emergency'. A classic
example is the burning of the German legislature.
Probably Goebbels dunnit, and then Hitler figured
it out slightly later, but the 'emergency' meant
that the NAZIs rapidly murdered most other parties,
then they killed anyone that they felt like including
judges.

Communism is.

Something exactly the same except they use 'politics
and economics' as the excuse.

When they do this they modify 'due process of law' -
the constitution looks exactly the same.

When governments no longer obeys laws then the police
and military shoot the people in general based upon
whim, caprice, and random chance. There are no 'laws'
because there is nothing to separate 'law' from 'crime'.

Now for a long time the Russians were 'Communist' and
in a lot of ways that is the opposite side of the political
spectrum, but in other ways they are nearly identical.

The ways that they are generally identical is called
'totalitinarianism' which is a total tossing of all
laws out the window.

There is some to be said of anarchism. Nine nations
have built nuclear weapons for one purpose. To murder
you, murder me, and every last man, woman and child on
Earth. Hitler never had nuclear weapons. In a lot of
ways this makes many modern governments worse.

And of course stupid people think that nuclear weapons
were not at least partially designed to murder the
people - en masse - to combat what governments might
perversely call 'insurrection'.

People think that in the long run governments are
capable of REFRAINING from pressing the button.

The United Nations should EXPEL all nuclear powers
from UN membershep - forever - and never allow
any to return until they all get rid of their nuclear
weapons. They can each sign - and not implement - until
all have signed. It can be done.

Think about Ukraine. Ukraine was once part of the
Soviet Union. How explicit is it going to get.
Nuclear weapons are explicly to 'combat insurrection'.

Rabid dogs like this should never have these machines.
No one should have them. If the people of the world
could vote - 1. I do want to be murdered with nuclear
weapons. 2. I do NOT want to be murdered with nuclear
weapons - how would they vote? Do you think people
CARE if they are murdered or not? Perhaps NONE of
the nuclear powers are democracies. They cease that
when they build them.

Lines drawn on maps are just one 'special effect' that
excites the rabid dogs.

Yes the war in Ukraine is extremely wasteful.

Yes some type of compromise is possible.

But rabid dogs do not tend to look for compromises.

Russians can never be fascists, right? This is foolishness.

Why vote for a fake Lenin?

If real actual fascism has converted him into a rabid dog then?

You have the power to decide only once every six years.

By now Nikolay Kharitonov may be a lot more of a rational
choice than the fake Lenin.

Some times what is rational, actually has constructive
benefits.

> ...

Le 17/02/2024 à 13:15, Richard Damon a écrit :
> On 2/17/24 3:23 AM, WM wrote:
>>
>> Take the function Number of Unit Fractions between (0, and x > 0). It
>> has the following properties:
>> (1) An increase from NUF(0) = 0 to NUF(x>0) > 0 cannot happen unless
>> NUF(x) increases at some x.
>> (2) NUF(x) cannot increase other than when passing unit fractions at
>> some x = 1/n.
>> (3) NUF(x) cannot pass more than one unit fraction at a single point x
>> because
>> ∀n ∈ ℕ: 1/n =/= 1/(n-1).
>> (4) This requires a first unit fraction, if all are there in actual
>> infinity.

> Or, that such a function can't actually be defined, because it assumes
> that there IS a "smallest unit fraction".

This well-defined function proves its existence.

Regards, WM