dafny how to apply trigger - triggers

Question

I have read the very helpful (Dafny: What does no terms found to trigger on mean?) but can any one tell me how to prove the two assertions marked with /**/.
Not even sure if they can be proven. The logically equivalent assertions with the defined function inters are proven and may be that is as far as you can go. Any insight greatly appreciated.
function inters(a:set<int>, b:set<int>): set<int> {a*b}
method pingo(a:set<int>, b:set<int>)
{
assert (forall x:int :: (x !in inters(a , b) ) <==> (x in a ==> x!in b ));
assert (forall x:int :: (x !in a*b) <==> (x in a ==> x!in b ));
assert (forall x:int :: (x !in inters(a , b) )) <==>
(forall x:int :: (x in a ==> x!in b ));
/**/ assert (forall x:int :: (x !in a*b)) <==>
(forall x:int :: (x in a ==> x!in b ));
assert ((a*b) == {}) <==> (forall x:int ::(x in a ==> x!in b )) ;
assert ((a*b) == {}) ==> (forall x:int :: (x !in inters(a , b) ));
/**/ assert ((a*b) == {}) ==> (forall x:int :: (x !in a*b )) ;
}

Answer 1

I know this answer comes a bit later and indeed does not offer anything new, but I coded the original problem (the same code as David Streader but where all the
inters(a,b) have been substituted by a*b) and the solution (all the a*b replaced by inters(a,b)). Just if someone wants to play:
Original problem (full of warnings):
function inters(a:set<int>, b:set<int>): set<int> {a*b}
method pingo(a:set<int>, b:set<int>)
{
assert (forall x:int :: (x !in (a*b) ) <==> (x in a ==> x!in b ));
assert (forall x:int :: (x !in a*b) <==> (x in a ==> x!in b ));
assert (forall x:int :: (x !in a*b )) <==>
(forall x:int :: (x in a ==> x!in b ));
assert (forall x:int :: (x !in a*b)) <==>
(forall x:int :: (x in a ==> x!in b ));
assert ((a*b) == {}) <==> (forall x:int ::(x in a ==> x!in b )) ;
assert ((a*b) == {}) ==> (forall x:int :: (x !in a*b ));
assert ((a*b) == {}) ==> (forall x:int :: (x !in a*b )) ;
}
Solution (no warnings):
function inters(a:set<int>, b:set<int>): set<int> {a*b}
method pingo(a:set<int>, b:set<int>)
{
assert (forall x:int :: (x !in inters(a , b) ) <==> (x in a ==> x!in b ));
assert (forall x:int :: (x !in inters(a , b) ) <==> (x in a ==> x!in b ));
assert (forall x:int :: (x !in inters(a , b) )) <==>
(forall x:int :: (x in a ==> x!in b ));
assert (forall x:int :: (x !in inters(a , b) )) <==>
(forall x:int :: (x in a ==> x!in b ));
assert ((a*b) == {}) <==> (forall x:int ::(x in a ==> x!in b )) ;
assert ((a*b) == {}) ==> (forall x:int :: (x !in inters(a , b) ));
assert ((a*b) == {}) ==> (forall x:int :: (x !in inters(a , b) )) ;
}
//
So in this case, if we take James Wilcox's answer, only the first suggestion can be used (wrap the forall... in a function). That's because here is no case where we can apply the ‘expansion’, because there are only cases like x!in ..., and x!in inters(a,b) is not the same as x!in (a) && x!in(b).