Juni 2016

Band 31, Nummer 6

Testlauf – Einführung in Prognosemärkte

Von James McCaffrey

Angenommen, Sie wollen das Ergebnis eines anstehenden Meisterschaftsspiels im American Football zwischen den Xrays und den Yanks vorhersagen. Sie finden eine Gruppe von 20 American Football-Experten und geben jedem Chips im Wert von 500 US-Dollar ($). Die Experten dürfen Anteile an beiden Teams in einer Weise kaufen und verkaufen, die mit dem Aktienmarkt vergleichbar ist.

Wenn ein Experte Anteile an einem Team kauft, z. B. den Xrays, steigt der Preis eines Anteils an diesem Team und der Preis eines Anteils am anderen Team sinkt. Mit der Zeit kaufen und verkaufen die Experten Anteile an den beiden Mannschaften, bis sich Preise stabilisieren. Anschließend können Sie die Wahrscheinlichkeit des Siegs eines der Teams ermessen.

Einen Tag vor dem Meisterschaftsspiel stellen Sie den Handel ein. Nachdem die Partie ausgetragen und der Sieger bestimmt wurde, zahlen Sie Experten mit Anteilen am siegreichen Team entsprechend dem letzten Preis des Teams bei Einstellung des Handels aus. Da die Experten wissen, dass sie ausbezahlt werden, besteht der Anreiz, während des Handels ihre wahren Meinungen kundzutun.

Was ich gerade beschrieben habe, wird als Prognosemarkt bezeichnet. In diesem Artikel beschreibe ich die mathematischen Grundlagen von Prognosemärkten und zeige, wie die wichtigsten Funktionen in Code implementiert werden. Es ist unwahrscheinlich, dass es sich bei Ihren täglichen Aufgaben ergibt, dass Sie einen Prognosemarkt erstellen, doch ich glaube, dass Sie die Konzepte dahinter sehr interessant finden werden. Darüber hinaus können einige der in diesem Artikel vorgestellten Programmiertechniken in gängigeren Szenarien der Softwareentwicklung zum Einsatz kommen.

Dieser Artikel geht davon aus, dass Sie über mindestens grundlegende Programmierkenntnisse verfügen, ohne aber anzunehmen, dass Sie irgendetwas von Prognosemärkten verstehen. Ich stelle ein vollständiges Demoprogramm vor, und Sie können außerdem den Quellcode aus dem Download abrufen, der diesen Artikel begleitet. In der Demo wird zwar C# verwendet, aber der Code sollte sich ohne Schwierigkeiten in eine anderen von Ihnen bevorzugte Sprache umgestalten lassen.

Beachten Sie, dass dies eine informelle Einführung in Prognosemärkte ist, die hauptsächlich für Softwareentwickler gedacht ist. Ich erlaube mir Freiheiten bei Terminologie und Definitionen, um die wesentlichen Konzepte so unmissverständlich wie möglich zu halten.

Beispiel

Prognosemärkte lassen sich wohl am besten anhand eines konkreten Beispiels erläutern. Sehen Sie sich das Demoprogramm in Abbildung 1 an. Nach einigen einleitenden Meldungen beginnt die Ausgabe der Demo mit:

Setting liquidity parameter = 100.0

Initial number of shares owned of teams [0] and [1] are:
0 0

Initial inferred probabilities of winning are:
 0.5000  0.5000

Abbildung 1: Demo eines Prognosemarkts

Der Parameter „liquidity“ wird in Kürze detailliert erläutert. Doch für den Moment reicht es aus zu wissen, dass die Liquidität den Grad bestimmt, mit dem Marktpreise auf Kauf und Verkauf reagieren. Höhere Werte für Liquidität sorgen für geringere Preisänderungen.

Anfänglich halten die Experten keine Anteile. Da die Anzahl der gehaltenen Anteile jedes Teams gleich (nämlich null) ist, ist es plausibel, dass die anfänglich gefolgerte Wahrscheinlichkeit des Siegs eines Teams 0,50 ist.

Der nächste Teil der Demoausgabe sieht so aus:

Current costs for one share of each team are:
 $0.5012  $0.5012

