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?