Strongly Computationally idempotent: y:= f() leaves same system state as {f(); y:= f()}, particularly, both set the same value of y.

Under this defintion, computational idempotency entails referential transparency:

Experiment 1:
Startup Virtual Machine:
var y_0 := f();

Experiment 2:
Startup Virtual Machine:
var y_0 := f();
var y_1 := f();

By Idempotency: y_0 == y_1, which proves Referential Transparency.

What are your definitions of “idempotent” and “referentially transparent”?

My definitions:
Mathematically idempotent: f(f(x) == f(x)
Computationally idempotent: f() leaves same system state as {f(); f()}

Referentially transparent: f(x) == f(x)

Assuming some sort of non-referentially transparent random() function, here is a mathematically idempotent function that is not referentially transparent, in pseudocode:

Definitions:
function f(x) := if (x == 0) then { if random() then {return 1} else {return 2}} else {return x}
var y_0 := f(0)
var y_n := f(n)

F is idempotent:
f(y_0) == y_0 // always true, but y_0 could be either 1 or 2 each time the program runs.
f(y_n) == y_n == n // always true, for any n != 0

but not referentially transparent:
f(0) == f(0) — maybe, maybe not.

Here’s a computationally idempotent function that is not referentially transparent:
var x := 0;
function f := {y := x; x := 1 ; return y; }

//Startup Virtual Machine
f(); // returns 0, x is now 1
f(); // returns 1, but no state change: x is still 1

As for Dave’s point, these functions are (close to, exempting error conditions) idempotent, but have “hidden parameters”—such as the state of the network. The same goes for IntendedAudience’s example—where the hidden parameter is the current time.

These hidden parameters can be made explicit in a functional programming language such as Haskell, where they form part of a structure such as a monad.

I do agree that referential transparency and idempotence (either definition) are different. Your argument probably should have considered both definitions of idempotence, as that is where the confusion lies.

Furthermore, using the words necessarily and possibly does not mean you are using modal logic.