Ein Anteil an einem Team hat jederzeit einen bestimmten Preis. Experten müssen diesen Preis kennen, da sie um echtes Geld spielen. Da die anfänglichen Wahrscheinlichkeiten eines Siegs gleich sind, ist es plausibel, dass die Preise für die Anteile an jedem Team auch gleich sind.

Der nächste Teil der Demoausgabe sieht so aus:

Update: expert [01] buys 20 shares of team [0]

Cost of transaction to expert was: $10.50

Experte 1 meint, dass Team 0 (die Xrays) gewinnen wird und kauft 20 Anteile an Team 0. Die Kosten für diesen Experten betragen $ 10,50. Wie Sie sehen, ist der Preis für 20 Anteile ($ 10,50) nicht identisch mit dem Preis des 20-fachen eines einzelnen Anteils (20 x $ 0,5012 = $ 10,02). Mit dem Kauf jedes Anteils erhöht sich der Preis eines zusätzlichen Anteils des Teams. Der nächste Teil der Demoausgabe sieht so aus:

New number of shares owned of teams [0] and [1] are:
20 0

New inferred probabilities of winning are:
 0.5498  0.4502

Die Demo zeigt die aktualisierte Anzahl von Anteilen, die für jedes Team verbleiben, (x, y) = (20, 0), und berechnet und zeigt aktualisierte gefolgerte Wahrscheinlichkeiten des Siegs der beiden Teams (0,55, 0,45). Da Experten mehr Anteile von Team 0 als von Team 1 gekauft haben, muss die gefolgerte Wahrscheinlichkeit des Siegs von Team 0 größer als bei Team 1 sein. Die Berechnung der Wahrscheinlichkeiten wird in Kürze erläutert.

Als Nächstes zeigt die Demo Folgendes:

Current costs for one share of each team are:
 $0.5511  $0.4514

Update: expert [02] buys 20 shares of team [1]

Cost of transaction to expert was: $9.50

Die neuen Kosten pro Anteil an den Teams werden berechnet und angezeigt. Beachten Sie, dass der Preis eines Anteils an Team 0 ($ 0,55) nun ein wenig höher als bei Team 1 ($ 0,45) ist. Dies gibt Experten einen Anreiz zum Kauf von Anteilen an Team 1, wenn sie meinen, dass der Preis im Verhältnis zur Wahrscheinlichkeit des Siegs von Teams 1 günstig ist. In diesem Fall simuliert die Demo, dass 20 Anteile an Team 1 von Experte 2 mit Kosten in Höhe von $ 9,50 erworben werden. Nächster Schritt:

New number of shares owned of teams [0] and [1] are:
20 20

New inferred probabilities of winning are:
 0.5000  0.5000

Für jedes Team verbleiben nun noch 20 Anteile, weshalb sich die gefolgerten Wahrscheinlichkeiten des Siegs eines der Teams wieder in 0,50 und 0,50 ändern.

Der nächste Teil der Demoausgabe sieht so aus:

Current costs for one share of each team are:
 $0.5012  $0.5012

Update: expert [03] buys 60 shares of team [0]
Cost of transaction to expert was: $34.43

New number of shares owned of teams [0] and [1] are:
80 20

New inferred probabilities of winning are:
 0.6457  0.3543

Experte 3 ist der festen Ansicht, dass Team 0 gewinnen wird, weshalb er 60 Anteile von Team 0 zum Preis von $ 34,43 erwirbt. Diese Transaktion ändert die Anzahl verbleibender Anteile in (80, 20) und bewirkt, dass sich die neu gefolgerten Wahrscheinlichkeiten eine Siegs stark in Richtung Team 0 verschieben (0,65, 0,35).

Als Nächstes erkennt Experte 1, dass der Wert seiner Anteile an Team 0 stark gestiegen ist, nämlich auf $ 0,6468 pro Anteil:

Current costs for one share of each team are:
 $0.6468  $0.3555

Update: expert [01] sells 10 shares of team [0]
Cost of transaction to expert was: $-6.34

New number of shares owned of teams [0] and [1] are:
70 20

New inferred probabilities of winning are:
 0.6225  0.3775

