The Lucas sequence follows the same rules for its generation as the Fibonacci sequence, except that the Lucas sequence begins with t_{1} = 2 and t_{2} =1.

Lucas numbers are found in the petal counts of flowing plants and pinecone spirals much the same as the Fibonnaci numbers. Also, like the Fibonacci numbers, successive pairs of Lucas numbers can be divided to make the Golden Ratio, . The Mathematica version (10) which I am using has a way of highlighting certain numbers that meet certain conditions. One of them is the `Framed[]`

function, which draws a box around numbers. `Framed[]`

can be placed into `If[]`

statements so that an array of numbers can be fed into it (using a `Table[]`

command).

For example, let’s frame all Lucas numbers that are prime:

`In[1]:= If[PrimeQ[#], Framed[#], #] & /@ Table[L[n], {n, 0, 30}]`

The `If[]`

statement is best described as:

`If[Condition[#], do_if_true[#], do_if_false[#]]`

The crosshatch # is a positional parameter upon which some condition is placed by some function we are calling `Condition[]`

. This boolean function returns `True`

or `False`

. In the statement we are using above, the function `PrimeQ`

will return true if the number in the positional parameter is prime; false if 1 or composite.

The positional parameters require a source of numbers by which to make computations, so for this source, we shall look to a sequence of Lucas numbers generated by the `Table`

command. The function which generates the numbers is a user-defined function `L[n_]`

:

`In[2]:= L[0] := 2`

In[3]:= L[1] := 1

`In[4]:= L[n_] := L[n-2] + L[n-1]`

With that, I can generate an array with the Table[] command to get the first 31 Lucas numbers:

`In[5]:= Table[L[n], {n, 0, 30}]`

{2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843, 1364, \

2207, 3571, 5778, 9349, 15127, 24476, 39603, 64079, 103682, 167761, \

271443, 439204, 710647, 1149851, 1860498}

This list (or “table”) of numbers is passed through the `If[]`

statement thusly:

`In[6]:= If[PrimeQ[#], Framed[#], #] & /@ Table[L[n], {n, 0, 30}]`

to produce the following output:

`In[7]:=`

Note that this one was an actual screenshot, to get the effect of the boxes. So, these are the first 31 Lucas numbers, with boxes around the prime numbers. The `Table[]`

command appears to feed the Lucas numbers into the positional parameters represented by `#`

.

There was a sequence I created. Maybe it’s already famous; I have no idea. On the other hand, maybe no one cares. But I wanted to show that with any made-up sequence that is recursive in the same way Fibonacci and Lucas numbers were, that I could show, for example, that as the numbers grow, neighbouring numbers can get closer to the Golden Ratio. The Golden Ratio is . I want to show that this is not really anything special that would be attributed to Fibonacci or François Lucas. It can be shown that, for any recursive sequence involving the next term being the sum of the previous two terms, sooner or later, you will always approach the Golden Ratio in the same way. It doesn’t matter what your starting numbers are. In Lucas’s sequence, the numbers don’t even have to begin in order. So let’s say I have:

`K[0] := 2`

K[1] := 5

`K[n_] := K[n-2] + K[n-1]`

So, just for kicks, I’ll show the first 31 terms:

`Table[K[n], {n, 0, 30}]`

{2, 5, 7, 12, 19, 31, 50, 81, 131, 212, 343, 555, 898, 1453, 2351, \

3804, 6155, 9959, 16114, 26073, 42187, 68260, 110447, 178707, 289154, \

467861, 757015, 1224876, 1981891, 3206767, 5188658}

Now, let’s output the Golden Ratio to 15 decimals as a reference:

`N[GoldenRatio, 15]`

1.61803398874989

Now, let’s take the ratio of the last two numbers in my 31-member sequence:

`N[K[30]/K[29], 15]`

1.61803398874942

You may say that the last two digits are off, but trying against the Fibonacci sequence, the ratio of the 30th and 31st numbers yields merely: 1.61803398874820, off by 3 digits.

For Lucas: 1.61803398875159, off by 4 digits — even worse.

So, my made-up sequence is more accurate for than either Lucas or Fibonacci. I have tried other made-up sequences. Some are more, and some are less accurate. If it depends on the starting numbers, I think some combinations work better, and you won’t necessarily get greater accuracy by starting and ending with larger numbers.