[Question]
  [
A [man from the stars](https://codegolf.stackexchange.com/users/12914/elendia-starman) has come to Earth! Luckily the president of the United States, Donald Trump, has an infinity-sided die. Using this die, he can conjure up a number which *you*, the mayor of [Podunk](http://earthbound.wikia.com/wiki/Podunk), must use to determine who should be sent to stop the invader! But be careful, you can only send a limited amount of bytes on the back of your [frog](http://earthbound.wikia.com/wiki/Save_Frog)!
Given a user input (which will be a positive integer), you must return a string depending on what category the number is in.
* If the number is a [**Fibonacci number**](https://en.wikipedia.org/wiki/Fibonacci_number), you must output [***Ness***](http://earthbound.wikia.com/wiki/Ness).
* If the number is a [**Lucas number**](https://en.wikipedia.org/wiki/Lucas_number), you must output [***Lucas***](http://earthbound.wikia.com/wiki/Lucas).
* If the number is *both* a **Lucas number** and a **Fibonacci number**, you must output [***Travis***](http://www.mother4game.com/).
* If the number is *neither* a a **Lucas number** nor a **Fibonacci number**, you must output [***Pippi***](http://earthbound.wikia.com/wiki/Pippi).
## Examples
Here are a bunch of test cases:
```
1 => Travis
2 => Travis
3 => Travis
4 => Lucas
5 => Ness
6 => Pippi
7 => Lucas
8 => Ness
610 => Ness
722 => Pippi
843 => Lucas
```
## Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest answer in bytes wins.
* You program may be a full program or a(n anonymous) function.
## Bonuses
There are a couple bonuses that you can use to help your frog get the data to President Trump faster:
* **For `-15` bytes:** If the input number is `2016`, you must output `Trump`, as he is at the peak of his presidency.
  
[Answer]
# Julia, ~~146~~ ~~142~~ ~~121~~ 120 bytes
```
n->split("Pippi Lucas Ness Travis")[2any(isinteger,sqrt([5n^2+4,5n^2-4]))+(n∈[2;[(g=golden)^i+(-g)^-i for i=1:n]])+1]
```
This creates an unnamed function that returns a boolean. To call it, give it a name, e.g. `f=n->...`.
Ungolfed:
```
function trump(n::Integer)
    # Determine if n is a Fibonacci number by checking whether
    # 5n^2 ± 4 is a perfect square
    F = any(isinteger, sqrt([5n^2 + 4, 5n^2 - 4]))
    # Determine if n is a Lucas number by generating Lucas
    # numbers and testing for membership
    # golden is a built-in constant containing the golden ratio
    L = n ∈ [2; [golden^i + (-golden)^-i for i = 1:n]]
    # Select the appropriate Earthbound charater using array
    # indexing on a string split into an array on spaces
    return split("Pippi Lucas Ness Travis")[2F+L+1]
end
```
Fixed an issue and saved 7 bytes thanks to Glen O!
[Answer]
# Mathematica ~~143~~ 156 - 15 (bonus) = 141 bytes
With 2 bytes saved thanks to LegionMammal978.
```
t_~g~l_:=(r=1<0;n=1;While[(z=l@n)<=t,If[z==t,r=1>0];n++];r);a=g[k=Input[],LucasL];
b=k~g~Fibonacci;Which[k==2016,Trump,a&&b,Travis,a,Lucas,b,Ness,2<3,Pippi]
```
[Answer]
# Mathematica, ~~92~~ 87 bytes
Inspired by [Sp3000's answer](https://codegolf.stackexchange.com/a/64484/9288).
```
Travis[Ness,Lucas,Pippi][[{2,1}.Product[Abs@Sign[{Fibonacci@n,LucasL@n}-#],{n,0,2#}]]]&
```
[Answer]
# Pyth, 59 - 15 = 44 bytes
*or 42 bytes after a bug was fixed*
```
&Qr@c."av�a�(s��kW�С��"\b?q2016Q4/hMst*2.uL,eNsNQ_BS2Q4
```
Hexdump:
```
0000000: 2651 7240 632e 2261 7601 c061 15dc 2873  &Qr@c."av..a..(s
0000010: fde0 6b57 8bd0 a1ed ed0f 225c 623f 7132  ..kW......"\b?q2
0000020: 3031 3651 342f 684d 7374 2a32 2e75 4c2c  016Q4/hMst*2.uL,
0000030: 654e 734e 515f 4253 3251 34              eNsNQ_BS2Q4
```
The first two characters (`&Q`) are necessary because of a Pyth parsing bug that makes `Q` after `."` fail. Fix has been applied. If the post-bugfix interpreter is allowed, -2 bytes.
---
Without unreadable string compression:
# Pyth, 63 - 15 = 48 bytes
*49 bytes without Trump*
```
@c"Pippi Ness Lucas Travis Trump")?nQ2016/hMst*2.uL,eNsNQ_BS2Q4
```
[Test Suite](https://pyth.herokuapp.com/?code=%40c%22Pippi+Ness+Lucas+Travis+Trump%22%29%3FnQ2016%2FhMst%2a2.uL%2CeNsNQ_BS2Q4&input=843&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A610%0A722%0A843%0A2016&debug=0)
Pretty straightforward, just generate the sequences, duplicate one and check for membership.
Sequences are generated by starting with `[1, 2]` and `[2, 1]`, and then applying the fibonacci rule.
[Answer]
## Python 2, 107
```
f=lambda i,n=input():abs(5*n*n+i)**.5%1>0
print["Travis","Lucas","Ness","Pippi"][f(4)*f(-4)+2*f(20)*f(-20)]
```
The key is two purely arithmetical checks for Fibonacci and Lucas numbers:
* `n` is a Fibonacci number exactly if `5*n*n+4` or `5*n*n-4` is a perfect square
* `n` is a Lucas number exactly if `5*n*n+20` or `5*n*n-20` is a perfect square
[This site has proof sketches](https://web.archive.org/web/20170303035519/http://hubpages.com/education/How-to-Tell-if-a-Number-is-a-Fibonacci-Number).
So, the output depends on the values of `5*n*n+i` for `i` in `{4,-4,20,-20}`. The function `f` tests a value of `i`, by checking if the corresponding value *does not* have a whole-number square root The `abs` is there just to avoid an error of taking the root of a negative for `n=1, i=-20`.
The function `f` takes the value of the number `n` to test from STDIN. Python only evaluates this once, not once per function call.
Whether the number is not Fibonacci is evaluated as `f(4)*f(-4)` using the implicit boolean to number conversion and similarly for not Lucas, and the corresponding string is taken. If trailing spaces were allowed, string interleaving would be shorter.
[Answer]
## Python 2, 117 bytes
```
F=[1]
L=[2,1]
n=input()
exec 2*n*"F,L=L+[sum(L[-2:])],F;"
print["Pippi","Lucas","Ness","Travis"][(n in F)*2+(n in L)]
```
For the string list, `"Pippi Lucas Ness Travis".split()` is the same length.
[Answer]
## CJam, ~~58~~ ~~55~~ 54 bytes
```
ri5Zbe!f{1${_-2>:++}*&!}2b"Travis Ness Lucas Pippi"S/=
```
Naïve approach of generating the Fibonacci and Lucas numbers then counting occurences in both, converting to binary, and picking the appropriate string.
[Try it online](http://cjam.aditsu.net/#code=ri5Zbe!f%7B1%24%7B_-2%3E%3A%2B%2B%7D*%26!%7D2b%22Travis%20Ness%20Lucas%20Pippi%22S%2F%3D&input=843).
[Answer]
## Perl, ~~133~~ ~~(146-15=)131~~ ~~(144-15=)129~~ (136-15=)121 bytes
+1 byte for the `-n` flag.
```
$a=$d=1;$b=$c=2;$f+=$_==$a,$l+=$_==$c,($a,$b,$c,$d)=($b,$a+$b,$d,$c+$d)while$a<$_*9;say$_-2016?(Pippi,Ness,Lucas,Travis)[$f+$l*2]:Trump
```
With newlines after semicolons, for readability:
```
$a=$d=1;$b=$c=2;
$f+=$_==$a,$l+=$_==$c,($a,$b,$c,$d)=($b,$a+$b,$d,$c+$d)while$a<$_*9;
say$_-2016?(Pippi,Ness,Lucas,Travis)[$f+$l*2]:Trump
```
Demo:
```
llama@llama:...code/perl/ppcg64476trump$ for x in 1 2 3 4 5 6 7 8 610 722 843 2016; do echo -n "$x => "; echo $x | perl -n trump.pl; done
1 => Travis
2 => Travis
3 => Travis
4 => Lucas
5 => Ness
6 => Pippi
7 => Lucas
8 => Ness
610 => Ness
722 => Pippi
843 => Lucas
2016 => Trump
```
Tricks:
* ~~You might be wondering why my variables are named `$a`, `$b`, `$%`, and `$d`. That is an excellent question! In fact, it allows me to save a byte.~~
```
(stuff) ... ,$l+=$_==$%while$a<$_
```
is one byte shorter than
```
(stuff) ... ,$l+=$_==$c while $a<$_
```
 This no longer applies because I golfed my code by rearranging things, causing the variable name change to no longer save bytes. I changed it back so that variable names make sense again.
* ~~`$_-2?$f+$l*2:3` is mildly interesting. Basically, I had to special-case `2` for Lucas numbers because my program checks whether a number is a Lucas number *after* "updating" the Fibonacci and Lucas numbers. So `2` was considered a not-Lucas number. `$_-2?foo:bar` is a char shorter than `$_==2?bar:foo`. Same thing is used for the `2016` test.~~
This is also no longer true because I was able to restructure the program to not require special-casing `2`. But I still use `$_-2016?stuff:Trump` instead of `$_==2016?Trump:stuff`, which is one byte longer.
* Speaking of which, you may be wondering how I did this restructuring. I just made the program do 9 times more iterations than necessary, which only costs 2 bytes (`*9`) but allows me to make assumptions elsewhere that help golf stuff down.
* Because variables default to zero,
```
$f+=$_==$a
```
is shorter than
```
$f=1if$_==$a
```
* Perl supports barewords, so I don't have to quote any of my strings (\o/).
[Answer]
# Seriously, 69 bytes
```
,;;r`;F@2+F+`M2@q@#"%d="%£MΣ@f0≤2*+["Pippi","Lucas","Ness","Travis"]E
```
Before this challenge, Seriously had the builtin `f` (index in Fibonacci numbers, -1 if not a Fibonacci number)... but not index in a list or "is in list"! (It's since been added as `í`.)
As a result, this is what I spend finding if the input is a Fibonacci number:
```
,                              f0≤
```
This is what I spend generating a list of Lucas numbers:
```
  ;r`;F@2+F+`M2@q
```
And this is what I spend finding if the input is in the list of Lucas numbers:
```
 ;                @#":%d:="%£MΣ
```
That's a string being formatted using Python's % notation into something like `:610:=`, and converted to a function, which is then mapped over the array and summed. (The Lucas numbers are unique, so the sum is always 0 or 1.)
Thanks to @Mego for that last bit with the string formatting.
[Answer]
# Julia, ~~101~~ 100 bytes
```
n->split("Pippi Lucas Ness Travis")[[2;1]⋅(sum(i->[i[];trace(i)].==n,Any[[1 1;1 0]].^(0:n)).>0)+1]
```
Ungolfed:
```
function f(n)
  k=Any[[1 1;1 0]].^(0:n) # Produces characteristic matrices of Fibonacci
                          # numbers from 0 to n
  F=sum(i->i[]==n,k)      # Check if n is a Fibonacci number by checking
                          # the first value in each matrix for n
  L=sum(i->trace(i)==n,k) # Check if n is a Lucas number by checking
                          # the trace of each matrix for n
  I=[2;1]⋅[F;L]+1         # Calculate 2F+L+1, which is the index for the next step
  S=split("Pippi Lucas Ness Travis") # Creates array with four strings
                          # saves a byte compared with directly creating array
  return S[I]
      # This uses the above calculations to determine which of the four to return
end
```
[Answer]
# Octave, 93 bytes
```
@(n){'Pippi','Lucas','Ness','Travis'}{(1:2)*any(~rem(real(sqrt(5*n^2+[-20,-4;20,4])),1)).'+1}
```
This approach is similar to [my MATLAB answer](https://codegolf.stackexchange.com/a/76849/51939) with the exception that Octave allows you to index directly into a fresh array:
```
{'a', 'b', 'c'}{2}    %// b
```
[Answer]
# MATL, ~~57~~ ~~55~~ ~~54~~ (67-15) = 52 bytes
```
20Kht_vi2^5*+X^Xj1\~a2:*sG2016=-'Lucas Ness Travis Trump Pippi'Ybw)
```
[**Try it Online!**](http://matl.tryitonline.net/#code=MjBLaHRfdmkyXjUqK1heWGoxXH5hMjoqc0cyMDE2PS0nTHVjYXMgTmVzcyBUcmF2aXMgVHJ1bXAgUGlwcGknWWJ3KQ&input=MjAxNg)
**Explanation**
Again, similar logic to my other answers [here](https://codegolf.stackexchange.com/a/76851/51939) and [here](https://codegolf.stackexchange.com/a/76849/51939).
```
20      % Number literal
K       % Retrieve the number 4 from the K clipboard (the default value)
h       % Horizontal concatenation to produce [20 4]
t       % Duplicate elements
_v      % Negate and vertically append elements (yields [20, 4; -20 -4])
i2^     % Explicitly grab the input and square it
5*      % Multiply by 5
+       % Add this to the matrix ([20, 4; -20 -4])
X^      % Take the square root
Xj      % Ensure that the result is a real number
1\      % Get the decimal component
~       % Create a logical arrays where we have TRUE when no remainder
a       % For each column determine if any element is TRUE
2:      % Create the array 1:2
*       % Perform element-wise multiplication with boolean
s       % Sum the result to yield an index
G       % Explicitly grab the input (again)
2016=   % Check to see if it is 2016 (yields TRUE (1) if equal)
-       % Then subtract the boolean from the index. Since 2016 is NOT a
        % Fibonacci or Lucas number, the original index is 0. Subtracting
        % this boolean, will make this index now -1. For all other non-2016
        % numbers this will have no effect on the index.
'Lucas Ness Travis Trump Pippi' % Create the possible strings values 
        % Note: the 0 index wraps around to the end hence Pippi being at the end.
        % The next to last entry ('Trump') is ONLY accessible via a -1 index as
        % discussed above
Yb      % Split at the spaces to create a cell array
w       % Flip the top two stack elements
)       % Retrieve the desired value from the cell array
```
[Answer]
# C++11, 176 + 15 (#include) = 191
```
#include<mutex>
[](int n){std::function<int(int,int)>c=[&](int f,int s){return f-s>n?0:s-n?c(s,f+s):1;};int l=c(2,1),f=c(1,1);l&f?puts("Travis"):l?puts("Lucas"):f?puts("Ness"):puts("Pippi");}
```
Ungolfed with usage. I can add explanation if requested tomorrow, gtg to bed now!
```
#include <functional>
#include <cstdio>
int main()
{
    auto r = [](int n)
    {
        std::function<int(int, int)> c = [&](int f, int s)
        {
            return f - s > n ? 0 : f - n ? c(s, f + s) : 1;
        };
        int l = c(2, 1), f = c(1, 1);
        l & f ? puts("Travis") : l ? puts("Lucas") : f ? puts("Ness") : puts("Pippi");
    };
    for (int i : { 1, 2, 3, 4, 5, 6, 7, 8, 610, 722, 843 })
    {
        printf("%i - ", i); r(i);
    }
}
```
[Answer]
# Javascript (ES6), 108 bytes
```
x=>(f=(a,x,y)=>a==y||a==x?1:a<y?0:f(a,y,x+y),b=f(x,0,1),c=f(x,2,1),b&&c?'Travis':b?'Ness':c?'Lucas':'Pippi')
```
Same function for Fibonnacci and Lucas. It's a recursive function that takes the first two values as init.
[Answer]
# Java, 151 bytes
You could argue that Trump would never outsource this crucial decision, so we wouldn't have to make the method public, saving another 7 bytes. 
```
public String t(int n){return"Pippi,Lucas,Ness,Travis".split(",")[2*f(n,1,1)+f(n,2,1)];}int f(int a,int x,int y){return a==x||a==y?1:a<y?0:f(a,y,x+y);}
```
Ungolfed including test-main invocation
```
public class Trump {
    //Test Invokation
    public static void main(String[] args) {
        int[] n = {1, 2, 3, 4, 5, 6, 7, 8, 610, 722, 843, 2016 };
        for(int i = 0; i < n.length; ++i) {
            System.out.println(""+ n[i] + " => " + new Trump().t(n[i]));
        }
    }
    public String t(int n) {        
        return "Pippi,Lucas,Ness,Travis".split(",")[2*f(n,1,1)+f(n,2,1)];               
    }
    int f(int a,int x,int y) {             
        return a==x||a==y?1:a<y?0:f(a,y,x+y);           
    }
}
```
I found no way so far to test for 2016 and return "Trump" in code that's less than 15 bytes in code. 
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~39~~ 37 (52 - 15 bonus) [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
2016Qi.•ªb‚•ë>ÅG¹å_¹ÅF¹åi.•F_ïk|»9•ë.•?®B'5n•}2äsè}™
```
[Try it online](https://tio.run/##yy9OTMpM/f/fyMDQLDBT71HDokOrkh41zAIyDq@2O9zqfmjn4aXxQKLVDcQCq3CLP7w@u@bQbkuwIpCI/aF1TuqmeUBWrdHhJcWHV9Q@alkEMdQAAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn1l5X8jA0OzwEy9Rw2LDq1KetQwC8g4vNrucKt75eGl8ZWHW92ANFjaLf7w@uyaQ7stwSpAIvaH1jmpm@YBWbVGh5cUH15R@6hl0X@d/4ZcRlzGXCZcplxmXOZcFlxmhgZc5kZGXBYmxlwg6wA).
**Explanation:**
```
2016Qi                # If the input equals 2016:
      .•ªb‚•          #  Push "trump" to the stack
ë                     # Else:
 >ÅG                  #  List of Lucas numbers up to and including the input+1
    ¹å                #  Check if the input is in this list (1 if truthy; 0 if falsey)
      _               #  Invert the boolean (0→1 and 1→0)
 ¹ÅF                  #  List of Fibonacci numbers up to and including the input
    ¹åi               #  If the input is in this list:
       .•F_ïk|»9•     #   Push string "travisnessi" to the stack
    ë                 #  Else:
     .•?®B'5n•        #   Push string "pippilucas" to the stack
    }                 #  Close the inner if-else
     2ä               #  Split the string into two parts
                      #   i.e. "travisnessi" → ["travis","nessi"]
                      #   i.e. "pippilucas" → ["pippi","lucas"]
       sè             #  Index the Lucas result into the list of two strings
}                     # Close the outer if-else
 ™                    # And output the top of the stack in title-case
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~128~~ ~~120~~ ~~116~~ 110 bytes
```
a;b;o;f(n){for(o=b=0,a=1;a<=n;b=a+b,a=b-a)o|=(b==n)+2*(2*a+b==n);n=o?o-1?o-2?"Travis":"Lucas":"Ness":"Pippi";}
```
[Try it online!](https://tio.run/##ZY7BbsIwDIbvfYooElICrUSzwtA8wwtMsANHLk6hUw4kVQtcoM/eJeIEPlj2//n/LdfFX12PI4GFAI3y@t6ETgW0OM8JS6Bv9GCRZjZKW5AOD1QW0euZmSozjYskwGPYhKKMZTZy39HN9fJL/lxrSn176lP7dW3rJAzjLbijaDvnL1s6n3aNipNwWtyfsFFyUh0FrsWkP3iZuzw6tAYxZFlynsl5Fd2ZeDlSangjhpEPRipGFowsGflkZMVT5ZznDP9pVaWvhvEf "C (gcc) – Try It Online")
# Explanation
Let's name `F(n)` the n-th Fibonacci number, and `L(n)` the n-th Lucas number.  
`a`, `b` are `F(n-1)`, `F(n)` respectively.  
Then we can calculate `L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b`  
This function will successively calculate Fibonacci and Lucas numbers, up to `n`, and check if `n` is any of them.  
If `n` is a Fibonacci number, the 1st bit of `o` will be set to `1`  
If `n` is a Lucas number, the 2nd bit of `o` will be set to `1`  
`o` will then be used to determine which name to output
# Edit
* Saved 8 bytes by golfing the condition of the for-loop : starting at second iteration, we have `a<b<c` and `a<a+c=L(n)`, so `( b<=n || a+c<=n ) => a<n`. I actually needed `a<=n` to handle correctly `n=1`
* Saved 4 bytes thanks to ceilingcat ! (also corrected a mistake, my code was outputting "2 => Ness")
* Saved 6 bytes:
	+ 2 thanks to ceilingcat again
	+ 4 by removing the variable `c`, equal to `F(n+1)`, which was useless since we can already calculate `F(n+1)` with `a` and `b`
[Answer]
## Perl 5.10, 119 - 15 (bonus) = 104 bytes
```
$_=<>;$j=1;($i,$j)=($j,$i+$j)while$_>$i;say$_-2016?(Pippi,Lucas,Ness,Travis)[($_==$i)*2|$_==3*$j-4*$i|$_-1>>1==0]:Trump
```
Ungolfed:
```
# Read line from stdin
$_ = <>;
# Find first Fibonacci number greater than or equal to input.
# Store this number in $i and the next Fibonacci number in $j.
$j = 1;
($i, $j) = ($j, $i + $j) while $_ > $i;
say $_ - 2016
  ? (Pippi,Lucas,Ness,Travis)[
      ($_ == $i) * 2 |          # Bitwise OR with 2 if Fibonacci number
      $_ == 3 * $j - 4 * $i |   # Bitwise OR with 1 if Lucas number >= 3
      $_ - 1 >> 1 == 0          # Bitwise OR with 1 if Lucas number <= 2
    ]
  : Trump
```
This exploits the fact that
```
L(n-2) = 3 * F(n+1) - 4 * F(n)
```
is the greatest Lucas number lower to or equal than F(n).
[Answer]
# Groovy, 149 bytes
```
f={i->g={m,s->while(s[-2]<=m)s<<s[-2]+s[-1];s}
println(["Pippi","Ness","Lucas","Travis"][(g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)])}
```
Test code:
```
[1,2,3,4,5,6,7,8,610,722,843].each {
    print "$it => "
    f(it)
}
```
`g` is a closure that generates a list of numbers based on a seed (`s`) and a max value (`m`). `(g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)` finds the index to use based on the number being lucas or fibonacci.
[Answer]
# MATLAB, ~~122~~ 119 bytes
```
@(n)subsref({'Pippi','Lucas','Ness','Travis'},substruct('{}',{(1:2)*any(~rem(real(sqrt(5*n^2+[-20,-4;20,4])),1)).'+1}))
```
**Brief Explanation**
We first create a cell array containing the values to print: `{'Pippi', 'Lucas', 'Ness', 'Travis'}`. Then to figure out which value to display, we check to see whether `n` is a Fibonacci or Lucas number.
For Fibonnaci, we use the following formula:
```
any(~rem(sqrt(5*n^2 + [-4 4]), 1))
```
This checks to see if either `5*n^2 + 4` or `5*n^2 - 4` are a perfect square. If `any` of them are, then it is a Fibonacci number.
The formula for a Lucas number is *very* similar with the exception that we use +/- 20 instead of 4:
```
any(~rem(sqrt(5*n^2 + [-20 20]), 1))
```
In this solution I combined these two cases into one by using the matrix:
```
M = [-20 -4
      20  4]
 
```
By applying the same equation as those above, but force `any` to consider only the first dimension, I get a two element logical array where if the first element is `true`, then it is a Lucas number and if the second element is `true`, it is a fibonacci number.
```
any(~rem(sqrt(5*n^2 + [-20 -4;20 4]), 1))
```
Then to compute the index into my initial cell array, I treat this as a binary sequence by performing element-wise multiplication of this boolean with `[2^0, 2^1]` or simply `[1,2]`. And sum the elements. Obviously I have to add 1 because of MATLAB's one-based indexing.
```
index = (1:2) * any(~rem(real(sqrt(5*n^2+[-20,-4;20,4])),1)).' + 1;
```
Then I have to use `subsref` and `substruct` to index into the initial cell array to obtain the final result.
[Answer]
## JavaScript (ES6), 97 bytes
```
x=>[['Pippi','Lucas'],['Ness','Travis'],f=(a,x,y=1)=>a>x?f(a,y,x+y):a==x||a==1][+f(x,0)][+f(x,2)]
```
The `a==1` check is needed otherwise I don't notice that 1 is a Lucas number.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 47 bytes - 15 = 32
```
+2ḶÆḞ⁸eð+ị“©ḤʠhMṂƁÞḄṭAƓ»Ḳ¤µ2+Ð¡-⁸eḤ
“¡Ỵ¦»Ç⁼?⁽¥Ð
```
[Try it online!](https://tio.run/##AW8AkP9qZWxsef//KzLhuLbDhuG4nuKBuGXDsCvhu4vigJzCqeG4pMqgaE3huYLGgcOe4biE4bmtQcaTwrvhuLLCpMK1MivDkMKhLeKBuGXhuKQK4oCcwqHhu7TCpsK7w4figbw/4oG9wqXDkP///zIwMTY "Jelly – Try It Online")
]