Experte 1 meint, dass Team 0 nun in Bezug auf seine Siegchancen überbewertet sei, und verkauft 10 seiner 20 Anteile, wofür er $ 6,34 erhält (was durch das Minuszeichen angegeben wird). Die neuen gefolgerten Wahrscheinlichkeiten nähern sich wieder ein wenig an, doch ein Sieg von Team 0 wird weiter mit der Wahrscheinlichkeit 0,63 prognostiziert.

Die Demo endet mit der Einstellung des Handels. Die endgültigen Wahrscheinlichkeiten sind das Ziel des Prognosemarkts. Nach Abschluss des Spiels zwischen den Xrays und den Yanks würden die Experten für die Anteile bezahlt, die sie am siegreichen Team halten, und zwar basierend auf dem letzten Anteilspreis des siegreichen Teams. Die Zahlungen regen die Experten an, ihre wahre Meinung kundzutun.

Die vier wichtigsten Gleichungen für Prognosemärkte

Ein einfacher Prognosemarkt basiert auf vier mathematischen Gleichungen (siehe Abbildung 2). Keine Angst, die Gleichungen sind nicht annähernd so kompliziert, wie es zunächst den Anschein haben mag. Es gibt mehrere mathematische Modelle, die zum Definieren eines Prognosemarkts verwendet werden können. Das in diesem Artikel präsentierte Modell basiert auf der sog. logarithmischen Marktbewertungsregel (Logarithmic Market Scoring Rule, LMSR).

Abbildung 2: Die vier wichtigsten Gleichungen für Prognosemärkte

Gleichung 1 ist die Kostenfunktion, die mit einer Menge verbleibender Anteile (x, y) verknüpft ist. Die Gleichung stammt, was überhaupt nicht offensichtlich ist, aus der Wirtschaftstheorie. Aus Entwicklersicht können Sie sich die Gleichung als Hilfsfunktion vorstellen. Sie verwendet x (die Anzahl der gehaltenen Anteile an Option 0) und y (die Anzahl der gehaltenen Anteile an Option 1) und gibt einen Wert zurück. Variable b in allen vier Gleichungen ist der Parameter „Liquidität“. Angenommen, x = 20 und y = 10. Wenn b = 100,0, dann C(x,y) = 100,0 x ln(exp(20:100) + exp(10:100)) = 100,0 x ln(1,22 + 1,11) = 100,0 x 0,8444 = $ 84,44. Der Rückgabewert wird in Gleichung 2 verwendet.

Gleichung 2 sind die Kosten einer Transaktion für einen Käufer. Angenommen, die aktuelle Menge verbleibender Anteile ist (20, 10) und ein Experte kauft 30 Anteile von Option 0. Die Kosten dieser Transaktion für den Experten werden mithilfe von Gleichung 2 als C(20+30, 10) - C(20, 10) = C(50, 10) - C(20, 10) = 101,30 - 84,44 = $ 16,86 berechnet. Wenn ein Experte Anteile verkauft, sind die Kosten der Transaktion ein negativer Wert, der angibt, dass der Experte eine Zahlung erhält.

Gleichung 3 ist technisch gesehen der Grenzpreis von Option 0 basierend auf der Menge verbleibender Anteile (x, y). Doch ein Grenzpreis kann lose als die Wahrscheinlichkeit interpretiert werden, mit der eine Option gewinnt. Gleichung 4 ist der Grenzpreis (die Wahrscheinlichkeit) von Option 1. Wenn Sie sich die beiden Gleichungen näher ansehen, werden Sie feststellen, dass ihre Summe 1,0 sein muss, was für eine Menge von Wahrscheinlichkeiten erforderlich ist.

Die Implementierung der vier wichtigsten Gleichungen für Prognosemärkte ist unkompliziert. Das Demoprogramm implementiert die Kosten (Gleichung 1) wie folgt:

static double Cost(int[] outstanding, double liq)
{
  double sum = 0.0;
  for (int i = 0; i < 2; ++i)
    sum += Math.Exp(outstanding[i] / liq);
  return liq * Math.Log(sum);
}

Die „Cost“-Methode ist praktisch eine exakte Übersetzung von Gleichung 1. Beachten Sie, dass die „Cost“-Methode davon ausgeht, dass es bloß zwei Optionen gibt. Aus Gründen der Einfachheit erfolgt keine Fehlerüberprüfung.

Gleichung 2 ist auch einfach zu implementieren:

static double CostOfTrans(int[] outstanding, int idx, int nShares, double liq)
{
  int[] after = new int[2];
  Array.Copy(outstanding, after, 2);
  after[idx] += nShares;
  return Cost(after, liq) - Cost(outstanding, liq);
}

Das Array namens „after“ enthält die neue Anzahl verbleibender Anteile nach einer Transaktion. Anschließend ruft die Methode die Hilfsmethode „Cost“ zweimal auf. Mit einer Methode zum Berechnen der Kosten einer Transaktion zur Hand ist es einfach, eine Methode zu schreiben, die die Kosten des Kaufs eines einzelnen Anteils von jeder der beiden Optionen berechnet:

static double[] CostForOneShare(int[] outstanding, double liq)
{
  double[] result = new double[2];
  result[0] = CostOfTrans(outstanding, 0, 1, liq);
  result[1] = CostOfTrans(outstanding, 1, 1, liq);
  return result;
}

Anhand der Kosten eines einzelnen Anteils können Experten einen Annäherungswert der Kosten des Kaufs von „n“ Anteilen einer Option bestimmen.

Die Methode „Probabilities“ gibt die beiden Grenzpreise (gefolgerten Wahrscheinlichkeiten) bei Sieg einer der Optionen in einem Array zurück:

static double[] Probabilities(int[] outstanding, double liq)
{
  double[] result = new double[2];
  double denom = 0.0;
  for (int i = 0; i < 2; ++i)
    denom += Math.Exp(outstanding[i] / liq);
  for (int i = 0; i < 2; ++i)
    result[i] = Math.Exp(outstanding[i] / liq) / denom;
  return result;
}

Wenn Sie den Code für die „Probabilities“-Methode mit den Gleichungen 3 und 4 vergleichen, erkennen Sie wiederum, dass der Code direkt der mathematischen Definition folgt.

Das Demoprogramm

Um das Demoprogramm zu erstellen, habe ich Visual Studio gestartet und die Projektvorlage „C#-Konsolenanwendung“ ausgewählt. Ich habe das Projekt „PredictionMarket“ genannt. Die Demo hat keine nennenswerten Microsoft .NET Framework-Abhängigkeiten, sodass jede Version von Visual Studio funktionieren sollte.

Nachdem der Vorlagencode im Fenster „Projektmappen-Explorer“ geladen wurde, habe ich die Datei „Program.cs“ umbenannt und ihr den anschaulicheren Namen „PredictionMarketProgram.cs“ gegeben. Visual Studio hat daraufhin die Programmklasse automatisch für mich umbenannt. Am Anfang des Quellcodes habe ich alle Anweisungen mit Verweisen auf nicht benötigte .NET-Namespaces gelöscht und nur den Verweis auf den obersten Namespace „System“ übrig gelassen.

In Abbildung 3 wird der gesamte Democode mit ein paar kleinen Änderungen und einigen gelöschten „WriteLine“-Anweisungen gezeigt, um Platz zu sparen. Die gesamte Programmsteuerungslogik ist in der Methode „Main“ enthalten. Die gesamte Prognosemarktfunktionalität ist in vier statischen Methoden enthalten, und es gibt zwei "ShowVector"-Hilfsanzeigemethoden.

Abbildung 3: Demo eines Prognosemarkts

using System;
namespace PredictionMarket
{
  class PredictionMarketProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin prediction market demo ");
      Console.WriteLine("Goal is to predict winner of Xrays");
      Console.WriteLine("vs. Yanks using expert opinions");
      double liq = 100.0;
      Console.WriteLine("Setting liquidity parameter = " +
        liq.ToString("F1"));
      int[] outstanding = new int[] { 0, 0 };
      Console.WriteLine("Initial number of shares owned are:");
      ShowVector(outstanding);
      double[] probs = Probabilities(outstanding, liq);
      Console.WriteLine("Initial probabilities of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      double[] costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are: ");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [01] buys 20 shares " +
        "of team [0]");
      double costTrans = CostOfTrans(outstanding, 0, 20, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 20, 0 };
      Console.WriteLine("New number of shares owned are: ");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are:");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [02] buys 20 shares " +
        "of team [1]");
      costTrans = CostOfTrans(outstanding, 1, 20, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 20, 20 };
      Console.WriteLine("New number of shares owned are:");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are:");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [03] buys 60 shares " +
        "of team [0]");
      costTrans = CostOfTrans(outstanding, 0, 60, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 80, 20 };
      Console.WriteLine("New number of shares owned are:");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are: ");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [01] sells 10 shares " +
        "of team [0]");
      costTrans = CostOfTrans(outstanding, 0, -10, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 70, 20 };
      Console.WriteLine("New number of shares owned are:");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      Console.WriteLine("Update: Market Closed");
      Console.WriteLine("\nEnd prediction market demo \n");
      Console.ReadLine();
    } // Main()
    static double[]Probabilities(int[] outstanding,
      double liq)
    {
      double[] result = new double[2];
      double denom = 0.0;
      for (int i = 0; i < 2; ++i)
        denom += Math.Exp(outstanding[i] / liq);
      for (int i = 0; i < 2; ++i)
        result[i] = Math.Exp(outstanding[i] / liq) / denom;
      return result;
    }
    static double Cost(int[] outstanding, double liq)
    {
      double sum = 0.0;
      for (int i = 0; i < 2; ++i)
        sum += Math.Exp(outstanding[i] / liq);
      return liq * Math.Log(sum);
    }
    static double CostOfTrans(int[] outstanding, int idx,
      int nShares, double liq)
    {
      int[] after = new int[2];
      Array.Copy(outstanding, after, 2);
      after[idx] += nShares;
      return Cost(after, liq) - Cost(outstanding, liq);
    }
    static double[] CostForOneShare(int[] outstanding,
      double liq)
    {
      double[] result = new double[2];
      result[0] = CostOfTrans(outstanding, 0, 1, liq);
      result[1] = CostOfTrans(outstanding, 1, 1, liq);
      return result;
    }
    static void ShowVector(double[] vector, int dec, string pre)
    {
      for (int i = 0; i < vector.Length; ++i)
        Console.Write(pre + vector[i].ToString("F" + dec) + " ");
      Console.WriteLine("\n");
    }
    static void ShowVector(int[] vector)
    {
      for (int i = 0; i < vector.Length; ++i)
        Console.Write(vector[i] + " ");
      Console.WriteLine("\n");
    }
  } // Program class
} // ns

Nach Anzeigen einiger einleitenden Meldungen beginnt die Programmausführung in der Methode „Main“ mit:

double liq = 100.0;
int[] outstanding = new int[] { 0, 0 };
ShowVector(outstanding);

Die Variable „liq“ ist der Liquiditätsparameter. Der Wert 100,0 ist typisch. Doch wenn Sie mit der Anpassung des Werts experimentieren, erkennen Sie, wie sich dies auf die Änderung des Anteilspreises nach einer Transaktion auswirkt. Höhere Liquiditätswerte sorgen für kleinere Änderungen. Das Array namens „outstanding“ enthält die Gesamtanzahl der Anteile im Besitz aller Experten für jedes der beiden Teams. Beachten Sie, dass der Liquiditätsparameter an die vier statischen Prognosemarktmethoden übergeben werden muss. Ein alternativer Entwurf ist das Kapseln der Methoden in einer C#-Klasse und Definieren von Liquidität als Memberfeld.

Als Nächstes wird die Anzahl verbleibender Anteile zum Bestimmen der gefolgerten Wahrscheinlichkeit des Siegs der beiden Teams verwendet:

double[] probs = Probabilities(outstanding, liq);
Console.WriteLine("Initial probabilities of winning:");
ShowVector(probs, 4, " ");

Danach zeigt die Demo die Kosten des Kaufs eines einzelnen Anteils an jedem der beiden Teams:

double[] costPerShare = CostForOneShare(outstanding, liq);
Console.WriteLine("Current costs for one share are: ");
ShowVector(costPerShare, 4, " $");

Bei einem realistischen Prognosemarkt ist diese Informationen für die Marktexperten hilfreich beim Beurteilen, ob der Anteilspreis eines Teams in Bezug auf die wahrgenommene Siegchance des jeweiligen Teams durch den Experten zu hoch oder zu niedrig ist.

