Simple recursive transformation solution in Python
Your code works correctly – as far as I can see – for strictly positive
integers \$ a, b, c, d \$. It fails if the integers are allowed to
be zero or negative. For example:


solve(-1, -1, -2, -3) returns False although \$(-1, -1) \$ can
be transformed to \$ (-2, -3) \$.
solve(0, 0, 1, 1) fails with a “maximum recursion depth exceeded”
because it calls itself with the same arguments.


The remainder of this review is based on the assumption that 
\$ a, b, c, d &gt; 0\$.

The number of recursive calls increases quickly with larger input values
because in most cases you have two possible branches at

return solve(a+b, b, c, d) or solve(a, a+b, c, d)


As an example, solve() is called


\$29\$ times to compute that \$(4, 6)\$ is not
reachable from \$(1, 1)\$, and
\$8189\$ times to compute that \$(127, 99)\$ is reachable
from \$(1, 1)\$.


The problem is that one does not know if \$(a, b)\$ should become \$(a+b, b)\$
or \$(a, a+b)\$ in order to reach \$(c, d)\$.

The “trick” to do the transformations backwards. If \$(c, d)\$ is
reached eventually, then the previous pair must be either
\$(c-d, d)\$ or \$(c, d-c)\$. But only one of these is possible, depending on the
sign of \$ c-d \$.

That leads to the following implementation:

def solve(a, b, c, d):
  if a == c and b == d:
    return True
  elif a &gt; c or b &gt; d:
    return False
  elif c &gt;= d:
    return solve(a, b, c - d, d)
  else:
    return solve(a, b, c, d - c)


which is considerable faster: Now solve() is called


\$4\$ times to compute that \$(4, 6)\$ is not
reachable from \$(1, 1)\$, and
\$14\$ times to compute that \$(127, 99)\$ is reachable from \$(1, 1)\$.


The method can still fail with a “maximum recursion depth exceeded” runtime
error. But with this changed algorithm it is easy to replace the 
recursion by an iteration:

def solve(a, b, c, d):
  while c &gt;= a and d &gt;= b:
    if c == a and d == b:
        return True
    (c, d) = (c - d, d) if c &gt;= d else (c, d - c)
  return False


The algorithm itself can be improved further by replacing multiple transformations
$$
(c, d) \to (c-d, d) \to (c-2d, d) \to \ldots
$$
by a single transformation
$$
   (c, d) \to (c - kd, d)
$$
with a suitable integer \$k\$. How large can \$k\$ be chosen?
If that reminds you of the Euclidean algorithm for computing the greatest common divisor then you are on the right
track to implement an optimal method.