**Navid Roux**
(28bfa2ae)
*
at
03 Jun 14:00
*

fix "edit page" links

**Navid Roux**
(f0c413fd)
*
at
03 Jun 13:59
*

Update nroux.md

Imagine a multi-player 3D serious game with two players A and B, who *individually* have started playing around in the world and have solved some math puzzles in the form of quests.
Let GS_t(A) and GS_t(B) denote the game states, respectively, of A and B at some time t. For simplicity, let us assume game states are described by sets of quest IDs and that we have GS_t(A) = {1,3,5} and GS_t(B) = {2,4,6}.

Suppose players A and B want to cooperate by **sharing solutions** with each other. In the simplest case, this means to proceed to game states

GS_{t+1}(A) = GS_{t+1}(B) = {1,2,3,4,5,6}.

In the FrameIT project we realize a 3D serious game by combining a Unity frontend with an MMT backend, where MMT is a logic engine developed at this research group. In this setting, MMT takes care of providing, analyzing, and checking all math puzzle quests.

In MMT we represent GS_t(X) by MMT theories. To represent GS_{t+1}(A) = GS_{t+1}(B), we simply create a new theory that includes the theories representing GS_t(A) and GS_t(B). Thus, implementing the act of sharing solutions in FrameIT is academically rather easy and rather some minor design + boilerplate work in implementing it code-wise.

For a more advanced example, suppose we instead have GS_t(A) = {1,3,5} and GS_t(B) = {2,4,5'}. Note the overlapping 5 indicating that both players have solved quest 5, possibly differently (hinted at by the primed 5 for B)! Although we suppress it in the notation for simplicity here, note that those game states very much include the precise solution path that A and B have respectively used to solve all those quests.
Suppose A and B want to cooperate by **merging their solutions**, settling on some rather naive merge strategy that in the merge adopts solutions 1,3 by A and solutions 2,4,5' by B. Thus, we want

GS_{t+1}(A) = GS_{t+1}(B) = {1,3,5',2,4}.

Representing this final game state in MMT gets vastly more difficult than in the case before where we only performed a union. We now have to perform a *colimit* of the theories representing GS_{t}(A) and GS_{t}(B).

Sharing and merging are not only relevant for multi-player scenarios, but also relevant when players are able to compile a tree-like temporal history of quest-solving and want to go back and forth in time.

See also #37.

In the FrameIT project we build a framework for educational math games such that mathematical content in these games (e.g., theorems, proofs, deduction of conclusions) is outsourced to a full-blown logical inference engine (namely, MMT). This makes it possible to detangle knowledge management from game design in serious games.

MMT allows the formalization of complex mathematical theorems in the style "given these prerequisites, those are the consequences." In the FrameIT project, we call theorems formalized in this style *scrolls*. During game play, users can apply such theorems interactively. For example, they can first fill, say, the first prerequisite of a given theorem, then wait (and see the interactive response), and finally fill in the second prerequisite.
So far, we employ a minimalistic visualization, yet one that is already interactive. See Figures 5 and 6 in our workshop paper "Dynamic User Interfaces via Incremental Knowledge
Management" for a figurative overview and read the paper for all details.

A project or thesis could target enhancing this feature:

- Requirements Analysis: we could demand theorems be equippable with text descriptions (already done), math formulae (TeX, MathML?), images (SVGs?). How interactive should these elements be?
- Survey of Possible Implementation Strategies
- How to tackle rendering? Use HTML or SVG rendering engine in Unity?
- How to tackle interactivity?
- Is the interactivity, i.e. data binding, mono- or bidirectional?

- Specification of FrameIT MMT server <-> Unity frontend communication protocol
- Implementation
- Evaluation

A major technical problem may be that rendering of SVG and HTML within Unity is quite limited or only possible via costly plugins.

Related GitHub issues: https://github.com/UFrameIT/UFrameIT/issues/18, https://github.com/UFrameIT/UFrameIT/issues/70.

**Navid Roux**
(cfa76c6a)
*
at
19 Jan 20:15
*

Update nroux.md

**Navid Roux**
(2741676e)
*
at
19 Jan 19:58
*

Update nroux.md

**Navid Roux**
(300658ca)
*
at
19 Jan 19:44
*

add Navid to VollKI, change link to https

**Navid Roux**
(5a833e4e)
*
at
19 Jan 18:15
*

Update nroux.md

**Navid Roux**
(7ae3923f)
*
at
02 Oct 22:07
*

i've got an m.sc. degree now :)

**Navid Roux**
(e2f39d0b)
*
at
23 Jul 14:31
*

add metadata for my bsc talk back then (2019)