This is far from perfect, but it shows how you can get rid of the temporary variables.
The code is untested, which means it is almost certainly wrong.  But the refactoring
to eliminate temporaries should work.

I assume there is an at: method on BTFixedHeadCollection and an instantiateVariable:
method on this class.  Other interfaces are the same.

multiplicationLaurierePhD
     | letters  pbm |
     letters := BTFixedHeadCollection new: 30.
     #(a d g j m p) do: [:label | letters add: (V label: label from: 1 to: 9)].
     #(b c e f h i k l n o q r s t) do: [:label | letters add: (V label: label from: 0 to: 9)].
     #(0 1 2 3 4 5 6 7 8 9) do: [:ind | (BTCardinality on: letters value: ind) @= 2].
     self makeConstraintsFor: letters.
     pbm := self new: 'Magic multiplication'.
     pbm 
        print: (letters at: #a); 
        print: (letters at: #b); 
        print: (letters at: #c); cr; 
        print: (letters at: #d); 
        print: (letters at: #e); 
        print: (letters at: #f).
     #(a b c d e f) do: [:each | pbm instantiateVariable: (letters at: each)].
     pbm minSize.
     ^pbm

makeConstraintsFor: letters
     | op1 op2 inter1 inter2 result inter3 |
     op1 := ((letters at: #a) * 100 + ((letters at: #b) * 10) + (letters at: #c)) asVariable: 'abc'.
     op2 := ((letters at: #d) * 100 + ((letters at: #e) * 10) + (letters at: #f)) asVariable: 'def'.
     inter1 := ((letters at: #g) * 100 + ((letters at: #h) * 10) + (letters at: #i)).
     inter2 := ((letters at: #j) * 100 + ((letters at: #k) * 10) + (letters at: #l)).
     inter3 := ((letters at: #m) * 100 + ((letters at: #n) * 10) + (letters at: #o)).
     result := ((letters at: #p) * 10000 + ((letters at: #q) * 1000) + ((letters at: #r) * 100) + ((letters at: #s) * 10) + (letters at: #t)).
     op1 * (letters at: #f) - inter1 @= 0.
     op1 * (letters at: #e) - inter2 @= 0.
     op1 * (letters at: #d) - inter3 @= 0.
     inter1 + (10 * inter2) + (100 * inter3) - result @= 0.
     op1 * op2 - result @= 0.

>    multiplicationLaurierePhD
>     | letters a b c d e f g h i j k l m op1 op2 inter1 inter2 result n o p q r s t
>    inter3 pbm |
>     pbm := self new: 'Magic multiplication'.
>     (letters := BTFixedHeadCollection new: 30)
>      add: (a := V label: 'a' from: 1 to: 9); add: (b := V label: 'b' from: 0 to: 9);
>    add: (c := V label: 'c' from: 0 to: 9);
>      add: (d := V label: 'd' from: 1 to: 9); add: (e := V label: 'e' from: 0 to: 9);
>    add: (f := V label: 'f' from: 0 to: 9);
>      add: (g := V label: 'g' from: 1 to: 9); add: (h := V label: 'h' from: 0 to: 9);
>    add: (i := V label: 'i' from: 0 to: 9);
>      add: (j := V label: 'j' from: 1 to: 9); add: (k := V label: 'k' from: 0 to: 9);
>    add: (l := V label: 'l' from: 0 to: 9);
>      add: (m := V label: 'm' from: 1 to: 9); add: (n := V label: 'n' from: 0 to: 9);
>    add: (o := V label: 'o' from: 0 to: 9);
>      add: (p := V label: 'p' from: 1 to: 9); add: (q := V label: 'q' from: 0 to: 9);
>    add: (r := V label: 'r' from: 0 to: 9);
>      add: (s := V label: 's' from: 0 to: 9); add: (t := V label: 't' from: 0 to: 9).
>     op1 := (a * 100 + (b * 10) + c) asVariable: 'abc'.
>     op2 := (d * 100 + (e * 10) + f) asVariable: 'def'.
>     inter1 := (g * 100 + (h * 10) + i).
>     inter2 := (j * 100 + (k * 10) + l).
>     inter3 := (m * 100 + (n * 10) + o).
>     result := (p * 10000 + (q * 1000) + (r * 100) + (s * 10) + t).
>     op1 * f - inter1 @= 0.
>     op1 * e - inter2 @= 0.
>     op1 * d - inter3 @= 0.
>     inter1 + (10 * inter2) + (100 * inter3) - result @= 0.
>     op1 * op2 - result @= 0.
>     #(0 1 2 3 4 5 6 7 8 9) do: [:ind | (BTCardinality on: letters value: ind) @= 2].
>     pbm print: a; print: b; print: c; cr; print: d; print: e; print: f.
>     pbm variablesToInstantiate: ((BTCollection with: a with: b with: c with: d) add: e;
>    add: f; yourself).
>     pbm minSize.
>     ^pbm