[Question]
  [
# Context
If `a0` and `b0` are two decimal numbers, with `a` and `b` representing the decimal expansion of all digits but the least significant one, then we know that
$$\frac{a0}{b0} = \frac{a{\not\mathrel0}}{b{\not\mathrel0}}= \frac{a}{b}$$
# Phony fraction
A *phony fraction* is a fraction where the numerator and denominator share a digit (other than a 0 in the units place) and, when that digit is erased from both numerator and denominator, the simplified fraction happens to be equal to the original one.
## Example
\$16/64\$ is a *phony fraction* because if we remove the \$6\$, we get \$16/64 = 1{\not\mathrel6}/{\not\mathrel6}4 = 1/4\$, even though the intermediate step of removing both sixes is wrong.
# Task
Given a fraction, determine if it is *phony* or not.
## Note
Notice that `10/20` is not a *phony fraction*. Even though `10/20 = 1/2`, the simplification here was mathematically sound, you divided numerator and denominator by `10`, which amounts to "crossing out a 0 on the num. and the den.".
On the other hand, `102/204 = 12/24` is a phony fraction, because supposedly we can't cross out the 0s.
Because of this, when the input fraction is such that crossing out 0 gives an equivalent fraction to the original, the behaviour is unspecified.
# Input
The fraction we care about, with positive numerator and denominator, in any sensible format. Some examples of sensible formats include:
* a list `[num, den]` or `[den, num]`
* a string of the form `"num/den"`
* the exact fraction, if your language supports it
* two different arguments to your function
Assume both are greater than 9. You can also assume the denominator is strictly larger than the numerator.
# Output
A Truthy value if the fraction is *phony* and a Falsy value if it is not.
# Test cases
(Please keep an eye out for the comments, as some people have really nice test case suggestions! I'll edit them in, but sometimes I don't do it immediately.)
## Truthy
```
69/690 = 9/90
99/396 = 9/36
394/985 = 34/85
176/275 = 16/25
85/850 = 5/50
59/295 = 5/25
76/760 = 6/60
253/550 = 23/50
52/520 = 2/20
796/995 = 76/95
199/796 = 19/76
88/583 = 8/53
306/765 = 30/75
193/965 = 13/65
62/620 = 2/20
363/561 = 33/51
396/891 = 36/81
275/770 = 25/70
591/985 = 51/85
165/264 = 15/24
176/671 = 16/61
385/781 = 35/71
88/484 = 8/44
298/596 = 28/56
737/938 = 77/98
495/594 = 45/54
693/990 = 63/90
363/462 = 33/42
197/985 = 17/85
462/660 = 42/60
154/451 = 14/41
176/374 = 16/34
297/990 = 27/90
187/682 = 17/62
195/975 = 15/75
176/473 = 16/43
77/671 = 7/61
1130/4181 = 130/481
```
## Falsy
```
478/674
333/531
309/461
162/882
122/763
536/616
132/570
397/509
579/689
809/912
160/387
190/388
117/980
245/246
54/991
749/892
70/311
344/735
584/790
123/809
227/913
107/295
225/325
345/614
506/994
161/323
530/994
589/863
171/480
74/89
251/732
55/80
439/864
278/293
514/838
47/771
378/627
561/671
43/946
1025/1312
```
You can check [this reference implementation](https://tio.run/##bVPBjpswEL37K6ac7MTdgnKIgsoe@wPdWxRFbBiKo2CQAWVXUb49nTGGZNNKJLZnnh9v3gztZ181dnW7la6pweW2oMXUbeN66KqhLE@ooUMstE8a2ws@ydVaCVFgCabbt8TwKTtLwEKlAsrGgdFwqHJaLaAdanR5jwThNJhyzGUZRHHEETg0tjd2wIcs3ewKnzxCRtsXYwv8kJxTHLV43hMz5UgUUW9Ts1vSYpZJupsRBdoJUWzTIyGK7XFG0Lti@JZNXAuPzqaLCwp5AeCwH5yFNzeQGwGsJ5gAPHXIwAD7ldNZQ0yPEGyOwY5EbHdCsDUsmoojO/@gTGKdxHHMvnSstOudJIAaXWQ9M5TCy2RGkyMBTiAuxnfhX3Vc/VOLRpN9yJcXJL7kbYu2kJLfpJlVy4ktkCmlvlRUepUla5yigZn5Ds1AvpeKLU2o@NZxH8rorUKHkNPvckIrA1xdZ46z6SvgQuHVW/DKnkUqEKiJKfrd1DhdSikfBnZm9HaP5YCvB@SzPUo9iN@mq/WOLJmEXgh5/XEh2JWqvYS7FAmXr9FdyyJarOK7xEeFtrHfH1R6W4gvFjn9v/vduTInhDHzE1ZrEjGGcjbvnduUa48NX6FM9GazUfrpLGAqlqC1sZJvEarOP8atENOg7On5Mhxh8vQ8VMRG3bRNf5@V/zgT8TyNypfUZ1bKZd1ufwE) that I used to generate some *phony fractions* by brute-force.
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!
  
[Answer]
# [J](http://jsoftware.com/), 22 bytes
```
%&".e.=/#&,%/&(1".\.])
```
[Try it online!](https://tio.run/##ZVRNbxQxDL33V0SLukOldjqOkziu1AMgcQH1wBkOVdkKECoSEvz9JTt27DBbaVXpTWy/Dyc/jrt5eg73d2EK12EJd@13M4d3nz6@P17ud/Nhvr99tb@@vN2/ht38ef5ydby6ODx9@xWmwlN4Pv1bJkVYEOTSEeS0Qlxzh4DKCkUyqH08ITVbpyydItsZraJiZ2LGFcpDWRQkGkIsdeydQGmS06xV6ioa8aXPG@pkHjtUZF7xeViUVAH3QFpVNuikfe1Og2I4c6rIqVjS1rxC3l7dowobOalaXWRV6JoJSQZi7VDirKessHTRfCYxNfVmDW3Jp@6NBwZZliFl2OpBGqjSdiJUgUodJgpVprPFSmQpErlb/RTgIsegGRYe3s7hw@Hv95f@/ab92eFEVRsYPUQNGD2BhdUQ16Xq68A4Rt0oo5dR0wRLBVBX2DcD1ZDcxvRC0rtXDapKgsEnFlGKzT6zrUMWOkDPzm9W0sVLxkujY99hSqxrbQNJm4Nbk6SO0GLKVaEh3yieVlcYo7ICcwsW2j4KMQpRjNknZvXUIstLfwP8HhXQwiGMZXsqV5XokQGB3i1/YpL64A8TqGhzJusLZ0UJe2tffF22yM4JtPdwR0lfDve4L2mzrC9uVn2nzV93/M3vl8c/P7/adJHa8g3/fb44/gM "J – Try It Online")
quick explanation for now:
1. take the input as strings
2. `%/&(1".\.])` creates a function table `%/` whose axes are the integer `".` lists formed by the 1-outfixes `\.` (remove 1 digit at a time) of both args, and whose cells are the quotients of those numbers
3. `=/` forms a corresponding function table of the same shape, which acts as a boolean mask which is only `1` when corresponding "removed" digits are equal
4. `#&,` Flattens `,` both function tables into lists and uses the boolean mask to filter `#` the quotients, since cancelling is only valid when the digits are equal
5. `%&".` the true quotient of the inputs after converting to ints
6. `e.` is that true quotient an element of the filtered list from step 4.
[Answer]
# [Python 3](https://docs.python.org/3/), 86 bytes
```
lambda a,b:g(a)&g(b)
g=lambda s:{(int(s[:i]+s[i+1:])/int(s),x)for i,x in enumerate(s)}
```
[Try it online!](https://tio.run/##RVLBbtswDL3zK3xabTQYJVEUpQA9ttddhl26HpzNbYylSeA4WIth3549OQV2sSLy6b3Hxxzf5@1hL5fnu@@XXf@6@dk3/Wqzfmn77tNLu@no5e6jfFr/acf93J4e1@PT7elxvPXrp46XUrd6654PUzOu3ppx3wz78@sw9fOAzt/L7@24G5qv03lYUzNP7/g2QB2bu/o9z21XC1C9Fj6fjrtxbm/4Zqkfp6rw3KLfoTC8/RiOc/Ot352H@2k6TOsPBF7@b99/efhobqah/3WB@LyFsPfiOPrsKRVOxVEpLCWRlMglK3lLHEwpK2d1pIVDUULRkqOgwlqrgTU4spK4oOvBgd@UM2sWElfRtSxccKbACWhJeJw8lBLn4gkqbFYl/FU5KYcUFwfJgIMFg0@wxhwpFLBDxMS4SKZYFPeIMaBSrvQxBajaQherLDx7jRzVL7RilccWvM/GKVe8crHr4NGEzBb1h353qnG5oOzFB4L1pREhFxNFy7hGEsFUAreuQB4ykM2VNgSEIKSCaXwiL8gM0wrk1RVSQ/y5UMa7AnqfHEs22Klnxp7qGIg8IhXoYYqC0CwWhBfIgPJQjZFNlDTjrEMFYTBSCHjtBfZt2V/AFBIUeIWbSOrq5pA1hpJQXbrlrhn0cO3NI3RsOEINa/dQQQT4TzgEUDEIEgmEgrceoLoQwzphqQYT7B8 "Python 3 – Try It Online")
*-8 bytes thanks to ovs*
Making use of the fact that the boolean value for `a0/b0==a/b` is equivalent to `a0/a==b0/b`. The helper function `g` generates all ratios `a0/a` and keeps track of the removed digit. Then it does the same for `b0/b`. The main function determines the intersection of the two sets.
Returns a non-empty set (boolean True in Python) if a match is found, and an empty set (boolean False in Python) otherwise.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~26~~ ~~23~~ 22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
€æ`âεR*Ë9ÝºIJySõ.;å*}à
```
-3 bytes thanks to *@Grimmy*.
Input as a pair `[numerator, denominator]`.
[Try it online](https://tio.run/##ATYAyf9vc2FiaWX//@KCrMOmYMOizrVSKsOLOcOdwrpJSnlTw7UuO8OlKn3DoP//WzExMzAsNDE4MV0) or [verify all test cases](https://tio.run/##NVK7ipRRDH6VYcslyMntJMFie0sthwUVLKwsBGELGwsbO3tBBAVBttvGcv7eh9gXGZOcf7qQy3dJ8u79q9dv35w/3N1cHR4/fz1c3dydfp8fP/3Zfr3cfvx7eH66v96@xPbt9Pd0/@zuxfbw5On28/rj9v0M5@NxBswYt3CMAI6ZAYdAuGaENoGsIldwrS4NoKhMlmxWhpRBV41AqQKLCdFdmKjWqO6gzgU/anIVGaKjSTB7kmeCTWwVEzwqSgVgtsjxomwq0JRd47SeSJHmuLjEq0iRrE1vbBDsGUlo5qo6iz8utDKpNdlOISWqHaIKiOJOxraQbZ9FN5i@ZhXCLosTK7dmuzpEHiDY@nBAuT0cxTzLhcecxrltjEgt3ZYKfCET5c4KTzntYjlCznX3Wji16IiqWl7TK/JECezZOYDdWl9F3mLKZV9PcpFSeGkyet8mkZuvUct@bE0iYFzO1DNavonBm5Uo0ZDbmO3vQaTApD2rqbg86qi36KNNzOryM/acetK2RzTM@/UjCbQbUkz@kqT5iFURru6@RO6QorEw29eNLT@mhdeCqcznV@2XkLx6O8aRIpFzS7f/AQ).
**Explanation:**
```
€æ         # Get the powerset of each number in the (implicit) input-pair
  `        # Push both lists separated to the stack
   â       # Create all possible pairs by taking the cartesian product
ε          # Map each pair to:
 R         #  Reverse the pair
  *        #  Multiply it by the (implicit) input-pair
   Ë       #  Check if both values are the same
 9Ý        #  Push a list in the range [0,9]
   º       #  Mirror each horizontally: [00,11,22,33,44,55,66,77,88,99]
 IJ        #  Push the input, joined together
   y       #  Push the pair we're mapping again
    S      #  Convert it to a flattened list of digits
     õ.;   #  Remove the first occurrence of those digits in the joined input,
           #  by replacing each first occurrence with an empty string
 å         #  Check if what remains is in the list of doubled digits
        *  #  And check if both that and the earlier check are truthy
}à         # After the map: check if any where truthy by taking the maximum
           # (after which this is output implicitly as result)
```
The `R*Ë` checks with input-pair \$[a,b]\$ and potentially reduced pair \$[c,d]\$ whether \$a×d=b×c\$ ([source](https://www.helpwithfractions.com/math-homework-helper/equivalent-fractions)).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~18~~ 17 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
DḌ-Ƥż$€÷þ/Ẏċ÷/,1Ɗ
```
A monadic Link accepting a list, `[numerator, denominator]` which yields zero (falsey) if not reducible, or a positive integer (truthy) if reducible.
**[Try it online!](https://tio.run/##ATQAy/9qZWxsef//ROG4jC3GpMW8JOKCrMO3w74v4bqOxIvDty8sMcaK////WzExMzAsIDQxODFd "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##RZMxjhRBDEWv0gFho23bVWU75xatCUnQXoCUBAkQpyAk3xVCJLO791gu0vjbRY80gcfj@n7@9nx4f3//8TjevT5@e/vy4/n3m7@ffl4frn/uXn99f/p6fbhb6eXLcf0c6fgcx77vw9dl@HZZl90jFB8Ixdu6uHXEpGNdWDO2vi7Ws7pHNXtmUaAjs9xlXfqs4Ag5Q/Uo8aom9NHqYxYlJtlyS5VZEipe8QiVUSoyID6oCKPcPOOAi6c6sehGPiLPo51TDK23GEON/hM0yxJ20BSYioaMGOLmHfmsGUnmN5w2uIj1bNsSufygHka2TieC6Oylpw5ZxMOmTvRyvRnfNN1RPemJZIs8BT@@7k0Nv6WsCBySmnJz4NUbINlswQyjU7YLXKEcmQT7KhcFeH3zrFGciGVs0HQqnREYYlrYGVvxpRV1Dg0baKkPJ7wWps2xvJRRvKQiblGiksN3QzwN4pjKioYZ6pT0tOl5g8zRSbiXTsdU6Ujf8vLqBgahZk6@nfluwClHSAkHUVfbQFlnTSBL4I7/QP7eJN/VQrEF9tImPJzHozjNGi8XxWlYB8pcaMNJlUe0YQyScPhy@Qc "Jelly – Try It Online").
### How?
```
DḌ-Ƥż$€÷þ/Ẏċ÷/,1Ɗ - Link: [n, d]
D                 - decimal digits (vectorises)
     $€           - last two links as a monad for each:
  -Ƥ              -   for overlapping 1-outfixes (i.e. less 1 digit):  
 Ḍ                -     un-decimal
    ż             -   zip (with digits - these are in the same order)
         /        - reduce by:
        þ         -   outer-product with:
       ÷          -     division -> [outfixesDivided, digitsDivided]
          Ẏ       - tighten (to a list of pairs)
                Ɗ - last three links as a monad:
             /    -   reduce ([n, d]) by:
            ÷     -     division
               1  -   one
              ,   -   pair -> [n÷d, 1]  i.e. digitsDivided must be 1
           ċ      - count occurrences
```
Unfortunately enumerate, `Ė`, given a number, `n`, yields `[[1, n]]` not simply the first pair `[1, n]`, which would save a byte with `...ċ÷/Ė$`.
[Answer]
# JavaScript (ES6), ~~100~~ 93 bytes
*Saved 7 bytes by using [@Jitse's method](https://codegolf.stackexchange.com/a/199759/58563)*
Takes input as `('numerator')('denominator')`. Returns a Boolean value.
```
n=>d=>(g=n=>[...n].map((x,i)=>x+-(n.slice(0,i)+n.slice(i+1))/n))(n).some(v=>g(d).includes(v))
```
[Try it online!](https://tio.run/##lVPLctpAELzzFbqxW8iKZl@zexA/QjhQCLvkwitXSCj/PZmHLCrHnBiG3p6enub9dD/dzr@mz98vdR4vj9fhUYf9OOzN20DFoeu6euw@Tp/GfLWTHfZfuxdTu9t1Ol9MT53d95dpB9b@qNaaarvb/HEx92H/ZkbbTfV8/TNebuZu7eM819t8vXTX@c0cDqm0TSr9sW0OhUpfEpe@hLYpOXINmNrGodQ5tk2Ogo6EdkW6DMAkXRd928QF4ah0UmIhSFE08BzUOTkTJHsZ2QvLAiGWonUilqQsPjF5AlVI8FykJnH0FBdZ8FSeqO9SWLdIqG95DczwrSBkgbjCalQYeiQan7kOJXJfMEmUlaeckJwqxnVsEMnqB0QyMkRYJXhcZuHKA5nqlBcemlXwaXxAcQdxVQ/ge@oD6d8swTjUthmPthn2zaupza7Zbq0Z9dN27/NUzbbdWm78rFu72fybgYCZ2UWY9@yxV5/6wgvqVF4qLyKd41OJsOjZVxDTwPPF9Q6eF4x9EQxyyLLUmTkLKE@iRXxGXVzqrBuKmRqowDcMws9eFj05hsLnFxrkl6CKA0HQi30xc71Y7GirrGqcY3YQ9dDjmmLnaJJ3UXkibyWOxF6yqylKwJhl837tx8xy1BFA4Ehp7gOr1D8GsDIRHPlfJL8HL@80EnwFV5Qb@OESP@Rw63pyKCeGRZayRCJwKNUj6HkN8OTwf6bDPv4C "JavaScript (Node.js) – Try It Online")
[Answer]
# T-SQL, 192 bytes
Returns -1 for true, 0 for false
```
WITH x as(SELECT substring(@n,number,1)b,substring(@,number,1)a,number
n FROM spt_values)SELECT~(1/~count(*))FROM x,x y
WHERE x.b=y.a AND x.b>0and 1*stuff(@,x.n,1,'')*@n=@*1*stuff(@n,y.n,1,'')
```
**[Try it online](https://rextester.com/IRKIJ44587)**
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 58 bytes
```
{[(&)] .map:{m:g/./>>.&{(.prematch~.postmatch)/.orig~$_}}}
```
[Try it online!](https://tio.run/##RVPRThwxDHz3V@xDhUCVznGc2DES9EMorSgCisT1TgdShRD8@nWcRerT2ruTyczYu787PNlx@7qc3C8Xx7er05Oz62Wzvdmfv23PH3jDl5ebk7fTzf5wt715uf39sdnvnl9mecab3eHx4ePLz/f39@Pzzevy7X7Z3O62v075@9@vfHb1o14v97vD8vT45@75aMEWZblYgqNQBGvY7NRIo3GMjlYbj07ixtWzFxSdRsfbPNu5F@rBNfrs8A1Qt/xmbIVqV@4TWnViK/c6W66FPIxjHsWpwD2Q4VOGoDAag/tQtHgqaUnqqaqwJ1o5Zi/K1skq239uNVxokmgUAk/GI2aPQgh@2H3CUaQL@fTcZXo22LGW7CjazMBc1gwMfAjBx@RDIam1jTa1tkY1IHk6qSiMXJ1DRzpFMagFoouENxSNLL3McUB2rOqb1VV9q/Dqn@rEU11LszPmVjNn6Y1bn@pQyFSr3la1mnr8k7968stwtlFXPkv@zrFOuM9scb65ruebElSv5j29i2ACTab7WSLP5gOQRppxK/IpAQfAQukYuKFWTE@pa8ZnJIpVQO4KZb0EdcdCjqCBcyHAW2EdDmX5HLgzE8BGtRyHEQxHCHkLjLWSAyW4tTV27dQHnukTawdGqmlblKR4Liv6zoptVbCZNOolNxFTNsH7VFlm3wfooVpc4BIbi/8BbFgR10od/0GhpolBxkigBs5iBEMxY8eCQVIGU52wjJkh4BzQLwUSRKX@Aw "Perl 6 – Try It Online")
Same approach as in Jitse's Python answer.
### Alternative, 75 bytes
```
{?grep {[==] $_ Z*$^m[(3,4),(0,2)]>>.join},m:ex/^(.*)(.)(.*)\s(.*)$1(.*)$/}
```
[Try it online!](https://tio.run/##RVPLbhsxDLzzK/YQFHZrmKIokWIBp//RPIq2cIoUcRIkhzYI8u3uUA7Qy4rcHVIzQ@7j/unOjoeX5cPNsju@fvn1tH9cXi92u6vl7Nvy9ePZ9eFipZu23qzKpq6vzs@3vx9u7982h8/7v3y92n5cr7brPC6f83km88lvx@fvL8vNsv35cPix4ss/n3h9cV2vlpuHp@Xu9n7/fLRgi7LsluAoFMEaNjM10mgcoyPVxqOTuHH1zAVBp9HxNms790I9uEafGb4B6pbfjK1Q7cp9QqtObOVeZ8q1kIdxzFJUBe4BDZ80BIHRGNyHIsWppCVbT1aFPdHKMXNRtk5W2f73VsOFJolGINBkPGLmCISgh90nHEGqkHfNXaZmgxxr2R1Bmx6Yy8kDQz@Y4GP2QyDJtY02ubZGNUB5KqkIjFydQ0cqRTCoBayLhDcEjSy1zHGAdpzYN6sn9q1Cq7@zE092LcVOm1tNn6U3bn2yQyCTrXo7sdXk4@/9q2d/Gc426qmfZf/OcZpwn96ivrme6psSWJ/Ee2oXwQSaTPUzhJ/NByCNNO1W@FMCCoAF0zFwQ62YnlLXtM9IFKsA3xXMegnqjoUcQQN1IcBbYR0OZnkO3JkOYKNajsMIgiOEvAXGWsmBEtzaGrt26gNn6sTaoSPVlC1KUjyXFXlnxbYqupk06iU3EVM2wftkWWbeB9qDtbhAJTYW/wO6YUVcK3X8B4WaJgYew4EaqMUIhmLGjgUDpTSmOmEZ00PAOcBfCiiISv0H "Perl 6 – Try It Online")
Same regex-based approach as in Neil's Retina answer.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 bytes
```
DżḌ-Ƥ$€ŒpḢ€E$Ƈ÷/€F=÷/Ẹ
```
[Try it online!](https://tio.run/##NVI9bpRBDO05xRYpHfF5PB7bikIF3AGtKGlQClq6KM02VNTQRJT0LAjRrJJ77F5kefZ8W401tt@P7Y8f7u4@n8@vn/4e91@un39cnR5@Pn39dNw/Inhz9bw7/HqJ6O0t3uOf/fn4@9/N6f7b5vrV5nT//eawe3HYIf/ufN6OoBHLe9pGkMRAINEpXBGxDWqWkSu5ZpUGtcgfpGzkT1MhnblG2jKwGBRVxUC1QnUndUn4JTtnUigqGo1GdcoA2OBSMcgjIyggs0nOF2VDqY2@ahxWHRBpzpOreyZbgLXoTYxCHFEPxV9mR/LHhbaPVppspegpqhyydurKK5nYRLa1l91o@OxVCrsMrlu6NVvVMctCnVPfZtvN8Z04IjAsJX8JaKhSMPtEbA2zShwV2OR0woIx1zgEGnSJzBq26Bk5UIKrdywkbqUrIy8R6a621jHAnngwFzVn64GJZ6uhnktT72SSjtQRTb9NyIu1NaBxquPF1rNoTUmaVq9CcXrUJc@hljUY2elnWf/UQVse2Rh7qwPqVG6aMvhTkuIAM9Mlq2sDmGGLwmKUz90aLqWE54Bbmsc1rRvo2HY55gUiWTCl/w "Jelly – Try It Online")
A monadic link taking a list of `[num, den]` and returning `1` for phony and `0` for non-phony. 
## Explanation
```
D                      | Convert to decimal digits
     $€                | For each list of decimal digits:
 ż                     | - Zip with:
  Ḍ-Ƥ                  | - A list of lists of digits each one with 1 removed, that has then been converted back to a list of integers
       Œp              | Cartesian product
            $Ƈ         | Keep those where the following is true:
         Ḣ€            | - The heads of each list (which will be the removed digits)
           E           | - Are equal
              ÷/€      | Reduce each by dividing
                 F     | Flatten (to remove the nested lists)
                  =÷/  | Equal to the original argument reduced by division
                     Ẹ | Any
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~109 86 81~~ 78 bytes
```
->n,d{g=->n,d{w=1;n.digits.map{|s|[s,d*(n%w+w*(n/w*=10))]}};g[n,d]&g[d,n]!=[]}
```
[Try it online!](https://tio.run/##nVLRbhpBDHzPV7iREkFC4vV6vV4XXX@EoogUBfFQigoRqhK@nc4e6g/0Hs63e2PPeOzf769/Lm/D5enbbrb@2AzXeBpkvntebzfb4@H552r/8Xn4XBxm64fJ7u70eELg08MgaTpdns/zzQI5y/vNYj3bLb8Mi@X5cneaiGjiIk2oBtdIFMEalTQKRzMSr5zdqBk3S2TBOYxw6TVRNmXrt5ktJ/KoHPgrqIFvao2tKWnq6H6tHIg1cwVaK5KrgKlyCyGwsHunkCtzNc61jAqqAwcJDp2oWlqhHKgOElfn0EYlDOeCNsAS1/KlZrD6WK50WmgWK1xMxrLqvY6PeGnOtXW8cfi18eJK7p19@s9fWs1eh8Pz4cdqN@Hv60ce/0zuvx5/vWyn8z0tAJi99fdyeb7Zvx8PdPvUn9sb2I2Gx2YKRJZKxRuOhVThhaLHFBANcRDbupicYZ2SKTyQSqJwGh4pRFsKMsfQWlBDXgjwNbE2RxM9NhLpzWNQBV6CD70HrPYSsDyTAyVgLYVdjawhdiuyMipSzsgWJUk@Tj1nY80GvEFNIUt93pgQmtLcVabxbA3loVpcMCrsRQEblkXAksmwSQkGdAzshwM5kCsA9TE6lgCSujHZ/9P2y18 "Ruby – Try It Online")
Saved some bytes by using multiplication instead of division: if `a/b==a0/b0`, then `a*b0==a0*b`.
Then stole some ideas from Jitse's excellent Python answer (upvote him!) to trim a couple of bytes off the corners.
[Answer]
# Excel (Ver. 1911), 64 Bytes
Fraction entered as a row literal of 2 strings e.x. `={"16","64"}`
```
A1    'Input: row literal of 2 strings -> ={num,den}
C1:D9 {=SUBSTITUTE(A$1#,ROW(),,1)} 'Array formula (entered with <C-S-Enter>)
E1    =SUM((C1:C9/D1:D9=A1/B1)*(A1#<>C1#)) 'Output (truthy/falsy int)
```
### Test Sample
[![test sample](https://i.stack.imgur.com/VWkJp.png)](https://i.stack.imgur.com/VWkJp.png)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~128~~ ~~126~~ 124 bytes
* Thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) for saving ~~two~~ four bytes.
```
P,h,o,n,_=10;i(e,s){for(n=P=1;e/P;P*=_)for(h=1;s/h;h*=_)e/P%_&&e/P%_==s/h%_&&(o=s/h/_*h+s%h,n*=!o|(e/P/_*P+e%P)*s-e*o);e=n;}
```
[Try it online!](https://tio.run/##jZM/c9swDMX3fAolPceSg8QE/4GoTu2W2UOHDL3z9Wy59lC5F3dL06/uggJlD1065QUCH394hDeP3zeb83kFezjCAOsOTXuoezg1b7vjaz10qw7bfrlqV4tu3eTSXgqn5b7d54J8ma3v78c/XSfl/F99zGq5XuwfTrM9DIvu9vi7lh4prR762apZnB77xbFp@25o388ftv3uMPTVl3qAbfPz9TD82tV3s0012y5n2@rPJxFfhzuobg9jx@f50/zj/GUO1QDVFiqtNu3NZPT830YvYvT0r9GPb4ehbt5uBCkyRDZNlszgOI7SsQdOYdRIESypTgFS0O7AYFmr0kBRqzY4CFOHhWBVEkfg0o1yD5V7UoKQnF5pssvU4oCLjhZicXFRzCMWwgiJVQsdEE1YeCWPAWz0lykilbMyBiWcCHzSFstCU8DIEbBLo/YcpK49MZPxFcdHW4jpcq3PyCUPDB58wAuCo@kuuvhgIohp8gnAdA3ek6ZDdKFHdAY8Zv4bWQVPST5l1@faOQnIoWrDQqcahSiNN4i2VnJ2ow5OQsGodSfPNYYoZ4UuGNYekg1JqpN4MhafaMAlUs1ZJ9WYk1Af6@UBvPpLEMyKQ57l7dSG5CQWYu@BXNDuJJpNIXaQCo214o5Kj4bKCuZ6AGdD8QkylSYSTF48X4hReqbJzaUekuCURJBQ9sEUTChz24BCpsBBfgL63bt8Tj2svILl4o1y0GkanmQzy3j5oawGJltc3jPbAJeM0MgY6HLC7@e/ "C (gcc) – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 69 bytes
```
L$w`(.)(.*)/(.*)\1
$($`$2)*$($3$1$')*_/$($`$1$2)*$($3$')*
\b(_+)/\1\b
```
[Try it online!](https://tio.run/##PZFNjlNBDIT3PsdDJEEat//tE7DhCJEmjMSCDQuExPFD9YvEJp041fVVl3//@PPz13d5frp8fTy/HX8fl7fr5e125f1xFzoux@PQ6w2nHXJ8vt7e@ZzJ/ylmdP@4vH@58l3uH89nDucsmmGbJBvn6SCpZK2gDu5YFMM6QRhWLtIwjj1VDl1Ukzz4V@CB79TN0Ua2tnqPjQdnKifUlricAlJyjxAoXLUR8iJnsKafCbKgQ4Rq2a7eTjpwB6SseKzJJ/DbKTdlXvaeCmqddr6xyCzh7CGnrdX2qVMvXZy99cFTr4d7GVWddBFb7AK@V2PiZIb8hlxrAIICgN4GqniuURhyS5IY2sG7DKBYQ1Eouoca90agz8XWBfA@G6QdGOU63u9JyDuop3xQk1JBJaC6c1lQNM4dX43hSKq4LUay6tyUarBpQB9I4xRr7witpmC@U67zdzTskVpKUC926aBhwQKKUmD7i9y2BpWhAR3cFYh29YXFIdIuRouw1LMyxyKQXxYiiIn@Aw "Retina – Try It Online") Link includes test suite. Outputs the number of phony pairs of digit cancellations. Explanation:
```
L$w`(.)(.*)/(.*)\1
```
List all matching pairs of digits in the numerator and denominator, including overlaps.
```
$($`$2)*$($3$1$')*_/$($`$1$2)*$($3$')*
```
Cross-multiply each value with the digit removed from the other value.
```
\b(_+)/\1\b
```
Count how many times this results in the same answer, indicating that this digit cancellation was a phony fraction.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 27 bytes
```
⊙θ⊙η∧⁼ιλ⁼×ＩΦη⁻ξμＩθ×ＩΦθ⁻ξκＩη
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxr1KjUEcBRGWAqBQN18LSxJxijUwdhRxNHQUoLyQzN7VYwzmxuETDLTOnJLUIpNo3M6@0WKNCRyFXUxOoFCxbCGJhqi5EUp2NUJ2hCQHW//8bGhobcJkYWhj@1y3LSQQA "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` for phony, nothing otherwise. Explanation:
```
 θ                          First input as a string
⊙                           Any character satisfies
   η                        Second input as a string
  ⊙                         Any character satisfies
      ι                     First character
     ⁼                      Equals
       λ                    Second character
    ∧                       Logical And
            η               Second input
           Φ                Filtered by
              ξ             Inner index
             ⁻              Minus (i.e. not equal to)
               μ            Second index
          Ｉ                 Cast to integer
         ×                  Multiplied by
                 θ          First input
                Ｉ           Cast to integer
        ⁼                   Equals
                     θ      First input
                    Φ       Filtered by
                       ξ    Inner index
                      ⁻     Minus (i.e. not equal to)
                        κ   First index
                   Ｉ        Cast to integer
                  ×         Multiplied by
                          η Second input
                         Ｉ  Cast to integer
                            Implicitly print
```
]