add README

+import hashlib
+
+class PCProver:
+    def __init__(self, g=5, p=2333, s=15):
+        self.g = g
+        self.q = 2*p + 1
+        self.s = s
+        self.h = pow(g, s, self.q)
+    def commit(self, M, r):
+        m = int(hashlib.sha256(M.encode()).hexdigest() ,16)
+        c = pow(self.g, m, self.q) * pow(self.h, r, self.q) % self.q
+        return (Message(M, r), Commitment(c))
+    def getParams(self):
+        return PCParameters(self.q, self.g, self.h)
+
+class Message:
+    def __init__(self, M, r):
+        self.M = M
+        self.r = r
+    def __repr__(self):
+        return """M | {}
+r | {}""".format(self.M, self.r)
+
+class Commitment:
+    def __init__(self, c):
+        self.c = c
+    def __repr__(self):
+        return """c | {}""".format(self.c)
+
+class PCParameters:
+    def __init__(self, q, g, h):
+        self.q = q
+        self.g = g
+        self.h = h
+
+class PCVerifier:
+    def __init__(self, params):
+        self.c = []
+        self.m = []
+        self.r = []
+        self.q = params.q
+        self.g = params.g
+        self.h = params.h
+    def __repr__(self):
+        returnStr = """Commitments | {}
+Messages    | {}
+q           | {}
+g           | {}
+h           | {}""".format(len(self.c), len(self.m), self.q, self.g, self.h)
+        return returnStr
+    def add(self, dataObject):
+        if(type(dataObject) is Commitment):
+            self.c.append(dataObject.c)  
+        if(type(dataObject) is Message):
+            m = int(hashlib.sha256(dataObject.M.encode()).hexdigest() ,16)
+            self.m.append(m)
+            self.r.append(dataObject.r)
+    def productCommitments(self):
+        pi = 1
+        for ci in self.c:
+            pi *= ci
+        return pi % self.q
+    def verify(self):
+        c = self.productCommitments()
+        m_sum = 0
+        r_sum = 0
+        for i in range(len(self.m)):
+            m_sum += self.m[i]
+            r_sum += self.r[i]
+        cv = pow(self.g, m_sum, self.q) * pow(self.h, r_sum, self.q) % self.q
+        return c == cv
+

+# Pedersen Commitment
+Project includes python implementation of Pedersen Commitment Scheme.
+# How to use
+example.py contains code examples to perform the RAPPOR algorithm.
+### Creating Commitments
+```
+from PC import PCProver, PCVerifier
+```
+Initialise the parameters.
+```
+pc = PCProver(self, g=5, p=2333, s=15)
+params = pc.getParams()
+verifier = PCVerifier(params)
+```
+Create commitments with a message and random integer.
+```
+m1, c1 = pc.commit("Hello!", 7)
+m2, c2 = pc.commit("Goodbye!", 9)
+```
+Send the commitments first.
+```
+verifier.add(c1)
+verifier.add(c2)
+```
+When the prover wants to reveal messages, they can be sent to the verifier and finally confirms the messages.
+```
+verifier.add(m1)
+verifier.add(m2)
+print(verifier.verify())
+```
+# Parameters
+**Name** | **Description** | **Rules**
+| --- | --- | --- |
+g | Generator value. | Must be a positive integer between 1 and q - 1.
+p | Prime number that will produce q = 2p + 1. | Must be a prime.
+s | Secret value used to create h = g^s mod q. | Must be a positive integer between 1 and q - 1.
\ No newline at end of file

+from PC import PCProver, PCVerifier
+
+#Set up the params
+pc = PCProver()
+params = pc.getParams()
+verifier = PCVerifier(params)
+
+#Dictionary of messages and their respective "random" integers
+exchange = [{"M":"Hello!", "r":7}, 
+            {"M":"Goodbye!", "r":9}]
+
+commitments = []
+messages = []
+
+#Create commitments and keep the results
+for i in range(len(exchange)):
+    ex = exchange[i]
+    (m, c) = pc.commit(ex["M"], ex["r"])
+    commitments.append(c)
+    messages.append(m)
+
+#Send commitments to the verifier
+for c in commitments:
+    verifier.add(c)
+
+#Interim period before prover wants to reveal message
+
+#Send messages to the verifier
+for m in messages:
+    verifier.add(m)
+
+#Verifier computes the challenges with the messages and compares them with the commitments
+print(verifier.verify())