emacs-orgmode
[Top][All Lists]

## Re: [more absurd]

 From: Martin Steffen Subject: Re: [more absurd] Date: Mon, 04 Jul 2022 15:18:31 +0200 User-agent: Gnus/5.13 (Gnus v5.13) Emacs/27.2 (gnu/linux)

```>>>>>   <tomas@tuxteam.de> writes:

> About the cultural thing... you seem to be a zero-counter (as I

I guess I am, by maybe have not been a zero-counter from the start, but
a 1-counter. I vaguely remember to have learnt (at school? beginning at
university?) that ``THE natural numbers'' (the ones Kronecker claimed to
have been created by God) start with \$1\$. There are referred to by
\$\mathbb{N}\$, and then there's also some versions, written
\$\mathbb{N}_0\$ (THE natural numbers ``extended'' by 0), they can be
handy too, sometimes.

>From a constructivistic point of view (and as a computer scientist, one
is obliged to have a constructivist view), for me 0 belongs to the most
natural way of defining natural numbers.

The fact that some theorems or facts are stated better this way or the
other is minor (as long as it's not that the vast majority of math on
Nats gets simpler without 0 (or with 0). One would also not work with
Nats starting at two like Nat ={2, 3,4,...}, for the extravagant
advantage to avoid stating clumsily a special-case condition ``a prime
number is a natural number larger or equal 2 and only divisible by 1 or
itself'' (if one thinks 1 and 0 are better not included in the prime
numbers, as most would do).

Constructing the nats from first principles seems to me a Nat is either
0, or the successor of a nat (succ n). Also for lists (and in complete
analogy): Lists are either empty () or built from cons-ing an element to
a list.

An analogous construction would of course also work using 1 as base
case resp. a one-element list as basic constructor. But it ``feels''
less natural for me in the meantime.

[talking about programming and data structures: while I think from a
practical (and aesthetic) point of view, lists should include the empty
list, and not start with lists of length 1 (likewise that functions
should be allowed to have a 0-length input parameter list), I found it
interesteding that _internally_, lists and similar data structures are
often usefully implemented with some ``sentinel'' node, i.e., the empty
lists is represented by some ``dummy cell'' in memory (not by
``nothing''), and a list of length n has additionally one such dummy
cell at the end, say, to make walking through the list, resp. checking
for the end more smooth and uniform, sometimes.]

> am, too): there, too, I think that "our" position isn't in any way
> "better" -- some theorems look better this way, some that way;
> some inductions are easier to start at 1, some at 0.

> Cheers -- t

```