Influenced by Non-discriminating Programming, I made up an idea of a similar challenge.

Here, we say a string is a Lucas string if the number of appearances of each character is a Lucas number (2, 1, 3, 4, 7, ...), and a string is a Fibonacci string if the number of appearances of each character is a Fibonacci number (1, 2, 3, 5, 8, ...).

Here are some concrete examples:

"Programming Puzzles"
Appearance Count: P a e g i l m n o r s u z
 1 2 1 1 2 1 1 2 1 1 2 1 1 2

All counts are both Lucas numbers and Fibonacci numbers, so this is both a Lucas string and a Fibonacci String

"Sandbox for Proposed Challenges"
Appearance Count: C P S a b d e f g h l n o p r s x
 3 1 1 1 2 1 2 3 1 1 1 2 2 4 1 2 2 1

All counts are Lucas numbers, so this is a Lucas string. However the count of o is not a Fibonacci number, so this is not a Fibonacci string.

"Here are some concrete examples: "
Appearance Count: : H a c e l m n o p r s t x
 5 1 1 2 2 8 1 2 1 2 1 3 2 1 1

All counts are Fibonacci, so this is a Fibonacci string. However the counts of and e are not Lucas numbers, so this is not a Lucas string.

"Non-discriminating Programming"
Appearance Count: - N P a c d g i m n o r s t
 1 1 1 1 2 1 1 3 5 3 4 2 3 1 1

Since count of i is not Lucas number, and count of n is not Fibonacci number, so this is neither a Lucas string nor a Fibonacci String.

Challenge

Write 2 programs, one Lucas program and one Fibonacci program, both accepting a string as input, that:

• The Lucas program checks whether the input is Fibonacci; and


• The Fibonacci program checks whether the input is Lucas,

where the definitions of "Lucas" and "Fibonacci" are as above.

Rules

• Your programs can choose to receive input either from STDIN or as function/program argument.


• Your programs must output or return one of the 2(TWO) distinct values at your choice, one for the truthy value and one for the falsy value, and the choice must be consistent across the programs, i.e. you cannot have one program returning 0/1 while the other one returning true/false.


• Your programs must output or return a truthy value if the source of each other is inputted, i.e. your Lucas program must return a truthy value if the source of your Fibonacci program is inputted, and vice versa.


• It is allowed to have program being both Lucas and Fibonacci.


• Characters not used are apparently not counted, in case you doubt because 0 is not in the Lucas sequence.


• Number of distinct characters in each program are not restricted to either Lucas or Fibonacci numbers.


• Only full programs or functions allowed. Snippets are not accepted.


• Standard loopholes are apparently forbidden.

Scoring

The score will be calculated as follows:

• For each program, multiply the number of distinct characters used by the maximum number of appearances of the characters in the source.


• Add the two values calculated in the previous step up. This is your score.

Example:

Lucas code : 20 distinct characters, MAX(appearance of each character)=7
Fibonacci code: 30 distinct characters, MAX(appearance of each character)=5
Score: 20*7 + 30*5 = 140 + 150 = 290

Test cases

Input | Output of ... 
 | Lucas Program | Fibonacci Program
----------------------------------------+---------------------------------------
<Your Lucas program> | True if all appe- | True
(Lucas string by rules) | arance counts are |
 | exactly 1, 2 or 3; |
 | False otherwise |
----------------------------------------+--------------------+------------------
<Your Fibonacci program> | True | True if all appe-
(Fibonacci string by rules) | | arance counts are
 | | exactly 1, 2 or 3;
 | | False otherwise
----------------------------------------+--------------------+------------------
"Programming Puzzles" | True | True
(Both Lucas and Fibonacci) | | 
----------------------------------------+--------------------+------------------
"Sandbox for Proposed Challenges" | False | True
(Lucas but not Fibonacci) | | 
----------------------------------------+--------------------+------------------
"Here are some concrete examples: " | True | False
(Fibonacci but not Lucas) | |
----------------------------------------+--------------------+------------------
"Non-discriminating Programming" | False | False
(Neither Lucas nor Fibonacci) | |
----------------------------------------+--------------------+------------------
"Hello world!" | True | True
(Both Lucas and Fibonacci) | | 
----------------------------------------+--------------------+------------------
"18446744073709551616" | False | True
(Lucas but not Fibonacci) | | 
----------------------------------------+--------------------+------------------
"Lucas and Fibonacci are IN pair" | True | False
(Fibonacci but not Lucas) | |
----------------------------------------+--------------------+------------------
"Lucas and Fibonacci are in pair" | False | False
(Neither Lucas nor Fibonacci) | |

Winning Criteria

The submission with the lowest score in each language wins.

05AB1E, score: 10 + 8 = 18

This could be a comment on Kevin's post, but I've developed it independently and the technique is slightly different. Therefore I am posting it myself.

Fibonacci program that checks Lucas (10 bytes)

€¢Dā0šÅgÃQ

Try it online!

