Novel Approach to Teaching Computer Science and Mathematics using The Scientific Community Game (SCG)

SCG proposes a novel learning and innovation technology. A scholar is either s student or a program (agent) written by a student.

The scholars contribute to a scientific community where they do experiments and propose claims. Other scholors oppose claims by either successfully strengthening or successfully discounting them. In both cases, the opposer gains reputation from the proposer. All scholars receive an initial reputation and the winning scholar is the one with the highest reputation. The undiscounted claims present the knowledge base that the group of scholars have collaboratively developed. While the scholars compete for reputation (the game is zero sum for reputation), they collaborate on knowledge creation giving each other very specific, constructive feedback.

The scholar = agent version is called SCG-Agent and the competitions are fully automatic. The scholar = student version is called SCG-Scholar and it operates through email. In both cases, the administrator checks the SCG rules.

To teach a specific CS topic, define suitable claims language:

Automata Theory

Let's consider the case of knowledge dissemination for basic Automata Theory to Alice and Bob: Consider the following exchange between Alice and Bob:

Alice claims the claim: Any regular expression of size 10 can be translated into an equivalent DFA with at most 80 states. The size is defined by ...

Bob strengthens Alice' claim to: Any regular expression of at most size 10 can be translated into an equivalent DFA with at most 70 states.

Alice discounts: Alice gives to Bob a regular expression, but Bob can only find an equivalent DFA with 75 states. Bob loses reputation to Alice.

The final undiscounted claims might be: Any regular expression of at most size 10 can be translated into an equivalent DFA with at most 25 states.

This might be a theorem or a conjecture that can be strengthened further. Scholars that lose reputation need help and they get significant help from their opposer.


Alice claims the claim: min t max b f(t,b) < 0.8. t and b are vectors in a subset of some vector space.

Bob opposes Alice' claim by strengthening it: min t max b f(t,b) < 0.7.

Alice opposes Bob's claim by strengthening it further: min t max b f(t,b) < 0.6.

Bob opposes Alice' claim by challenging it. Alice provides t=t0 and Bob finds b=b0 and it turns out that f(t0,b0)=0.65. Therefore Bob wins reputation from Alice.


Alice claims: There is a translation T from Satisfiability to Graph Coloring with 3 colors so that for all Satisfiability problem instances s, the graph T(s) is 3-colorable iff s is satisfiable.

Bob challenges Alice (he knows that this is a theorem but he thinks that Alice does not understand it). Alice provides T, Bob chooses s and computes T(s). It turns out that s is unsatisfiable but T(s) is 3-colorable. Therefore, Bob wins although Alice'claim is correct.

Programming language type checking

Alice proposes: For all type-correct programs p of some programming language PL and for all inputs f to program p: no-run-time-error(p,f). Bob opposes by challenging. Bob delivers, after studying PL, p0 and f0 so that p0 is type correct and run-time-error(p0,f0). Bob wins reputation from Alice. (Alice is not involved in the protocol other than proposing.)

Claim Design for Education

To design a scholarly SCG community to explore a set of learning objectives is an interesting design problem.

direct design: A learning objective is directly appearing in the claim. For example, in a mathematics course about solving min-max problems, a claim might directly look like: min t max b f(t,b) > 0.3. t and b are vectors in some vector space.

indirect design: A learning objective is not directly appearing in the claim. For example, in a capstone course in a computer science program you want students to review combinations, permutations, symmetry, minimizing and maximizing functions, solving search problems. We use the following kind of claims: For all CSP-problems S of kind R there exists an assignment J satisfying the fraction q of the constraints.

Comparing SCG-Agent and SCG-Scholar

SCG-Agent: scholars = agents: promotes new algorithms, system testing, flexible, reliable software. developers behind agents develop innovative algorithms and software. scholars develop new knowledge.

SCG-Scholar: scholars = students: promotes knowledge innovation and dissemination through a hands-on learning experience with constructive feedback. Student evaluation.