Bias inside of the media system is not something new, but recent forces have magnified the problem to a previously unimaginable state. Every major media distributor - from mainstream newspapers to cable new shows to the tech monopolists - routinely creates content with a biased agenda. Buzzwords like "misinformation", "disinformation" and "propaganda" are now so cliche that they nonchalantly blend into societal talk as if speaking about the weather.

     To the citizen who wants to receive unbiased information, this is a dire problem. There are no credibly neutral media systems because there are no real consequences for posting biased media. All the previous mechanisms to ensure neutrality have been gamed and are broken. None of these mechanisms provide real accountability between the media provider and media consumer. Advertiser pressure, reputational damage, shareholder votes, boycotts, comment systems, moderators, likes, upvotes, downvotes, suspensions, strikes, bans, etc. have all proved wanting. How can a citizen get unbiased media?

     The solution to the media bias problem is found through meaningful accountability between the creator and consumer. Whoever creates or posts or distributes content (hereafter referred to as the "Poster") needs to be held accountable for their posts. To solve the bias problem, we need to require the Poster to put up collateral that can be forfeit if the post is judged biased. The citizen who consumes the post is a judge who can vote whether the post is biased. In the end, the citizens' votes can determine whether the collateral is forfeit.

     To put up valuable collateral is termed staking. To forfeit valuable collateral is termed slashing. Staking and slashing can be viewed as opposite forces in quality control. The more confident the Poster is in the quality of the content, the higher (in general) should be the staked value. Content that is lower in quality should have more votes for slashing the collateral. Of course, there is game theory at play. Since the Poster stakes first, they must consider the odds that the voters will find the post biased and incorporate that into the initial staked value.

     In order to solve media bias, there needs to be a credibly neutral system that is transparent to both the Poster and the citizen-consumer. The rules need to be clearly stated in advance and should not change once the process has started. In the Appendix section below, the math/code for an open-source accountability algorithm is provided. Technical readers are directed to that section for more detailed information.

     The basic intuition behind the algorithm is simple: if very few citizens vote to slash, the Poster gets the collateral back at the resolution date. On the other hand, if a slashing threshold is met, the Poster forfeits the collateral. The mathematical key underpinning the algorithm is that neither the Poster nor the voters know the exact voting threshold which triggers the forfeit. In other words, the algorithm includes randomness to blind both the Poster and voters to the exact slash threshold. The exact threshold is only revealed at the resolution date. So Posters must stake and voters must slash without perfect information.

     To understand the algorithm better, let's describe a few of its key properties:

     The staked tokens are locked until the resolution date and can't be moved. Therefore, a Poster who stakes a larger amount of tokens is putting more value at risk of slashing. This indicates stronger confidence that the post is less likely to be slashed.

     There is a cost to voting on the post. If a voter spends tokens to slash a post, they are signaling disagreement with the post's content. Any spent tokens voted on a post, accrue to the Poster up to a Maximum. If a voter strongly agrees with a post, they can also spend tokens not to slash, which acts as a sort of tip to the Poster.

     Once the resolution date occurs, the votes to slash are compared to a Random Threshold (which was previously unknown to both the Poster and voters). If the votes are under the threshold, the staked tokens are returned to the Poster. Otherwise, the staked tokens are forfeit. Any tokens spent during voting still accrues to the Poster (up to a Maximum) so there is typically an offset from voting to the forfeit stake.

     The algorithm described above provides meaningful accountability between the Poster and the consumer of the post. Unlike with other mechanisms, citizens can directly hold each Poster accountable for each post through staking and slashing. If the Poster wants to signal to the citizens a strong belief in the quality of the content, they can stake a relatively larger amount of tokens.

     In order to ensure credible neutrality, the parameters and inputs to the algorithm need to be auditable and transparent. Both the Poster and the voters should be able to verify the process is fair and the rules have been followed. To achieve this, the current implementation of the algorithm uses the IOTA Tangle as a distributed ledger to store this data in encrypted form.

     At the time of posting, the specific values of the Random Threshold are encrypted, stored in the IOTA Tangle, and provided to both the Poster and voters. Each post includes a "VERIFY" button that contains this encrypted data. Similarly, each vote is recorded as encrypted data into the IOTA Tangle. This encrypted vote data is likewise given to the voter at the time of voting.

     Once the resolution date of the post has been reached, decryption keys are publicly revealed (available using the "VERIFY" button). Decrypting the data reveals the Random Threshold, votes, and other parameters of the algorithm. Both the Poster and voters can independently verify the original encrypted data decrypts to final values. The final values can then be entered into the algorithm to confirm the slashing result was accurate. For a more technical discussion of this verification process, see the Appendix below.

     No initial implementation is perfect. There are obvious ways that the current implementation can be improved, including but not limited to: 1) switching from a hide-and-reveal encryption scheme to a decentralized source of randomness delivered at the resolution date; 2) using different tokens as the source of value for slashing and staking; 3) moving the token value actions to a public ledger; 4) encoding the algorithm in a smart contract deployed to a distributed public ledger; 5) incorporating anti-sybil techniques to allow 1 vote per person or nonlinear voting schemes (such as quadratic voting); and 6) providing different user interfaces which display posts according to different intentions.

     The core algorithm is provided as MIT-Licensed open source software below. The current implementation includes various inputs and parameters defined below:

     let randomNumber(t) be a Random Number in the range of 0 to 1 at time t
     let stakeTokens be the Number of Staked Tokens in the range of 0 to 10000
     let tempMax = floor(randomNumber(t1) * (9000 - 500 + 1) + 500);
     let tempMin1 = floor(randomNumber(t2) * (100 - 1 + 1) + 1);
     let tempMin2 = floor(randomNumber(t3) * (10 - 5 + 1) + 5) / 100;
     let tempReject1 = floor(randomNumber(t4) * (5000 - 500 + 1) + 500);
     let tempReject2 = floor(randomNumber(t5) * (50 - 10 + 1) + 10) / 100;
     let maxResult = max(min(tempMax, 2 * stakeTokens),stakeTokens);
     let minResult = min(tempMin1, tempMin2 * stakeTokens);
     let rejectThresh = min(tempReject1, tempReject2 * stakeTokens);
     let acceptTokens be the Sum of all tokens voted to approve the post
     let rejectTokens be the Sum of all tokens voted to slash the post
     let postId be a Unique Identifier for each staked post
     let minVotes be a positive Number that represents the Minimum Number of votes before slashing
     let slashDate be a date a Random Number of days into the future
     let maxWithdrawRate be a Number in the range of 0 to 1 that is a Celody Decentralized Law

     At the slash date resolution, these inputs are entered into the open-source algorithm to determine whether the staked tokens are slashed. The algorithm also calculates how many tokens are ultimately returned to the staker. The open source algorithm is demonstrated using the javascript programming language.

  // M.I.T. LICENSE - FREE OPEN SOURCE SOFTWARE
  // ENTER DECRYPTED DATA INTO INPUT VARIABLES BELOW, THEN EXECUTE THE CODE
  // AFTER EXECUTION, VERIFICATION RESULT IS DISPLAYED LOGGED AS OUTPUT

  'use strict';
  let tempMax = 0; // input "m" from post decryption above
  let tempMin1 = 0; // input "m1" from post decryption above
  let tempMin2 = 0; // input "m2" from post decryption above
  let tempReject1 = 0; // input "r1" from post decryption above
  let tempReject2 = 0; // input "r2" from post decryption above
  let stakeTokens = 0; // input "s" from post decryption above
  let minVotes = 0; // input "v" from post decryption above
  let acceptTokens = 0; // input "v" from vote decryption above - sum of all votes with "t" of yes (judgeType of yes)
  let rejectTokens = 0; // input "v" from vote decryption above - sum of all votes with "t" of no (judgeType of no)
  let voteCount = 0; // the count of all vote submissions (both accept and reject)
  let maxWithdrawRate = 0; // max withdraw rate from verify panel on stakedy.com (celody decentralized voting law at time of slash date)
  console.log("FINAL RESULT",verifyStakedy()); // output of verification (tokens paid,slashed or not slashed)

  function verifyStakedy() {
    let maxTokens = Math.min(tempMax, 2 * Number(stakeTokens));
    let minTokens = Math.min(tempMin1, tempMin2 * Number(stakeTokens));
    let rejectThresh = Math.min(tempReject1, tempReject2 * Number(stakeTokens));
    let isAboveMin = "no";
    // check if the vote tokens sum is above the min
    if (Number(acceptTokens) + Number(rejectTokens) > Number(minTokens)) {
        isAboveMin = "yes";
    }
    // calculate the reject scale factor
    let rejectScaleFactor = 0;
    if ((!rejectTokens) || (Number(rejectTokens) === 0) || (!rejectThresh) || (Number(rejectThresh) === 0)) {
        rejectScaleFactor = 0;
    } else {
        if (Number(rejectTokens) < Number(rejectThresh)) {
            rejectScaleFactor = Number(rejectTokens) / Number(rejectThresh);
        } else {
            rejectScaleFactor = Number(rejectThresh) / Number(rejectTokens);
        }
    }
    // determine if slashed
    let checkResult = "no";
    if ((isAboveMin === "yes") && (Number(rejectTokens) > Number(rejectThresh))) {
        checkResult = "yes";
    } else {
        checkResult = "no";
    }
    // check if above max payments
    let isAboveMax = "no";
    if (Number(acceptTokens) + Number(rejectTokens) > Number(maxTokens)) {
        isAboveMax = "yes";
    }
    // calculate the gross token payment - excludes stake, uses scale factor
    let grossPayments = 0;
    if (isAboveMax === "no") {
        grossPayments = (Number(acceptTokens) + Number(rejectTokens)) * rejectScaleFactor;
    } else {
        grossPayments = Number(maxTokens) * rejectScaleFactor;
    }
    // check if above the withdraw limit
    let isAboveWithdraw = "no";
    if (Number(grossPayments) > Number(maxWithdrawRate) * (Number(acceptTokens) + Number(rejectTokens))) {
        isAboveWithdraw = "yes";
    }
    // if above the withdraw limit, cap the gross payments
    if (isAboveWithdraw === "yes") {
        grossPayments = Number(maxWithdrawRate) * (Number(acceptTokens) + Number(rejectTokens));
    }
    // calculate how many tokens to return to wallet (includes stake)
    let finalResult = 0;
    if (checkResult === "no") {            
        finalResult = Number(grossPayments) + Number(stakeTokens);        
    } else {
        finalResult = Number(grossPayments);        
    }
    // circuit guard for low votes
    if (voteCount < minVotes) {        
        checkResult = "no";
        finalResult = Number(stakeTokens);
    }
    finalResult = "TOKENS TO STAKER: " + finalResult + " | SLASHED: " + checkResult;
    return finalResult;
  }                    

     The current implementation uses a hide-and-reveal scheme, where several of the parameters and inputs are encrypted. For example, at the time of staking, the tempReject1 and tempReject2 variables are encrypted and published to a distributed ledger. These variables (now encrypted) are unknown to the Poster and voters. Similarly, whenever a vote occurs, an encrypted message of the spent tokens is recorded to a public ledger. It's only upon the resolution date, where a decryption key set becomes publicly available that the encrypted variables are revealed.

     In order for these encrypted strings to be decrypted into their final format, the following nodejs code is provided. The verifier need only to set the encrypted variable string and key set before executing the code.

  // M.I.T. LICENSE - FREE OPEN SOURCE SOFTWARE
  // ENTER ENCRYPTED DATA AND DECRYPTION KEYS INTO INPUT VARIABLES BELOW, THEN EXECUTE THE CODE USING NODEJS
  // AFTER EXECUTION, DECRYPTED DATA IS DISPLAYED LOGGED AS OUTPUT

  'use strict';
  const crypto = require('crypto');
  let algorithm = "aes-192-cbc"; // encryption algorithm to use
  let ENCRYPTED_DATA = ""; // input data from verify panel on stakedy.com
  let DECRYPTION_KEY1 = ""; // decrypt key1 from verify panel on stakedy.com
  let DECRYPTION_KEY2 = ""; // decrypt key2 from verify panel on stakedy.com
  console.log("FINAL DATA",decryptStakedy()); // output of decryption
  // CREATE POST STRUCTURE: "m-" + tempMax + "|m1-" + tempMin1 + "|m2-" + tempMin2 + "|r1-" + tempReject1 + "|r2-" + tempReject2 + "|s-" + stakeTokens + "|p-" + postId + "|v-" + minVotes + "|d-" + slashDate + "|" + randomPad
  // VOTE STRUCTURE: "v-" + voteTokens + "|t-" + judgeType + "|p-" + postId + "|" randomPad;

  function decryptStakedy() {
    let key2 = Buffer.from(DECRYPTION_KEY1, "hex"); // convert back to Buffer
    let iv2 = Buffer.from(DECRYPTION_KEY2, "hex"); // convert back to Buffer
    let decipher2 = crypto.createDecipheriv(algorithm, key2, iv2);
    let decrypted2 = decipher2.update(ENCRYPTED_DATA, 'hex', 'utf8') + decipher2.final('utf8'); // deciphered text    
    // from decrypted2 - parse the keyHex1 and ivHex1
    let encryptedText1 = decrypted2.substring(0,decrypted2.length - 48 - 32);
    let keyHex1 = decrypted2.substring(decrypted2.length - 48, decrypted2.length);
    let ivHex1 = decrypted2.substring(decrypted2.length - 48 - 32, decrypted2.length - 48);
    let key1 = Buffer.from(keyHex1, "hex"); // convert back to Buffer
    let iv1 = Buffer.from(ivHex1, "hex"); // convert back to Buffer
    let decipher1 = crypto.createDecipheriv(algorithm, key1, iv1);
    let decrypted1 = decipher1.update(encryptedText1, 'hex', 'utf8') + decipher1.final('utf8'); // deciphered text
    return decrypted1;
  }