€¢Dā0šÅgÃQ -> Full program
€¢ -> Count the occurrences of each character in the string. Call this list C.
 Dā -> Duplicate and yield the range [1 ... len string].
 0š -> Prepend 0. [0 ... len string].
 Åg -> Nth Lucas number (for each).
 Ã -> Intersection with C.
 Q -> Check equality with C.

Lucas program that checks Fibonacci (8 bytes)

€¢DāÅfÃQ

Try it online!

€¢DāÅfÃQ -> Full program
€¢ -> Count the occurrences of each character in the string. Call this list C.
 Dā -> Duplicate and yield the range [1 ... len string].
 Åf -> Nth Fibonacci number (for each). We don't need the 0th this time!
 Ã -> Intersection with C.
 Q -> Check equality with C.

05AB1E, score: 19 17 (9x1 + 8x1)

-2 score thanks to @Emigna.

Lucas (10 9 bytes):

€¢Z>ÅGKg_

Try it online (with the Fibonacci program as input).
Verify all test cases.

Fibonacci (9 8 bytes):

€¢ZÅFKg_

Try it online (with the Lucas program as input).
Verify all test cases.

Outputs 1 for truthy and 0 for falsey results.

Explanation:

€¢ # Count each of the characters in the input
 # i.e. "Programming Puzzles" → [2,2,1,2,2,1,2,2,1,1,2,1,2,1,2,2,1,1,1]
 Z # Get the max, without popping the list
 # i.e. [2,2,1,2,2,1,2,2,1,1,2,1,2,1,2,2,1,1,1] → 2
 >ÅG # Calculate the Lucas numbers up to and including this max+1
 # (Note: the +1 is because `1ÅG` returns `` instead of `[1]`)
 # i.e. 2 → [2,1]
 ÅF # Calculate the Fibonacci numbers up to and including this max
 # i.e. 2 → [0,1,1,2]
 K # Remove all these Fibonacci numbers from the count list
 # i.e. [2,2,1,2,2,1,2,2,1,1,2,1,2,1,2,2,1,1,1] and [2,1] → 
 # i.e. [2,2,1,2,2,1,2,2,1,1,2,1,2,1,2,2,1,1,1] and [0,1,1,2] → 
 g_ # Check if the list is not empty
 # i.e. → 0

Jelly,  19  8×1+9×1=17

^code-page

Lucas Program:

ĠẈfƑJÆḞ$

Try it online! Or see all-tests.

Fibonacci Program:

ĠẈfƑJŻÆĿƊ

Try it online! Or see all-tests.

How?

Both work in very similar fashions -- ÆḞ gets the n^th Fibonacci number while ÆĿ gets the n^th lucas number. Ż adds a zero to the front of the list of n's to use with ÆĿ to cater for the fact that the 0^th Lucas number is 2, which we need to test for while 0 is the 0^th Fibonacci number, which we do not need to test for. Ɗ is a quick to chain the last three links together as a monad, while $ chains the last two links together as a monad...

Lucas Program:

ĠẈfƑJÆḞ$ - Link: list of characters, s
Ġ - group indices by value
 Ẉ - length of each
 $ - last two links as a monad (f(s))
 J - range of length of s
 ÆḞ - nth Fibonacci number (vectorises)
 Ƒ - is left argument is equal to the result of?:
 f - filter - remove items from left that are not in right
 - i.e. groupLengths without those Fibonacci numbers

Fibonacci Program:

ĠẈfƑJŻÆĿƊ - Link: list of characters, s
Ġ - group indices by value
 Ẉ - length of each
 Ɗ - last three links as a monad (f(s))
 J - range of length of s
 Ż - prepend a zero
 ÆĿ - nth Lucas number (vectorises)
 Ƒ - is left argument is equal to the result of?:
 f - filter - remove items from left that are not in right
 - i.e. groupLengths without those Lucas numbers

Java 8, score 1238 1137 (35x18 + 39x13)

Lucas:

c->c.chars().map(a->c.length()-c.replace(""+(char)a,"").length()).allMatch(a->a==m;)//",-..mmnrr

Try it online.

Fibonacci:

s->s.chars().map(e->s.length()-s.replace(""+(char)e,"").length()).allMatch(a->int l=(int)Math.sqrt(a=5*a*a+4);return(l*l==a)//--...===aaanl((((()))))

Try it online.

Explanation (base) Lucas:

s-> // Method with String parameter and boolean return-type
 s.chars() // Loop over the characters as integer-stream
 .map(c-> // Map each of them to:
 s.length()-s.replace(""+(char)c,"").length())
 // The occurrence-count of this character in the input
 .allMatch(n->n==c;) // or `c`

Explanation (base) Fibonacci:

s-> // Method with String parameter and boolean return-type
 s.chars() // Loop over the characters as integer-stream
 .map(c-> // Map each of them to:
 s.length()-s.replace(""+(char)c,"").length())
 // The occurrence-count of this character in the input
 .allMatch(n->(r=(int)Math.sqrt(n-=8))*r==n;)
 // and/or if `5*n*n-4` is a perfect square

A number $n$ is a Fibonacci number, if either or both of $5n^2+4$ or $5n^2-4$ is a perfect square ^(source)

Explanation modifications: