Detecting transformation rules and removing them

Question

Is it possible to detect the non-standard transformation rules (DownValues, UpValues, etc) that activate in an evaluation (and remove them)?

With non-standard I mean user defined, but the transformation rules assigned to Unprotected objects should be a good enough proxy for this.

So say I have assigned a downvalue for f, f[x_]:= x, and I input transformationDetection[f[1]] it would output the downvalue (and optionally remove that downvalue). Similarly if a chain of transformations are triggered it would output all of them (and optionally remove all of them).

Answer 1

Maybe something like the following will work for you:

SetAttributes[transformationDetection,HoldAll]
transformationDetection[expr_] := Module[{syms},
    {syms, values} = Reap[
        Thread[
            Cases[
                Unevaluated@expr,
                x_Symbol?valuesQ :> Hold[x],
                {0, Infinity},
                Heads->True
            ],
            Hold
        ],
        _Symbol,
        Rule
    ];
    Print[values];
    Replace[syms,
        {
        {} :> expr,
        Hold[z_] :> Block[z, Hold @ Evaluate @ expr]
        }
    ]
]

SetAttributes[valuesQ, HoldAll]
valuesQ[sym_] := With[{def=Language`ExtendedDefinition[sym]},
    Cases[
        def, 
        rule:Rule[
            OwnValues|DownValues|UpValues|SubValues,
            Except[{}]
        ] :> Sow[rule, sym],
        {3}
    ] =!= {}
]

A couple examples:

f[x_]:=x^2
g[x_]:=1/x

transformationDetection[Integrate[f[x], {x, 1, g[3]}]]

transformationDetection[Integrate[x^2, {x, 1, g[3]}]]

{f->{DownValues->{HoldPattern[f[x_]]:>x^2}},g->{DownValues->{HoldPattern[g[x_]]:>1/x}}}

Hold[Integrate[f[x], {x, 1, g[3]}]]

{g->{DownValues->{HoldPattern[g[x_]]:>1/x}}}

Hold[-(1/3) + g[3]^3/3]

In the first example, the Integrate expression does not evaluate because the DownValues for f were removed by the Block.