Re: specified complexity (was: The Aphenomenon of Abiogenesis)

From: Iain Strachan (iain.strachan.asa@ntlworld.com)
Date: Fri Aug 08 2003 - 15:41:09 EDT

  • Next message: Glenn Morton: "RE: specified complexity (was: The Aphenomenon of Abiogenesis)"

    Josh wrote:

    >
    > -I think it would be best to understand how these series are generated,
    > first. There may be a very simple explanation. For example, if we found
    > something following the pattern 1,2,4,8,16,32,64, etc. we don't
    necessarily
    > have a specification that requires a highly complex explanation. The
    > division of a cell can follow the above pattern very easily, and I've seen
    > Michael Ruse argue that the fibonacchi series is derived from some pattern
    > of cell division established during development. We're talking about an
    > emergent property of a system, in my opinion, that is not necessarily
    > encoded by any specific gene.
    >

    I think Josh has hit the nail on the head here. The algorithm for the
    1,2,4,8 .. series is simple;
    just double the last one. The Fibonacci series "algorithm" is only slightly
    more complex,
    just add the last two together. It is easy to think of a natural physical
    growth process in which this
    could happen (Fibonacci originally derived the series from a simple model of
    rabbit breeding).
    There is no need for any genetic encoding to take place; no "software"
    required.

    But to generate primes is a different matter; to generate a prime of size
    about N you have to generate
    all the previous primes, and store which of the previous ones are composite
    in a "sieve" array in
    memory (if you use the "Sieve of Eratosthenes"). Furthermore, if you
    decide then you want to
    get the next prime that is greater than the size of your sieve array, there
    is no simple way to carry
    on the calculation (as there is with Fibonacci; - just add the last two).
    In the case of primes you
    have to do the whole lot again, because you need to strike out all the
    multiples of 2,3,5 etc in the
    new bigger sieve, which you didn't do the first time. Here's a VBA
    algorithm for computing
    an array of primes in an Excel spreadsheet:

    Function primes(n As Long) As Variant
    nout = Application.Caller.Rows.Count
    ReDim v(1 To nout)
    ReDim p(1 To n) As Integer
    For i = 1 To n
        p(i) = 1
    Next i
    p(1) = 0
    nfound = 0
    For i = 2 To n
        If (p(i) > 0) Then
            nfound = nfound + 1
            v(nfound) = i
            If nfound = nout Then
                Exit For
            End If
            For j = i * i To n Step i
                p(j) = 0
            Next j
        End If
    Next i

    primes = Application.Transpose(v)

    End Function

    Anyone with Excel can try this out if they want. Paste this text into the
    Visual Basic Editor.
    Then in the spreadsheet, select a vertical column of cells & type

    =primes(100)

    which will give the primes up to 100 and zeros thereafter. Then enter
    <Cntrl+Shift+Enter>
    and the array of primes will appear. Now, to get the next prime after that,
    you have to do it
    all again; select the whole range of cells and enter the formula again.

    Now contrast this with generating the next Fibonacci number. You don't need
    a Visual Basic
    program. Just type 1 into cell A1 and 1 into cell A2. Then in cell a3 type

    =a1+a2

    Now select cell A3, extend the selection down and type Cntrl+D (copy the
    formula down)
    You get the Fibonacci series.

    You have entered about the simplest formulae possible; one it's easy to
    imagine happening
    in a natural environment.

    Contrast that with the 20+ lines of code (OK not all of them are core to the
    algorithm), and you
    will see how much more complex, and evidently "designed" the algorithm is.
    (Storage arrays;
    calculating the size and allocation of them, nested loops and whatnot).

    Interesting question; can anyone imagine a way that this algorithm might
    have build up gradualistically
    as a series of simpler algorithms, which also perform "useful" functions,
    such as a mathematical
    series, each one more useful than the last?

    Now, of course, it may be the case that there is a simple rule that
    generates the next prime number
    from the last 2 or so, but the mathematician who finds this holy grail (if
    such exists), will be
    very famous indeed.

    On the basis of this, I'd say that a sequence of primes coming in from space
    (as Jodi Foster got
    in the "Contact" film of Sagan's book) would be a far more convincing sign
    of ET intelligence than
    a sequence of Fibonacci numbers; which could be a sequence of pulses
    arising from a simple
    growth process.

    Iain



    This archive was generated by hypermail 2.1.4 : Fri Aug 08 2003 - 15:41:41 EDT