Operator chart minification problem

There is a puzzle I've been knowing about a while now. I
think it's an important problem to solve if I plan going on
with the type-inferencer that I've been working on lately.

First some examples. The following program:

c = a + b
while (d < e) {
c = c + e
}

Produces the chart:

a+b = c
d<e = f
e+c = c

And the following program:

a = 1 + b
c = d + (1 + 1.5)

Produces the chart:

Int + b = a
b + (Int|Rational) = c

And the following program:

f = a + b + c + d + e
u = a + b

Produces the chart:

a+b = g
g+c = h
h+d = i
i+e = f
a+b = u

Now some rules. We can collapse two expressions if we can
prove that they have the same resolution. The resolution
depends entirely on the input types.

For example, we can collapse a+b = g and a+b = u in the
previous example, because they have same input flows. The
chart shrinks to:

a+b = g&u
g+c = h
i+e = f

We rely on unique coercion on the rules. When resolving an
operator, either side must be convertible to an another, but
inverse must not be allowable.

Eg. If X -> Y and Y -> X, then we have a type error on
X + Y, because there is no unique coercion to resolve that
operation. In other hand if X -> Z, but not another way
around, then X + Z can resolve to (+)::Z.

We can hoist every graph into set of input variable
flows, for instance the second example can be rewritten as:

Int = x
Int|Rational = y
x + b = a
b + y = c

Now, the interesting questions related to this puzzle:

Is it possible for us to know when some graph is
minimal or irreducible to smaller format?

Are there some other rules we can use for minifying the
graph?

Can an algorithm be written for minifying the graph, if
the graph is internally in a flow-format?