Rose (The Relationship Evaluation Algorithm)

Being single is hard. At least, it was for me. Some people are jerks. Some people are your future relationships. Hopefully, one person is your future spouse. How can you tell the difference?

For me, as with many people, this was a hard problem. It doesn’t help that as soon as you find someone cute, my mind kinda went blank. I’ve seen it in myself, and I’ve seen in my friends. They have all these standards, and then change them as soon as they meet someone, and then getting hurt.

Well, after one particularly bad breakup, I had had enough. Surely there was a way to figure out if someone wasn’t right for you before dating them and getting hurt, instead of after.

And that was when Rose was born.

The Concept

The Algorithm

The idea is you have a list of attributes that are relevant to relationships. Everything you can possibly think of, from deep stuff like, “You feel like you can trust them”, to [hopefully] obvious stuff like, “You like them”, to frivilous stuff like, “They’re tall”. All the attributes have to be phrased in that way.

Then, you go through all the questions twice. Once, when you’re unbiased, for instance when you’re single, and for each question, ask yourself, “how important is it to me that… [attribute]?”. For example, “How important is it to me that I feel like I can trust them?”. And you answer that on a scale of -1 to 1, -1 being “Absolutely not, I don’t want that”, and 1 being “absolutely, I need that”. You can also set attributes as dealbreakers, but be very sparing about that. A lot of things that you think are dealbreakers may not be. These are your preferences.

Then you set thresholds for each kind of relationship that reflect how “picky” you are. 10% being “I’ll enter a relationship with them as long as they breathe”, and 90% being “they have to be almost perfect”. You set thresholds for being friends, dating, and marriage. And maybe engagement, depending on how you think of it.

Then, later on, when you’re thinking about entering, exiting, or changing a relationship with someone, you can think of that person, and for each question, ask yourself “Do I feel like… [attribute]?”. For example, “Do I feel like I can trust them?”. You answer that question on a scale of 0 to 1, 0 being “no, not at all”, and 1 being “yes, entirely”. These are your evaluations

Then, for each question, you multiply your preferences * your evaluations, and take the weighted average of all the attributes, and compare it against the thresholds you set. If they scored a 70%, and your threshold for dating is 60%, then it makes sense to date them.

Advantages

The advantages of using this algorithm, is that you can always add more attributes. The more attributes you have, the more accurate the answer will become. When creating the boilerplate list of attributes for the 3rd Rose incarnation, I did research. I kept a running list on my phone, and whenever I thought of something, I’d write it down. I observed happy couples I knew, and watched for attributes they did or didn’t do. I asked my friends, my roommates, my parents, I interviewed couples.

The other advantage, is that you can take into account emotions with it. I know for me, at least, if somebody asks me if I feel a certain way about something/someone, I’m like, I have no idea. That’s a big question. But if you break it down, and ask “How do you feel about them doing this?”, and ask a bunch of smaller questions, those I can ask with more certainty.

Of course, it’s not perfect. It’s not the end-all be-all of deciding to date someone. It doesn’t elliminate all hurt; you still have to date and get your heart broken to find out the things you do and don’t prefer. Tuning your preferences is the hardest part about it.

But I think it’s very helpful. I can think of several couples I know who are divorced, or who have very unhealthy relationships, because they were wearing the “rose-colored glasses” when they were dating, only to take them off once they were married, only to find out afterwards that they weren’t thinking clearly the entire time. Rose is aimed at helping you take off the rose-colored glasses, and evaluate someone objectively, so you can avoid that situation. At the very least, it can help you think about important things and have important discussions with your significant other before you rush into something. Or it could do the opposite, it could help you realize you’re not overthinking, and it does make sense, even though it might not feel like it.

The Implementation

Command Line

It started off as a command line Python program. I had a cool idea, I wanted to actually be able to use it and trust it wouldn’t break, and I didn’t trust my ability to write UI’s at the time. So command line it is.

Here’s the original script, if you’re interested. It’s pretty short, and wasn’t perfect, but it worked.

import json
from os.path import dirname, join; DIR  = dirname(__file__)

