[Question]
  [
When studying [numerology](https://en.wikipedia.org/wiki/Numerology), you can say two words (strings consisting entirely of letters) are compatible if they produce the same number under the following operation (let's use the string `hello` as an example):
* Map each letter to a number according to the following, ignoring case:
```
1 2 3 4 5 6 7 8 9
a b c d e f g h i
j k l m n o p q r
s t u v w x y z
```
The number at the top of the column a letter is in is its mapped value (e.g. `a -> 1`, `x -> 6`)
`hello -> [8, 5, 3, 3, 6]`
* Take the sum of these numbers. `hello -> 25`
* Repeatedly take the [digital sum](https://en.wikipedia.org/wiki/Digit_sum) until it reaches a single digit (i.e. it's digital root). `hello -> 2+5 = 7`
For example, `hello` and `world` are not compatible (they yield `7` and `9` respectively), whereas `coding` and `sandbox` are (both `7`).
---
You are to write a program which will take two strings as input and output two distinct consistent values which indicate whether the strings are compatible or not
* The inputs will only consist of letters (`ABCDEFGHIJKLMNOPQRSTUVWXYZ` or `abcdefghijklmnopqrstuvwxyz`) in a consistent case
* You may choose the case of the inputs, so long as it is consistent across inputs and runs
* You may take input as a delimited string (e.g. space separated), so long as the delimiter is non-empty and consists of entirely non-letter characters of your chosen case (i.e. if you input in uppercase, the delimiter may contain lowercase letters, but not uppercase letters)
* Otherwise, you may input and output in [any convenient method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods)
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest code in bytes wins.
## Test cases
```
a, b -> out
"hello", "world" -> 0
"raahyjc", "mvj" -> 0
"mpqtjmjd", "bwkhrh" -> 0
"VZZLCZTH", "DOJEIV" -> 0
"coding", "sandbox" -> 1
"vhw", "wl" -> 1
"HMCZQZZRC", "SIQYOBXK" -> 1
"a", "j" -> 1
```
[These](https://tio.run/##y0rNyan8///opJy0R01rDs9IPLTVX9tY1TLf8uGOHk2XQ8tVDk/wceUyNAhSqDA0UHi4q0vv4e5uhUNbFQ7PcFSoAAkoPNzZqKAJJFuAJigcbld41LgdxOM6tOjQwoc7ZwO5//8bGhgAAA) [two](https://tio.run/##y0rNyan8///opJy0R01rDs9IPLTVX9tY1TLf8uGOHk2XQ8tVDk/wceUyNAhSqDA0UHi4q0vv4e5uhUNbFYBqFSpAAgoPdzYqaALJFqAJCofbFR41bgfxuA4tOrTw4c7ZQO7//4YGBgA) programs can generate more test cases
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
O’§%9E
```
[Try it online!](https://tio.run/##y0rNyan8/9//UcPMQ8tVLV3///8freTs7@Lp566ko6AU7Ojn4uQfoRQLAA "Jelly – Try It Online") [All Tests.](https://tio.run/##y0rNyan8/9//UcPMQ8tVLV3/H25/1LTm///oaCUPVx8ffyUdBaVw/yAfF6VYHa5opSBHR49IL2eQqG@YF0TMNyAwxMvXywUk6BTu7RHkAREPi4rycY4K8QCJu/h7uXqGQcSd/V08/dxBosGOfi5O/hFQ5R7hYMt8IFwPX@eowKioILBdwZ6Bkf5OEd5KsbEA "Jelly – Try It Online")
We take input in capital letters. The key insight here is to note (ref. [en.wikipedia.org/wiki/Digital\_root](https://en.wikipedia.org/wiki/Digital_root#Congruence_formula) that the digital root of \$n>0\$ is \$n\mod 9\$ except if \$n\$ is a multiple of 9, at which case it is 9. However, we only care if the digital roots are equal, so we can treat the digital root as \$n\mod 9\$ in all cases.
```
O’§%9E
O       # Character values A→65,...
 ’      # minus 1, A→64...
  §     # take the sum of each word
   %9   # modulo 9 (∑{A...} = ∑{1...})
     E  # are the two words' sums equal?
```
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~10~~ 9 bytes
```
=/9!+/'3+
```
[Try it online!](https://tio.run/##Lc3LDoIwEAXQvV@BswECBo0rbfyY0oKlD0YK4dGFv15LMXc1505y1QWV9@3zVT3ORZXeC39Njtz@@SZtmmUgGq0RCCxoNYecZGApFZtkwcwso5jPMEkjeaB6UcKKqLNzmrlJBOUom26OypB3/TvYSHte43q8imWf0PEQhrnBObsvjN2wYb2qvSiBAikhTOYn/wM "K (oK) – Try It Online")
Another port of [fireflame241's answer](https://codegolf.stackexchange.com/a/215456/58563).
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~11~~ 8 bytes
-7 bytes after looking at fireflame241's [answer](https://codegolf.stackexchange.com/a/215456/95792)  
-3 bytes thanks to [Dominic van Essen](https://codegolf.stackexchange.com/users/95126/dominic-van-essen)
```
Ëo%9ṁo←c
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f/h7nxVy4c7G/MftU1I/v//f3S0koerj4@/ko5SuH@Qj4tSrE60UlhUlI9zVIgHUNDF38vVMwws6uzv4unnDhQLdvRzcfKPAAt6@DpHBUZFBTmDxD0DI/2dIryVYmMB "Husk – Try It Online")
Needs the input a list of uppercase words.
```
Ëo%9ṁo←c
    ṁ     Map each word and sum the results
       c  Get integer value of character
     o←   And decrement
 ȯ%9      Take that modulo 9
Ë         Check if they're equal
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~32~~ 27 bytes
```
9∣(#-#2&@@FromDigits/@#)&
```
[Try it online!](https://tio.run/##Jc1JCsIwAIXhvaeQBoqCRXDnQim2SuuAI6IRF@mY1KbRGKwidu09vJkXqY1Zvu8tfooEDikSxEdl1Cu73/enAQzQ0U1zxBm1SUzEtW2Cpl4uOMnEARj9yARHvVj7KCuetaeGwzRlWquu5YyngfZqVcYRwo/El0pviTJ6voiEJoFELz9hjpVvIZxacONIt@fjobtV7rOAZLHUK8oCj90V33D@j6VqOjMLLiFcWRLX7nI/H@wm6kKSqnjtVf4A "Wolfram Language (Mathematica) – Try It Online")
Takes a list containing two strings.
Inspired by Neil's Charcoal solution: [`FromDigits`](https://reference.wolfram.com/language/ref/FromDigits.html) still recognizes `a`=10, `b`=11, etc., even if those digits are not present in the base (by default, it interprets its input base 10).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~12~~ 11 bytes
Takes input as lists of lists of characters.
-1 byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)!
```
ÇÌ9%>ΔO€S}Ë
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cPvhHktVu3NT/B81rQmuPdz9/390tFKyko6CUj6ISAERmSAiD0SkK8XqKEQrFYPYiXBRsKIkuJ4KpdhYAA "05AB1E – Try It Online")
**Commented:**
```
€Ç             # convert both words to codepoint lists  a->97, b->98, ...
  Ì            # add 2 to each number                   a->99, b->100, ...
   9%          # modulo 9                               a->0, b->1, ...
     >         # increment                              a->1, b->2, ...
      Δ   }    # execute until the reult doesn't change:
       O       #   sum each list
        €S     #   split the results into lists of digits
           Ë   # are both lists equal?
```
---
A port of [fireflame's excellent Jelly answer](https://codegolf.stackexchange.com/a/215456/64121) comes in at 6 bytes as well (provided by [Kevin](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)):
```
Ç<O9%Ë
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cLuNv6Xq4e7//6OjlZyVdJT8gdgFiD2B2A@I3ZVidaKVgoEsR6gISNYJqjJCKTYWAA "05AB1E – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~31~~ 30 bytes
```
+T`_l`dl
.
$*
1{9}|(1*)¶\1
^$
```
[Try it online!](https://tio.run/##BcFRCoIwGADg9/8cBmYj8LHXLNAyxBSpEbXppLmmqyWuqK7VAbrY@j5d901H7cjNCIKcxETaSU5OkjAJU3A88F@zz9v1vfHve/ABjo61vJZSIaO0ZKAp5U9RoXYQ0F5vvWgFQ6W5cM2hwDgOcB6iRbJaRgVUijXdGd1px0r1gIEbZCSEmwCnGG8DlEXpPpnv1n8 "Retina 0.8.2 – Try It Online") Takes input on separate lines, but link includes header which lowercases the test suite and splits on `,` for convenience. Explanation:
```
+T`_l`dl
```
Retina 0.8.2 doesn't have `Y`, but fortunately we can just repeatedly transliterate 9 digits at a time, shuffling the letters back 9 places in the alphabet.
```
.
$*
```
Convert all of the digits to unary.
```
1{9}|(1*)¶\1
```
Take the difference modulo 9.
```
^$
```
Check that the result is zero.
[Answer]
# [J](http://jsoftware.com/), 15 bytes
Based on fireflame241's Jelly answer.
```
=&(9|1#.3+3&u:)
```
[Try it online!](https://tio.run/##Tc69DoIwHATwnaf4RxMKEYmGyRomEycn3wBasJSWSkE@Gt@9OohluOV@ueS43cSohBQDgggOgL/Zx3C536429YPT@7iNk13iv3BoQ88rCFOAWCGEQhBE@FyGgEalBUU/01nGZk6cyoEvJp9tzyWnDvOxZpotPhgjiOmZc6p4UQ2LE0Wr5uG0yxqaq@k/Z@PqlFhqJolpjdGrT13VziqfauTZDw "J – Try It Online")
### Original approach: [J](http://jsoftware.com/), 29 bytes
*-2 after reading ovs' answer: `(x-97)|9 = (x+2)|9`*
```
=&(1(,.&.":@#.^:_)1+9|2+3&u:)
```
[Try it online!](https://tio.run/##Tc5LDoIwGATgPaf4gwmFgI3oyhoSExNXrjyABlqwlELlIY/Gu6MLERazmS@TjBhNjBIICCDwYAPkmzWG0/VyHgPL9m0PW9gkxxW@kbvju/v31t1ZL@KMjmHElCtAPJZSIbA9ckgcQJ2qJEM/q8KQD4LOmrdisvxZNiIXbMaoy3jFJ2@1llQ3fHamRJy2k1PF0uIxax0WLFL9f867xSk51TynutS6Wnyq03JQUZ8hY/wA "J – Try It Online")
```
=&(1(,.&.":@#.^:_)1+9|2+3&u:)
f&(            g            ) call g on both arguments, then call f
                        3&u:  convert string to code points
                      2+      'a' -> 99, 'b' -> 100 …
                    9|        mod 9
                  1+          plus 1
   1(  f     )^:_             execute 1 f (list of digits)
                                until the result does not change
           @#.                sum digits and
       &.":                   convert the sum to a string and
     ,.                       itemize the characters
       &.":                   convert the characters back to digits
=&                            are the digital roots equal?
```
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=sum -p`, 61 bytes
```
y/a-z/1-91-91-8/;s|\d+|sum$&=~/./g|ge while/\d\d/;$_=/(.) \1/
```
[Try it online!](https://tio.run/##K0gtyjH9/79SP1G3St9Q1xKMLPSti2tiUrRriktzVdRs6/T19NNr0lMVyjMyc1L1Y1JiUvStVeJt9TX0NBViDPX//0/OT8nMS1coTsxLScqv@JdfUJKZn1f8X9fXVM/A0ABI@2QWl1hZhZZk5tgCzfyvWwAA "Perl 5 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~61~~ \$\cdots\$ ~~53~~ 51 bytes
Saved a byte thanks to [ovs](https://codegolf.stackexchange.com/users/64121/ovs)!!!  
Saved 2 bytes thanks to [Dingus](https://codegolf.stackexchange.com/users/92901/dingus)!!!
```
lambda t:len({sum(ord(c)+3for c in w)%9for w in t})
```
[Try it online!](https://tio.run/##NZBNbsMgEIX3PsUIKQoodFFn00RyN2lPUXdhAyl2sLEx9Q9Vz@56QsoIpPcNvIemW7y2bbpes3w1RVPKAvzZqJb@DN8NtU5SwQ7Hq3UgoGphYrsTigmF/2WrV4MfIANKiVbGWMLJZJ2RhHGgxBWFXmpBOJBmrCNrut7XTS0RltNNOx35GIIRwWvk0taqGiMXVlbtF9KhaGVp58d1PSGbTJS6EaEPwd2zhqpfbDnfYqtAtIWzRM2dEl5J/G/KYz3HYonQStyUwx7J5/c0n09v@fxywdcPfdn2kbAEJ@C5whmEqqP3GXD4d2fnBLaFTlfq2V10rmo97MluQLvthKfX/c5zcBwewR8uy9Tn@gc "Python 2 – Try It Online")
Inputs a tuple of two strings in lowercase and returns \$1\$ if they are compatible or \$2\$ otherwise.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~203~~ 145 bytes
-58 bytes thanks to @caird coinheringaahing
```
def f(a):
 x,y=[sum((ord(i)-97)%9+1for i in z)for z in a]
 g=lambda t:sum(int(i)for i in str(t))
 while x>9:x=g(x)
 while y>9:y=g(y)
 return x==y
```
[Try it online!](https://tio.run/##PdBNa8MwDAbge36FMAxslo2VHUYC2WHdoN0HpesoW0IOTp3Uzpy4c90m7p/P7BxyEEgPkg7vwRqu2vthYGUFFaYkDqAPbZIdTw3GSjMsyE30QK6i61mlNAgQLVyIby@@pXkA@0TSpmAUTOyvRGvc0bR8NBobQgLouJAl9I9R3Cd73E9inVgn1okuzUm30CeJHaYPGUa8lFKhEHVKS4ZIiJGmlNt6h0JAzbkeqTn8mbqpmbei@@Waj7xN0/d5@rXw/Lx6fVluR94pJtq9xyNtWaH6Uc@889TJcVp8zNN1mn7OvW2W65/V0/cbIrkLSUACIrvLb6XqSo1JKLLZNARw0GMMrioXBiHDPw "Python 3 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 31 bytes
```
Y`l_`1-9
{`\d
*
)`_+
$.&
(.) \1
```
[Try it online!](https://tio.run/##BcFBDoMgEADA@75iD22jbWrisS/oG5qYCALpgiCKBJQ@ns4EFfXC@3pt3qx@mB1Z/3zBjw0S7tCy8QGX7gZN1@LQ10rKWo/ZByshcE6nEeiSAbdu0TgjccozBYJUihUlEkpvlE4gvNTLF3e@yMkfkChjtkBOlK2UIHDX2@mnY/4D "Retina – Try It Online")
A direct implementation of the given algorithm. Outputs 0/1 indicating incompatible/compatible taking the argument in lower case.
### Explanation
```
Y`l_`1-9
```
Transliterate cyclically the sets `a-z_` to `1-9`. Here, the underscore is not a real character but a dummy, not that it particularly matters. To cyclically transliterate we extend both sequences infinitely, then each time we encounter a character in the input in the first set we output the corresponding character in the same location in the second set. This behaviour requires the dummy character to map to 9 after `z` is mapped to `8`, as otherwise the second occurrence of each character will be off by one, the third occurrence off by two, etc.
```
{`\d
*
)`_+
```
Here we loop until a fixed point over these two stages, indicated by `{` and `)`. The first stage converts each individual digit to a corresponding number of `_` characters, while the second converts each chain of `_` characters to a number equal to the length of the chain. This reaches a fixed point naturally only at single digit numbers.
```
(.) \1
```
Count if the remaining digits are the same, so the total is zero if they are not the same and one if they are.
[Answer]
# Scala, 27 bytes
Uses fireflame241's [approach](https://codegolf.stackexchange.com/a/215456/95792).
```
_.map(_.map(3+).sum%9).size
```
[Try it online!](https://scastie.scala-lang.org/iMg86eC9T3ylIxvbpvVvSA)
Accepts input as a `Set` of lowercase strings. Returns 2 if inputs are not compatible, 1 if they are. I'll probably go to hell for my abuse of the rules here.
[Answer]
# [Haskell](https://www.haskell.org/), 44 bytes
```
a#b=o a-o b
o s=sum[fromEnum c-1|c<-s]`mod`9
```
[Try it online!](https://tio.run/##TZDRTsIwFIbv9xR/qhcQGFHvTJgXDhJQCEGU6JZFug3sxrrOtmOY8O5zRV28OWm/7@85OWVU7bdZVie8EFJjRDUduIxK6z@YJUoPVkWW6JpehI4AtQVCS0A5quT@Tgo@zkuOyL4@RUNbBRsu4s1tzWmSwwGnxfwdRalXWs5yWPChmKhwRK8HAvuuKc3pzDpoJsBxcIUuThbQpIY2Ilbme7XY4QaXph86pmjxUhRb2YVvgiCs2USQPkglZBYT9H@wpJR9pZER/JC2mBefOuVpbHhY7Zlk5NesPW/mes8TY0aLh/F03T6KRJzkH0YomsehOLbmwKrz6Oyvy2TuekvPe3INXk2Xb4v718c2Tg1NibkEZ5RtNXzaD4Pmx44Wgvob "Haskell – Try It Online")
* Infix function expecting two UPPERCASE strings: returns `0` if compatible or any value if not.
* Inspired by @fireflame241 insights: <https://codegolf.stackexchange.com/a/215456/84844>
[Answer]
# [Ruby 2.7](https://www.ruby-lang.org/), ~~89~~ \$\cdots\$ ~~55~~ ~~52~~ 41 bytes
*Saved a whooping 34 bytes, thanks to [fireflame241](https://codegolf.stackexchange.com/a/215456/83605)'s answer!*  
*Saved extra 11 bytes, thanks to [Dingus](https://codegolf.stackexchange.com/users/92901/dingus)!*
```
->w{!w.map{|s|s.bytes.sum{_1-6}%9}.uniq!}
```
[Try it online!](https://tio.run/##Zc47coMwEIDh3qdY8GRogEmazKSIL@JxISQ5QuiFHsgIODsxTuIitPt/s7s2NON6/VyrU5yyWEtkptnNrm5GT13tgpxmPOPqfXn5WOqg2j5b1iMgIaBVJngHyFLwqKPqPgCio8LI0RJ08PcMAxKB/iAXkTGUZIeDgev5nDMqhM5LyKO2guSXCxyhOsHbb5am91xysokmdsyyHRlSEjh5thGiOW2HHbEIsZHjTciB7zLWpFVfW3VIkUbfnuL17waLjx/FrjCJU5@SfSx3bT/q5tb9VwUqSih48Ryv3w "Ruby – Try It Online")
This outputs with the boolean values swapped!  
In Ruby 2.7, we can use `_1` in place of `|c|c` to save 2 bytes.
[Answer]
# Java 8, 50 bytes
```
a->b->a.map(v->v-1).sum()%9==b.map(v->v-1).sum()%9
```
Inputs in uppercase as character-Streams.
Port of [*@fireflame241*'s Jelly answer](https://codegolf.stackexchange.com/a/215456/52210), so make sure to upvote him!
[Try it online.](https://tio.run/##nZFbT4NAEIXf@ys2m5hCKJv46KUkXKpAoVhoesH6MFCqVG4pC0lj@tsRkFgxPvl2cr6Z3TMzByiBP@zeKz@CPEcmhMnHAKGcAg19dKgpKWgYkX2R@DRME/LQifsLy@kxgJhoCXVaNfp3n5SmUQCJIKA9GlfACx4vAIkhY0peKPlrluRFzLBXN@Ox95dd3Q3q8FnhRXX4boYyDXcorudi6l/C5PX5BQHbzIgQDXLKYHViGBYeIbyybEPB7N0PZouiutHlhppLvc/Mp/lCN3WlgdJqqtpqny9d15DdhdpwxdIn2rLPZUvRZo8NdcSZIlnrX@3qqg1l9G3VlN2569ptJkebbyxpPe2XiA3qwp4Hl2u2m2hLvjaBYNQJr1uIc8ppEJO0oCSrAY0SZoiHHHB4W7@5xZjzGnmLMLcnkGXRiQHiv8ExZ1i2M7xvowtwrj4B)
**Explanation:**
```
a->b->                    // Method with two IntStream parameters & boolean return-type
  a.map(v->               //  Map over the characters of the first input:
           v-1)           //   Decrease each value by 1
   .sum()                 //  Then sum them all together
         %9               //  And take modulo-9 on that
  ==b.map(v->v-1).sum()%9 //  Do the same for the second input,
                          //  and check if they're equal to one another
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `a`, 7 bytes
```
C‹v∑9%≈
```
Another port of [fireflame241's Jelly solution](https://codegolf.stackexchange.com/a/215456/80050). Takes input as newline-separated strings. [Try it Online!](http://lyxal.pythonanywhere.com?flags=a&code=C%E2%80%B9v%E2%88%919%25%E2%89%88&inputs=CODING%0ASANDBOX&header=&footer=)
```
C‹v∑9%≈
C          Convert the input from a list of strings to a list of lists of their codepoints
 ‹         Decrement every number
  v∑       Sum each sublist
    9%     Mod 9 both sums
      ≈    Check if both sums are equal
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~13~~ 10 bytes
```
¬﹪⁻⍘Ｓχ⍘Ｓχ⁹
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMvv0TDNz@lNCdfwzczr7RYwymxODW4BCiXruGZV1BaAmVr6igYGgAJvNJA0lJTU9P6///k/BSgsEJxYl5KUn7Ff92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Takes input in lower case. Outputs a Charcoal boolean, i.e. `-` for compatible, nothing if not. Edit: Saved 3 bytes via inspiration from @att's Mathematica solution, which only seems fair. Explanation:
```
    Ｓ       First input string
   ⍘ χ      Interpret as "base 10"
  ⁻         Subtract
      ⍘Ｓχ   Second input string as "base 10"
 ﹪       ⁹  Reduced modulo 9
¬           Equals zero?
            Implicitly print
```
Like Mathematica, Charcoal interprets interprets `a=10`, `b=11` ... `z=35` even in bases which don't actually go up that high. Obviously it also interprets `aa=110` which has a digital root of 2 etc.
[Answer]
# JavaScript (ES6), ~~80 79 65~~ 63 bytes
*Saved 14 bytes by using [@fireflame241's insight](https://codegolf.stackexchange.com/a/215456/58563)*  
*Saved 2 more bytes thanks to @Neil*
Expects `(a)(b)`. Returns a Boolean value.
```
a=>b=>(g=s=>[...s].map(c=>t+=parseInt(c,36),t=0)&&t%9)(a)==g(b)
```
[Try it online!](https://tio.run/##hc9dS8MwFIDhe3/FKDgSNrOJIHiRXliF1Q/GVIZGvDhNumYxTWoTWvfrq5EKUjY81897OEdBA47X28qfGCvybkM7oHFGY1RQR@NXQoh7IyVUiNPYT2gFtctT4xGfnp3jqadzPB774wuMAFNaoAx33BpndU60LdAGRTLX2kYYRa2ttYgwHvUzm43mRwNcA8id4oGXjfoHl9WHV6USQWftu6xlH@zDa8buEva0CPhqeXOdrg9hPEy5FVtThNCBEZn9/L3rOz0d4ka2P8/qP8cfxIv7hK0Ye0hC8piuXpaXz7ch3IchIDVc22/uvgA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 66 bytes
```
SameQ@@(Tr@*IntegerDigits~FixedPoint~Tr@#&/@LetterNumber@#~Mod~9)&
```
[Try it online!](https://tio.run/##Hc1fa8IwFIfhryIRxA3Bay@EsLph/TPtFNkydpE2hyS1abY0s47SfvUsyeV5zgs/Ra0ARa0sqONLd6IKMoynZ4Mf09oCB7OSXNpmeJF3YEctazv453gyxzuwFszrr8rBw7DXbFg8TNzR@Abzz0RQQwtfNHM8/vL9qOuQgKrSaDZCrTYVQ/2sQ4ZS8VcWAdWtjKS@f2ypShYsb6/CiMgXQnYJOa8Drw6b5/QSudBM1jxgQ2uW63vUm2jjThWv9T4hGSFvSbBTmn0cnt63qO@d@wc "Wolfram Language (Mathematica) – Try It Online")
thanks @att
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 67 bytes
Takes two lowercase strings and returns `0` if they match, non-zero otherwise. Uses the method from @fireflame241's answer.
```
i;g(char*s){for(i=0;*s;i+=(2+*s++)%9+1);s=i%9;}f(s,t){s=g(s)-g(t);}
```
[Try it online!](https://tio.run/##VY/BcoMgEIbvPsU2HTOgpjW9Zah5kl4QVNagJEA1MZNXr0XTSw87fPvP/v8uYtcIMc/IGiIUt4mj99pYgkXOEscwLchHmrg0pfEh3VPmCowP7FETl3l6d0VDHN01xFP2mF@xF/pbVvDpvETzpo7RP0ljuWgR9h46jj0ZDEoK9whgWQ2JyyDxLLTLBLIo0HILAyd4X5NN3DlYS371mwy2YX7rQyE95gxqW1XhmuwJntJgBzjbELZ4HZBY0ve/F4pjiFlxzQpRzWr2C/gAL88/ZoCURY9ZVVobGI3VEvLIcq5urYBuaEPXnS@@7VoJ5XhSVgVlmCYtJq9AmrbCISjCSOwbcLyXpbnCPhrUCKMOoDoxXabJCnB4uZnyegoihxb2P6LWvHHzbvwF "C (gcc) – Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 14 bytes
```
S%{:i:(:+9%}/=
```
[Try it online!](https://tio.run/##BcG7CsIwFADQ/X7FXQKCg7MBhzyKN2keJi1Jm604KQg6l357POf53j79F9jeJ7bzFz/x85Udl1v/Hgw6Dc5FrDE7DVkIWq1CXyz4R5qttxplHSkTlNacajOhjnYwBVTUJtxxEkHLuEChitUBedVSa1nhZNIa5TKCQPsH "CJam – Try It Online")
First attempt at CJam. Using [Fireflame241's](https://codegolf.stackexchange.com/a/215456/91386) solution.
```
S%  # Split on spaces
{
 :i # Convert each to int
 :( # Decrement each
 :+ # Sum list
 9% # Modulo 9
}/  # For each word (push to stack)
=   # Are equal
```
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 18 bytes
```
WDm{{**-.}ms9.%}sm
```
[Try it online!](https://tio.run/##BcG7DoIwFADQ/X7FXVxIZHcVTMBHCGpQr1OhxFpbKq1QDeHb6zn1YFXr@qENqpuIwiXV0xRFy3jWbhUvZqfDrO9lEK1SBr2xioNlTPxkg3qUoN/9R2rJsfYvYQVURPuEzhmmxXaTV9AY/uwe6FjHa/OFUXj0CrJDQiXRMcFTXt6K9XUHDOUf "Burlesque – Try It Online")
```
WD     # Split into words
m{     # Map over words
  {**  # To int
   -.  # Decrement
  }ms  # Map sum
  9.%  # Modulo 9
}
sm     # Are the same
```
Using [Fireflame241's](https://codegolf.stackexchange.com/a/215456/91386) solution.
# [Burlesque](https://github.com/FMNSSun/Burlesque), 36 bytes
```
WDm{{**2.-9.%+.}ms{XX++}{ln1!=}w!}sm
```
[Try it online!](https://tio.run/##BcHNDoIgAADgO0@Bhy663OrWoUvapv3MWc2MTiguIpCElBrj2en7mlHxTg9j53lvEfLXVFgbhst4vopnUeyEtnUdRc7yfhGsnQmcFt6Je@lpx7mERipOgMKY/lgLxcSAeA8fJhiBjXlRRUGF0CFBlwymxW6bV6CV5Nk/oMY9aeQXTNRAw0F2TFCJ0CmB57y8FZt6DzBkfw "Burlesque – Try It Online")
Full solution. Saving a byte using `2.-` rather than `65.-` having looked at some other answers. Otherwise much the same as other answers.
```
wd          # Split into words
m{          # For each word
  {
   **       # ord(a)
   2.+9.%+. # ((x+2)%9)+1
  }ms       # Map each letter then sum result
  {
   XX       # XXplode into digits
   ++       # Sum digits
  }
  {ln       # Number of digits
   1!=      # Not equal 1
  }w!       # While
 }
 sm        # Are all the same
```
[Answer]
# TI-Basic, 92 bytes
```
Prompt Str1,Str2
"BCDEFGHIJKLMNOPQRSTUVWXYZ→Str3
"fPart(1/9sum(1+seq(9fPart(inString(Str3,sub(Ans,I,1))/9),I,1,length(Ans→u
Str1
u→S
Str2
u=S
```
Output is stored in `Ans` and displayed. Outputs `0` for incompatible numbers and `1` for compatible ones.
]