func (cs *ConstraintSystem) LinearExpression(terms ...compiled.Term) compiled.LinearExpression {
	res := make(compiled.LinearExpression, len(terms))
	for i, args := range terms {
		res[i] = args
	}
	return res
}
LinearExpression packs a list of compiled.Term in a compiled.LinearExpression and returns it.
package frontend
import (
	"io"
	"math/big"
	"sort"
	"github.com/consensys/gnark-crypto/ecc"
	"github.com/consensys/gnark/backend/hint"
	"github.com/consensys/gnark/internal/backend/compiled"
)
type ConstraintSystem struct {
	public, secret, internal, virtual variables
	constraints []compiled.R1C
	coeffs    []big.Int       
	coeffsIDs map[string]int  
	mHints map[int]compiled.Hint  
	logs      []compiled.LogEntry  
	debugInfo []compiled.LogEntry  
	mDebug map[int]int  
}
type variables struct {
	variables []Variable
	booleans  map[int]struct{}  
}
func (v *variables) new(cs *ConstraintSystem, visibility compiled.Visibility) Variable {
	idx := len(v.variables)
	w := Wire{visibility, idx, nil}
	variable := cs.buildVarFromWire(w)
	v.variables = append(v.variables, variable)
	return variable
}
type CompiledConstraintSystem interface {
	io.WriterTo
	io.ReaderFrom
	GetNbVariables() (internal, secret, public int)
	GetNbConstraints() int
	GetNbCoefficients() int
	CurveID() ecc.ID
	FrSize() int
	ToHTML(w io.Writer) error
}
func newConstraintSystem(initialCapacity ...int) ConstraintSystem {
	capacity := 0
	if len(initialCapacity) > 0 {
		capacity = initialCapacity[0]
	}
	cs := ConstraintSystem{
		coeffs:      make([]big.Int, 4),
		coeffsIDs:   make(map[string]int),
		constraints: make([]compiled.R1C, 0, capacity),
		mDebug:      make(map[int]int),
		mHints:      make(map[int]compiled.Hint),
	}
	cs.coeffs[compiled.CoeffIdZero].SetInt64(0)
	cs.coeffs[compiled.CoeffIdOne].SetInt64(1)
	cs.coeffs[compiled.CoeffIdTwo].SetInt64(2)
	cs.coeffs[compiled.CoeffIdMinusOne].SetInt64(-1)
	cs.public.variables = make([]Variable, 0)
	cs.public.booleans = make(map[int]struct{})
	cs.secret.variables = make([]Variable, 0)
	cs.secret.booleans = make(map[int]struct{})
	cs.internal.variables = make([]Variable, 0, capacity)
	cs.internal.booleans = make(map[int]struct{})
	cs.virtual.variables = make([]Variable, 0)
	cs.virtual.booleans = make(map[int]struct{})
	cs.public.variables[0] = cs.newPublicVariable()
	return cs
}
func (cs *ConstraintSystem) NewHint(hintID hint.ID, inputs ...interface{}) Variable {
	r := cs.newInternalVariable()
	hintInputs := make([]compiled.LinearExpression, len(inputs))
	for i, in := range inputs {
		t := cs.Constant(in)
		hintInputs[i] = t.linExp.Clone()  
	}
	cs.mHints[r.id] = compiled.Hint{ID: hintID, Inputs: hintInputs}
	return r
}
func (cs *ConstraintSystem) one() Variable {
	return cs.public.variables[0]
}
func (cs *ConstraintSystem) makeTerm(v Wire, coeff *big.Int) compiled.Term {
	return compiled.Pack(v.id, cs.coeffID(coeff), v.visibility)
}
func newR1C(l, r, o Variable) compiled.R1C {
	if len(l.linExp) > len(r.linExp) {
		l, r = r, l
	}
	return compiled.R1C{L: l.linExp.Clone(), R: r.linExp.Clone(), O: o.linExp.Clone()}
}
func (cs *ConstraintSystem) NbConstraints() int {
	return len(cs.constraints)
}