http://planetmath.org/encyclopedia/IFLogic.html
Adapted for Algorithms:
To each first-order sentence phi we assign a game G(phi)
with two players, played on a model. The two players
are called verifier and falsifier. The verifier tries to show
that the sentence is true in the model, while the
falsifier attempts to show that it is false in the model.
[other names we used:
Alice = Proposer = P[E] = verifier
Bob = Opposer = P[A] = falsifier
]
the game G(Exists x:phi(x)) begins with the choice by verifier
of a member of M which is given a name aa, and then proceeds
as G(phi(aa)).
the game G(ForAll x:phi(x)) is the same as G(Exists x:phi(x))
except that the choice of a is made by the falsifier
the game G(!phi) is the same as G(phi) with the
roles of the falsifier and verifier exchanged
if P is an n-ary predicate and t[i] are names of
elements of the model, then G(P(t[1],...,t[n])) is
a game in which the verifier immediately
wins if (t[1],...,t[n]) in P, otherwise the
falsifier immediately wins.
Truth of a sentence phi is defined as the existence of a
winning strategy for verifier for the game G(phi) .
Similarly, falsity of phi is defined as the existence of a
winning strategy for the falsifier for the game G(phi) .
(A strategy is a specification that determines
for each move of the opponent what the player should do.
A winning strategy is a strategy which guarantees victory no matter what strategy the opponent follows.)
For classical first-order logic, this definition is equivalent to
the usual Tarskian definition of truth (i.e. the one based
on satisfaction found in most treatments of semantics of first-order
logic). This means also that since the law of excluded middle
holds for first-order logic that the games G(phi) have a very strong property: either the falsifier or the verifier has a winning strategy.
Notice that all rules except those for negation and atomic sentences concern finding an element.
These can be codified into functions, which tell us which element of the model to choose, based on our previous choices and those of our opponent.
These sort of functions are known as Skolem functions, and they are
in essence just winning strategies for the verifier.
====================
The way we use those games:
Our claims most of the time are of the form: ForAll x in InstanceSet Exists y in Solution: valid(x,y) and p(x,y) or the negation of such a claim.
We have translated such sentences into refutation protocols:
Falsifier provides x
Verifier solves x for y
check: valid(x,y) and p(x,y): is true: verifier wins (claim is defended) otherwise falsifier wins (claim is refuted).
====================
==================== EXTRA === NOT FOR CLASS
In SCG we make those refutation protocols the central topic. The notion of quality of a solution: quality(x,y) is built in.
Alice provides x
Alice solves x for yA
Bob solves x for yB:
valid(x,yA) and valid(x,yB) and quality(yB)>=quality(yA).
This cannot be expressed in predicate logic. It means: Bob is at least as good as Alice.
Can it be expressed in IF-logic?
IF-logic:
(ForAll x // Exists y) Exists y phi(x,y) asserts that for any
choice of value for x by the falsifier, the verifier can find a
value for y that does not depend on the value of x,
s.t. phi(x,y) is true.
Bob provides x
Bob provides dummy (constant)
Alice solves dummy for y
p(x,y)
IF-logic: what is not available later
SCG: which earlier provided value to use
Both are informationally incomplete games.
SCG:
Bob provides x
Bob solves x for yB (yB is secret)
Alice solves x for yA
p(x,yA,yB)
In SCG, only solutions are hidden.
Provided values are not hidden.
Can we do:
Bob provides x
Bob solves x for yB
Bob provides quality(x,yB)
Alice solves x for yA
p(x,yA,yB,quality(x,yB))
Would need extension of protocol?