sumcheck

Documentation

Index

• func Verify(claims LazyClaims, proof Proof, transcriptSettings fiatshamir.Settings) error
• type Claims
• type LazyClaims
• type Proof
  • func Prove(claims Claims, transcriptSettings fiatshamir.Settings) (Proof, error)

Functions

func Verify

func Verify(claims LazyClaims, proof Proof, transcriptSettings fiatshamir.Settings) error

Types

type Claims

type Claims interface {
	Combine(a small_rational.SmallRational) polynomial.Polynomial // Combine into the 0ᵗʰ sumcheck subclaim. Create g := ∑_{1≤j≤m} aʲ⁻¹fⱼ for which now we seek to prove ∑_{0≤i<2ⁿ} g(i) = c := ∑_{1≤j≤m} aʲ⁻¹cⱼ. Return g₁.
	Next(small_rational.SmallRational) polynomial.Polynomial      // Return the evaluations gⱼ(k) for 1 ≤ k < degⱼ(g). Update the claim to gⱼ₊₁ for the input value as rⱼ
	VarsNum() int                                                 //number of variables
	ClaimsNum() int                                               //number of claims
	ProveFinalEval(r []small_rational.SmallRational) interface{}  //in case it is difficult for the verifier to compute g(r₁, ..., rₙ) on its own, the prover can provide the value and a proof
}

Claims to a multi-sumcheck statement. i.e. one of the form ∑_{0≤i<2ⁿ} fⱼ(i) = cⱼ for 1 ≤ j ≤ m. Later evolving into a claim of the form gⱼ = ∑_{0≤i<2ⁿ⁻ʲ} g(r₁, r₂, ..., rⱼ₋₁, Xⱼ, i...)

type LazyClaims

type LazyClaims interface {
	ClaimsNum() int                                                          // ClaimsNum = m
	VarsNum() int                                                            // VarsNum = n
	CombinedSum(a small_rational.SmallRational) small_rational.SmallRational // CombinedSum returns c = ∑_{1≤j≤m} aʲ⁻¹cⱼ
	Degree(i int) int                                                        //Degree of the total claim in the i'th variable
	VerifyFinalEval(r []small_rational.SmallRational, combinationCoeff small_rational.SmallRational, purportedValue small_rational.SmallRational, proof interface{}) error
}

LazyClaims is the Claims data structure on the verifier side. It is "lazy" in that it has to compute fewer things.

type Proof

type Proof struct {
	PartialSumPolys []polynomial.Polynomial `json:"partialSumPolys"`
	FinalEvalProof  interface{}             `json:"finalEvalProof"` //in case it is difficult for the verifier to compute g(r₁, ..., rₙ) on its own, the prover can provide the value and a proof
}

Proof of a multi-sumcheck statement.

func Prove

func Prove(claims Claims, transcriptSettings fiatshamir.Settings) (Proof, error)

Prove create a non-interactive sumcheck proof