DCGs describe lists. Unlike everything else in Prolog, they describe these lists implicitly. Every value you compute in Prolog needs to be passed out of a predicate through an argument -- except for the lists described by DCGs, which you do not represent by an argument. They are instead represented as an implicit DCG state. (There are some uses for having the list as an argument as well, but it's not common.)
What this means is that when you convert a predicate to a DCG, you remove the list argument. But you must keep all other arguments so that you can communicate with the rest of the program.
So, for example, if you have the following predicate:
abc(A, B, C, [A, B, C]).
?- abc(a, b, c, ABC).
ABC = [a, b, c].
To convert it to a DCG that describes the list [A, B, C] you remove the list from the arguments but keep all other arguments:
abc(A, B, C) -->
[A, B, C].
?- phrase(abc(a, b, c), ABC).
ABC = [a, b, c].
What this means for your program is that your predicate
accept(List) :- ...
will turn into a DCG without arguments:
accept --> ...describe the list somehow...
and your steps predicate:
steps(Q, Steps, Q2) :- ...
will keep the states Q and Q2 as arguments but will remove the list argument:
steps(Q, Q2) --> ...describe the steps somehow...
With this knowledge, the first part of the translation is fairly mechanical:
accept -->
steps(q0, F),
{ final(F) }.
steps(Q, Q) -->
[].
steps(Q, Q2) -->
tran(Q, Qn),
steps(Qn, Q2).
As for the rest, you had some confusion in your transition DCG because suddenly it looked like you were trying to describe a list of states rather than a list of input symbols. This is partly because you chose bad variable names. This is not entirely your fault; many Prolog texts were written by people with a mathematical background, and written at times when books were printed on paper (which was expensive, so programs had to be more compact than anything else) or stored on tiny, slow storage devices (which again meant they had to be compact above all else) or viewed on tiny computer screens (which again meant that they had to be compact above all else). We don't have these restrictions anymore, so we can free ourselves from the shackles of the past. It is your responsibility to choose good variable names despite what outdated Prolog traditions teach you. By all of which I mean to say: If a variable describes a state, it should be called State instead of Y (or, yes, in automata theory Q can be canonical), and if a variable describes a symbol, it should be called Symbol instead of X.
Anyway. Here is a fixed version:
tran(Q, n0) --> [0], {Q = q0 ; Q = q1 ; Q = n0}.
tran(Q, n1) --> [1], {Q = q0 ; Q = q1 ; Q = n0}.
tran(n1, h1) --> [Symbol], {Symbol = 0 ; Symbol = 1}.
tran(h1, q1) --> [Symbol], {Symbol = 0 ; Symbol = 1}.
The original predicate behaves like this:
?- accept([1, 0, 0, 1, 0, 1]).
true ;
false.
?- accept([1, 0, 1, 0, 0, 0]).
false.
And the fixed DCG version behaves the same:
?- phrase(accept, [1, 0, 0, 1, 0, 1]).
true ;
false.
?- phrase(accept, [1, 0, 1, 0, 0, 0]).
false.
