constraint

type Coeff [6]uint64

type CoeffEngine interface {
	FromInterface(interface{}) Coeff
	ToBigInt(*Coeff) *big.Int
	Mul(a, b *Coeff)
	Add(a, b *Coeff)
	Sub(a, b *Coeff)
	Neg(a *Coeff)
	Inverse(a *Coeff)
	One() Coeff
	IsOne(*Coeff) bool
	String(*Coeff) string
}

type Commitment struct {
	Committed              []int // sorted list of id's of committed variables
	NbPrivateCommitted     int
	HintID                 hint.ID // TODO @gbotrel we probably don't need that here
	CommitmentIndex        int
	CommittedAndCommitment []int // sorted list of id's of committed variables AND the commitment itself
}

type ConstraintSystem interface {
	io.WriterTo
	io.ReaderFrom
	CoeffEngine

	// IsSolved returns nil if given witness solves the constraint system and error otherwise
	IsSolved(witness witness.Witness, opts ...backend.ProverOption) error

	// GetNbVariables return number of internal, secret and public Variables
	// Deprecated: use GetNbSecretVariables() instead
	GetNbVariables() (internal, secret, public int)

	GetNbInternalVariables() int
	GetNbSecretVariables() int
	GetNbPublicVariables() int

	GetNbConstraints() int
	GetNbCoefficients() int

	Field() *big.Int
	FieldBitLen() int

	AddPublicVariable(name string) int
	AddSecretVariable(name string) int
	AddInternalVariable() int

	// AddSolverHint adds a hint to the solver such that the output variables will be computed
	// using a call to output := f(input...) at solve time.
	AddSolverHint(f hint.Function, input []LinearExpression, nbOutput int) (internalVariables []int, err error)

	AddCommitment(c Commitment) error

	AddLog(l LogEntry)

	// MakeTerm returns a new Term. The constraint system may store coefficients in a map, so
	// calls to this function will grow the memory usage of the constraint system.
	MakeTerm(coeff *Coeff, variableID int) Term

	NewDebugInfo(errName string, i ...interface{}) DebugInfo

	// AttachDebugInfo enables attaching debug information to multiple constraints.
	// This is more efficient than using the AddConstraint(.., debugInfo) since it will store the
	// debug information only once.
	AttachDebugInfo(debugInfo DebugInfo, constraintID []int)

	// CheckUnconstrainedWires returns and error if the constraint system has wires that are not uniquely constrained.
	// This is experimental.
	CheckUnconstrainedWires() error
}

type DebugInfo LogEntry

type Hint struct {
	ID     hint.ID            // hint function id
	Inputs []LinearExpression // terms to inject in the hint function
	Wires  []int              // IDs of wires the hint outputs map to
}

type Iterable interface {
	// WireIterator returns a new iterator to iterate over the wires of the implementer (usually, a constraint)
	// Call to next() returns the next wireID of the Iterable object and -1 when iteration is over.
	//
	// For example a R1C constraint with L, R, O linear expressions, each of size 2, calling several times
	// 		next := r1c.WireIterator();
	// 		for wID := next(); wID != -1; wID = next() {}
	//		// will return in order L[0],L[1],R[0],R[1],O[0],O[1],-1
	WireIterator() (next func() int)
}

type LinearExpression []Term

type LogEntry struct {
	Caller    string
	Format    string
	ToResolve []LinearExpression // TODO @gbotrel we could store here a struct with a flag that says if we expand or evaluate the expression
	Stack     []int
}

type R1C struct {
	L, R, O LinearExpression
}

type R1CS interface {
	ConstraintSystem

	// AddConstraint adds a constraint to the system and returns its id
	// This does not check for validity of the constraint.
	// If a debugInfo parameter is provided, it will be appended to the debug info structure
	// and will grow the memory usage of the constraint system.
	AddConstraint(r1c R1C, debugInfo ...DebugInfo) int

	// GetConstraints return the list of R1C and a helper for pretty printing.
	// See StringBuilder for more info.
	// ! this is an experimental API.
	GetConstraints() ([]R1C, Resolver)
}

type R1CSCore struct {
	System
	Constraints []R1C
}

type Resolver interface {
	CoeffToString(coeffID int) string
	VariableToString(variableID int) string
}

type SparseR1C struct {
	L, R, O Term
	M       [2]Term
	K       int // stores only the ID of the constant term that is used
}

type SparseR1CS interface {
	ConstraintSystem

	// AddConstraint adds a constraint to the sytem and returns its id
	// This does not check for validity of the constraint.
	// If a debugInfo parameter is provided, it will be appended to the debug info structure
	// and will grow the memory usage of the constraint system.
	AddConstraint(c SparseR1C, debugInfo ...DebugInfo) int

	// GetConstraints return the list of SparseR1C and a helper for pretty printing.
	// See StringBuilder for more info.
	// ! this is an experimental API.
	GetConstraints() ([]SparseR1C, Resolver)
}

type SparseR1CSCore struct {
	System
	Constraints []SparseR1C
}

type StringBuilder struct {
	strings.Builder
	Resolver
}

type System struct {
	// serialization header
	GnarkVersion string
	ScalarField  string

	// number of internal wires
	NbInternalVariables int

	// input wires names
	Public, Secret []string

	// logs (added with system.Println, resolved when solver sets a value to a wire)
	Logs []LogEntry

	// debug info contains stack trace (including line number) of a call to a system.API that
	// results in an unsolved constraint
	DebugInfo   []LogEntry
	SymbolTable debug.SymbolTable
	// maps constraint id to debugInfo id
	// several constraints may point to the same debug info
	MDebug map[int]int

	MHints             map[int]*Hint      // maps wireID to hint
	MHintsDependencies map[hint.ID]string // maps hintID to hint string identifier

	// each level contains independent constraints and can be parallelized
	// it is guaranteed that all dependencies for constraints in a level l are solved
	// in previous levels
	// TODO @gbotrel these are currently updated after we add a constraint.
	// but in case the object is built from a serialized representation
	// we need to init the level builder lbWireLevel from the existing constraints.
	Levels [][]int

	CommitmentInfo Commitment
	// contains filtered or unexported fields
}

type Term struct {
	CID, VID uint32
}