# Specify these 3
MAX_NUM = 100
TOLERANCES = {
    "Leave Be": -MAX_NUM,
    "Date":  0,
    "Marry": MAX_NUM * .9
}
preferencesFile = join(DIR, "girlfriendPreferences.json")

with open(preferencesFile, 'r') as f:
    traits = json.load(f)

def getInput(trait):
    _input = input(trait.capitalize() + ': ').strip().lower()
    if _input in 'y ya yeah yes si true definitely accurate'.split():
        return 1
    elif _input in ('n', 'no', 'not', 'nien', 'false', 'nope', 'not really'):
        return 0
    elif _input in ('none', 'na', 'n/a', 'not applicable'):
        return None
    elif _input in ('sure', 'kinda', 'i guess', 'kind of'):
        return 0.7
    else:
        try:
            mod = float(_input)
            if mod >= -1 and mod <= 1:
                return mod
            else:
                raise TypeError()
        except:
            print("Invalid input")
            return getInput(trait)

def applyTolerance(amt):
    for action, tolerance in sorted(TOLERANCES.items()):
        if amt >= tolerance:
            return action
    raise UserWarning("You've somehow scored less than is possible.")

girl = net = count = 0
for trait, weight in traits.items():
    modifier = getInput(trait)
    if modifier is None:
        continue
    else:
        girl  += modifier * weight
        net   += weight
        count += 1

if not count:
    print('I think you need to learn more about this girl.')

print(f'\nOut of the {count} traits evaluated, this girl scored {girl / count} out of {net / count}. She is good to {applyTolerance(girl / count).lower()}.')

And here’s an updated script I wrote a couple months later, after my best friend was trying to deciding whether to get engaged to her then boyfriend. After going through it with her, I actually helped her convince herself that she wasn’t overthinking things (spoiler alert: they’re now married): Rose 2.0

PyQt5

Later on, after talking about it to my dad & cousin, they thought it was a fantastic idea, and encouraged me to work on it some more. I had my parents take it, which was fun. I honestly don’t remember the outcome, but I remember my mom complaining that a “-10 to 10 scale is too hard to understand”. At that point, I had worked on a couple other projects using Qt, so I wrote a user interface that would let people actually use my program, instead of needing to know how to use the command line and such.

While a good idea, and the program is actually relatively useable out of the box, if you know how to clone a repo and run a python program, it’s still not “deployable”. Python really isn’t great for making programs that other people can use.

The code for that is in this repo: Rose 3.0

I actually did end up using it while dating an equally-nerdy girl, who actually suggested we use it on each other for a date. While not really how the program is intended to be used, you’re supposed to fill out your preferences before you meet someone, so you can be objective, it was still a lot of fun, and broke the ice on a lot of deep questions.

Spreadsheet

Later on, I learned linear algebra, statistics, and spreadsheets. I’m not a huge fan of spreadsheets, I feel like generally programming is easier, and scales much better, but they are super useful for small stuff like this. I put all the questions in a spreadsheet, and copied some cells from the spreadsheet we used in my statistics class, and recreated it in Google Sheets (Excel costs money, and I hate Microsoft). I then realized, the way I was calculating the answer, could be improved. If you think of your preferences as a hypothetical person, and think of your optimal hypothetical person and the actual person you’re evaluating as mathmatical vectors, in an N-dimentional space of all people, the problem becomes: is this person you're evaluating within a certain distance away from your optimal person, in this space?. Which can easily be calculated using linear algebra.

Except then, I also realized you can ask the question using statistics, and that way you can get a specific P-value, and your “pickiness” value just becomes the threshold of the P-value.

But then you could also take into account your uncertainties for each answer you provide, and incorperate that to get a specific uncertainty value of the average…

I then went down a rabbit hole of linear algebra, statistics, and spreadsheets for about an hour and a half, utill I finally gave up and just asked the girl sitting next to me the entire time if she would like to start dating. She said yes, and a few months later, she said yes again. We’re now married.

The Future

Eventually, I want to rewrite it again as a website, now that I know React. That way it’s actually accessible to other people. It’s been somewhat less relevant, now that I’m married, but I still want to finish it eventually.

It also can be generalized to make all sorts of decisions. I used a similar concept when my wife was trying to decide whether to go to vet school or not. It’s sort of like a mathmatically accurate pro-con list.