Here we focus on learning about software development. What we called before a "hypothesis" has now the simpler name "claim".
An important design consideration in SCG is how to prevent scholars from making trivial claims that cannot be successfully opposed. There are two ways to deal with this: 1. Create a predefined set of claims, called NonTrivialClaims, from which the scholars must choose the claims they want to propose. 2. Introduce the notion of strengthening a claim as an alternative way to oppose a claim. Strengthening involves proposing a new claim stronger than the previous one but that cannot be refuted.
The game can be played with scholar = human or scholar = software agent implemented by human.
Refutation Protocol: Alice gives her executable program to Bob. He runs test cases. If he finds one that breaks the program he wins.
In this version of the game, called SCGr, there is only one claim and scholar = software agent. We force all scholars to propose and oppose this one claim. There is no strengthening: instead there is one predefined claim from which all must choose. The winner of the game is the agent that has a program that could not be broken by all others and that has broken the most programs of others.
This game encourages the development of reliable software. After each round, the agents are improved based on the feedback from previous rounds. The perfect state is when all programs are correct and all agents receive the same score.
What is interesting is the journey to that ideal state. The programmers behind the agents are motivated to get all their bugs out and to make the programs efficient enough to satisfy the specification.
Alice claims: She can win RPpos(FS, JS, pred) FS is a set of artifacts given by a FS language. JS is a set of artifacts defined for F in FS. Given by JS language. pred is a predicate: pred(FS,JS).
Whatever F in FS Bob gives her, she can find a J in JS(F) making pred true. Only FS and JS and pred are known.
Refutation protocol RPpos(FS, JS, pred): Bob provides artifact F in set FS Alice processes F producing artifact J in set JS(F) Alice wins iff pred(F,J)
or
Alice claims: She can provide an F in FS to Bob so that he cannot find a J making pred true. Only FS and JS and pred are known.
Refutation protocol RPneg(FS,JS,pred): Alice provides artifact F in set FS Bob processes F producing artifact J in set JS(F) Bob wins iff pred(F,J)
The artifact might be an algorithm or some structure, like a Boolean formula. The processing might be complex, like analyzing an algorithm to be done by a human or simple, like finding an assignment for a Boolean formula.
Claims are chosen from a fixed catalog or they are defined intensionally by giving conditions that FS must satisfy.
Scholars are motivated to propose not successfully refutable claims.
Scholars must recognize claims they can defend (for proposing). Scholars must recognize claims they can refute (for opposing). The reputation of a scholar = fraction of unopposed claims that have been attempted to be opposed at least once divided by the total number of proposed claims. The scholar with the highest reputation wins. This creates a virtual world of scholars. Collaboration: Losing reputation means gaining knowledge.
Alice loses reputation when her claim is refuted by Bob but Bob has to give a detailed reason (artifact F that he cannot process as planned). Alice loses energy when she tries to refute a claim by Bob, but she does not succeed. Bob gave her a harder artifact F than she thought would exist: this creates a learning experience for Alice. We need to make sure that the scholars are discouraged to propose trivial claims.
============== variant Bob provides artifact F in set FS and a secret J' in JS(F) Alice processes F producing artifact J in set JS(F) Alice wins iff (pred(F,J,FS,JS(F)) and consistent(F,J')) Interesting claims: Other potential applications: Improve peoples health? If I get a free XYZ health club membership, I can lower my weight by 5% in 1 month.