Das Demoprogramm simuliert einen der Experten, der einige Anteile kauft, wie folgt:

Console.WriteLine("Update: expert [01] buys 20 shares of team [0]");
double costTrans = CostOfTrans(outstanding, 0, 20, liq);
Console.WriteLine("Cost of transaction to expert was: $" +
  costTrans.ToString("F2"));

Bei einem echten Prognosemarkt muss das System verschiedene Informationen zum Kontostand von Experten und zur Anzahl der Anteile in deren Besitz speichern.

Im Anschluss wird die Anzahl verbleibender Anteile wie folgt aktualisiert:

outstanding = new int[] { 20, 0 };
Console.WriteLine("New number of shares owned on teams [0] " +
  "and [1] are: ");
ShowVector(outstanding);

Wenn Sie sich nochmals die mathematischen Gleichungen in Abbildung 2 ansehen, werden Sie feststellen, dass die Anzahl verbleibender Anteile für jedes Team bzw. jede Option (x, y) von allen Gleichungen benötigt wird.

Nachdem die Anzahl verbleibender Anteile aktualisiert wurde, dient diese Information zum Schätzen der revidierten Wahrscheinlichkeiten der Siegchance der Teams bzw. Optionen:

probs = Probabilities(outstanding, liq);
Console.WriteLine("New inferred probabilities of
  winning are: ");
ShowVector(probs, 4, " ");

Wie Sie sich erinnern, sind diese Werte tatsächlich Grenzpreise. Es ist jedoch hilfreich, sie sich als Wahrscheinlichkeiten vorzustellen. Schlussendlich ist das Ziel des Prognosemarkts das Bestimmen der Wahrscheinlichkeit des Sieges des jeweiligen Teams bzw. der jeweiligen Option. Sie suchen also die finale Menge von Wahrscheinlichkeiten, nachdem sich der Markt stabilisiert hat.

Das Demoprogramm schließt, indem die folgenden fünf Vorgänge noch dreimal wiederholt werden:

• Anzeigen der aktuellen Kosten eines Anteils jedes Teams
• Durchführen einer Kauf- oder Verkaufstransaktion
• Anzeigen der Kosten der Transaktion
• Aktualisieren der Gesamtanzahl verbleibender Anteile
• Aktualisieren der Wahrscheinlichkeit des Siegs jedes Teams

Beachten Sie, dass im Demoprogramm die Siegwahrscheinlichkeit beider Teams gleich ist. Dies ist in vielen realen Prognosemarktszenarien nicht realistisch. Es ist möglich, einen Prognosemarkt mit ungleichen Wahrscheinlichkeiten zu initialisieren, indem in den Gleichungen 3 und 4 nach x und y aufgelöst wird.

Zusammenfassung

Die Informationen in diesem Artikel basieren auf der Forschungsarbeit „Logarithmic Market Scoring Rules for Modular Combinatorial Information Aggregation“ von Robin Hanson aus dem Jahr 2002. Eine PDF-Version dieser Arbeit ist über die Suchmaschine Ihrer Wahl an mehreren Stellen im Internet zu finden.

Prognosemärkte sind mehr als bloß eine abstrakte theoretische Idee. In den letzten Jahren wurden mehrere Unternehmen gegründet, die Prognosemärkte tatsächlich gewinnbringend auf den Markt gebracht haben.

Besonders aktiv geforscht wird in einem Bereich, der als „kombinatorische Prognosemärkte“ bezeichnet wird. Anstatt nur eine von zwei Siegchancen auszuwählen, können Experten Anteile in kombinierter Form erwerben. Beispiel: Team A besiegt Team B, und Team J besiegt Team K. Kombinatorische Prognosemärkte sind wesentlich komplexer als einfache Märkte.

Dr. James McCaffrey ist in Redmond (Washington) für Microsoft Research tätig. Er hat an verschiedenen Microsoft-Produkten mitgearbeitet, unter anderem an Internet Explorer und Bing. Dr. McCaffrey erreichen Sie unter jammc@microsoft.com.

Unser Dank gilt den folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Pallavi Choudhury, Gaz Iqbal, Umesh Madan und Tien Suwandy