{-# LANGUAGE OverloadedLists  #-}
{-# LANGUAGE TypeApplications #-}

module ZkFold.Base.Protocol.ARK.Plonk.Internal where

import           Control.Monad                                (guard)
import           Data.Bifunctor                               (first)
import           Data.Bool                                    (bool)
import           Data.Containers.ListUtils                    (nubOrd)
import           Data.List                                    (find, permutations, sort, transpose)
import           Data.Map                                     (Map, elems, empty)
import           Data.Maybe                                   (mapMaybe)
import qualified Data.Vector                                  as V
import           GHC.IsList                                   (IsList (..))
import           Numeric.Natural                              (Natural)
import           Prelude                                      hiding (Num (..), drop, length, sum, take, (!!), (/), (^))
import           System.Random                                (RandomGen, mkStdGen, uniformR)

import           ZkFold.Base.Algebra.Basic.Class
import           ZkFold.Base.Algebra.Basic.Field              (fromZp)
import           ZkFold.Base.Algebra.Basic.Number             (KnownNat)
import           ZkFold.Base.Algebra.EllipticCurve.BLS12_381  (BLS12_381_G1, BLS12_381_G2)
import           ZkFold.Base.Algebra.EllipticCurve.Class
import           ZkFold.Base.Algebra.Polynomials.Multivariate (Polynomial', evalMapM, evalPolynomial, mapVar,
                                                               polynomial, var, variables)
import           ZkFold.Base.Algebra.Polynomials.Univariate   (PolyVec, toPolyVec)
import           ZkFold.Base.Data.Vector
import           ZkFold.Prelude                               (length, take)
import           ZkFold.Symbolic.Compiler

type F = ScalarField BLS12_381_G1
type G1 = Point BLS12_381_G1
type G2 = Point BLS12_381_G2

-- TODO (Issue #15): safer code and better tests for this module

getParams :: Natural -> (F, F, F)
getParams :: Natural -> (F, F, F)
getParams Natural
l = StdGen -> (F, F, F)
forall g. RandomGen g => g -> (F, F, F)
findK' (StdGen -> (F, F, F)) -> StdGen -> (F, F, F)
forall a b. (a -> b) -> a -> b
$ Int -> StdGen
mkStdGen Int
0
    where
        omega :: Fr
omega = case Natural -> Maybe Fr
forall a. Field a => Natural -> Maybe a
rootOfUnity Natural
l of
                  Just Fr
o -> Fr
o
                  Maybe Fr
_      -> [Char] -> Fr
forall a. HasCallStack => [Char] -> a
error [Char]
"impossible"
        hGroup :: [Fr]
hGroup = (Natural -> Fr) -> [Natural] -> [Fr]
forall a b. (a -> b) -> [a] -> [b]
map (Fr
omegaFr -> Natural -> Fr
forall a b. Exponent a b => a -> b -> a
^) [Natural
Item [Natural]
1 .. Natural
2Natural -> Natural -> Natural
forall a b. Exponent a b => a -> b -> a
^Natural
lNatural -> Natural -> Natural
-!Natural
1]
        hGroup' :: Fr -> [Fr]
hGroup' Fr
k = (Fr -> Fr) -> [Fr] -> [Fr]
forall a b. (a -> b) -> [a] -> [b]
map (Fr
kFr -> Fr -> Fr
forall a. MultiplicativeSemigroup a => a -> a -> a
*) [Fr]
hGroup

        findK' :: RandomGen g => g -> (F, F, F)
        findK' :: forall g. RandomGen g => g -> (F, F, F)
findK' g
g =
            let (Fr
k1, g
g') = (Natural -> Fr) -> (Natural, g) -> (Fr, g)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: Type -> Type -> Type) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Natural -> Fr
forall a b. FromConstant a b => a -> b
fromConstant ((Natural, g) -> (Fr, g)) -> (Natural, g) -> (Fr, g)
forall a b. (a -> b) -> a -> b
$ (Natural, Natural) -> g -> (Natural, g)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
uniformR (Natural
1, forall a. Finite a => Natural
order @F Natural -> Natural -> Natural
-! Natural
1) g
g
                (Fr
k2, g
g'') = (Natural -> Fr) -> (Natural, g) -> (Fr, g)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: Type -> Type -> Type) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Natural -> Fr
forall a b. FromConstant a b => a -> b
fromConstant ((Natural, g) -> (Fr, g)) -> (Natural, g) -> (Fr, g)
forall a b. (a -> b) -> a -> b
$ (Natural, Natural) -> g -> (Natural, g)
forall g a. (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g)
uniformR (Natural
1, forall a. Finite a => Natural
order @F Natural -> Natural -> Natural
-! Natural
1) g
g'
            in (F, F, F) -> (F, F, F) -> Bool -> (F, F, F)
forall a. a -> a -> Bool -> a
bool (g -> (F, F, F)
forall g. RandomGen g => g -> (F, F, F)
findK' g
g'') (F
Fr
omega, F
Fr
k1, F
Fr
k2) (Bool -> (F, F, F)) -> Bool -> (F, F, F)
forall a b. (a -> b) -> a -> b
$
                (Fr -> Bool) -> [Fr] -> Bool
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Bool
all (Fr -> [Fr] -> Bool
forall (t :: Type -> Type) a.
(Foldable t, Eq a) =>
a -> t a -> Bool
`notElem` [Fr]
hGroup) (Fr -> [Fr]
hGroup' Fr
k1)
                Bool -> Bool -> Bool
&& (Fr -> Bool) -> [Fr] -> Bool
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Bool
all (Fr -> [Fr] -> Bool
forall (t :: Type -> Type) a.
(Foldable t, Eq a) =>
a -> t a -> Bool
`notElem` Fr -> [Fr]
hGroup' Fr
k1) (Fr -> [Fr]
hGroup' Fr
k2)

toPlonkConstraint :: Polynomial' F -> (F, F, F, F, F, F, F, F)
toPlonkConstraint :: Polynomial' F -> (F, F, F, F, F, F, F, F)
toPlonkConstraint Polynomial' F
p =
    let xs :: [Item (Set Natural)]
xs    = Set Natural -> [Item (Set Natural)]
forall l. IsList l => l -> [Item l]
toList (Set Natural -> [Item (Set Natural)])
-> Set Natural -> [Item (Set Natural)]
forall a b. (a -> b) -> a -> b
$ Polynomial' Fr -> Set Natural
forall c. MultiplicativeMonoid c => Polynomial' c -> Set Natural
variables Polynomial' F
Polynomial' Fr
p
        i :: Natural
i     = forall a. Finite a => Natural
order @F
        perms :: [[Natural]]
perms = [[Natural]] -> [[Natural]]
forall a. Ord a => [a] -> [a]
nubOrd ([[Natural]] -> [[Natural]]) -> [[Natural]] -> [[Natural]]
forall a b. (a -> b) -> a -> b
$ ([Natural] -> [Natural]) -> [[Natural]] -> [[Natural]]
forall a b. (a -> b) -> [a] -> [b]
map (Natural -> [Natural] -> [Natural]
forall a. Natural -> [a] -> [a]
take Natural
3) ([[Natural]] -> [[Natural]]) -> [[Natural]] -> [[Natural]]
forall a b. (a -> b) -> a -> b
$ [Natural] -> [[Natural]]
forall a. [a] -> [[a]]
permutations ([Natural] -> [[Natural]]) -> [Natural] -> [[Natural]]
forall a b. (a -> b) -> a -> b
$ case [Natural] -> Natural
forall (t :: Type -> Type) a. Foldable t => t a -> Natural
length [Natural]
[Item (Set Natural)]
xs of
            Natural
0 -> [Natural
Item [Natural]
i, Natural
Item [Natural]
i, Natural
Item [Natural]
i]
            Natural
1 -> [Natural
Item [Natural]
i, Natural
Item [Natural]
i, [Natural] -> Natural
forall a. HasCallStack => [a] -> a
head [Natural]
[Item (Set Natural)]
xs, [Natural] -> Natural
forall a. HasCallStack => [a] -> a
head [Natural]
[Item (Set Natural)]
xs]
            Natural
2 -> [Natural
Item [Natural]
i] [Natural] -> [Natural] -> [Natural]
forall a. [a] -> [a] -> [a]
++ [Natural]
[Item (Set Natural)]
xs [Natural] -> [Natural] -> [Natural]
forall a. [a] -> [a] -> [a]
++ [Natural]
[Item (Set Natural)]
xs
            Natural
_ -> [Natural]
[Item (Set Natural)]
xs [Natural] -> [Natural] -> [Natural]
forall a. [a] -> [a] -> [a]
++ [Natural]
[Item (Set Natural)]
xs

        getCoef :: Map Natural Natural -> F
        getCoef :: Map Natural Natural -> F
getCoef Map Natural Natural
m = case ((Fr, Map Natural Natural) -> Bool)
-> [(Fr, Map Natural Natural)] -> Maybe (Fr, Map Natural Natural)
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Maybe a
find (\(Fr
_, Map Natural Natural
as) -> Map Natural Natural
m Map Natural Natural -> Map Natural Natural -> Bool
forall a. Eq a => a -> a -> Bool
== Map Natural Natural
as) (Polynomial' Fr -> [Item (Polynomial' Fr)]
forall l. IsList l => l -> [Item l]
toList Polynomial' F
Polynomial' Fr
p) of
            Just (Fr
c, Map Natural Natural
_) -> F
Fr
c
            Maybe (Fr, Map Natural Natural)
_           -> F
Fr
forall a. AdditiveMonoid a => a
zero

        getCoefs :: [Natural] -> Maybe (F, F, F, F, F, F, F, F)
        getCoefs :: [Natural] -> Maybe (F, F, F, F, F, F, F, F)
getCoefs [Item [Natural]
a, Item [Natural]
b, Item [Natural]
c] = do
            let xa :: [(Natural, Natural)]
xa = [(Natural
Item [Natural]
a, Natural
1)]
                xb :: [(Natural, Natural)]
xb = [(Natural
Item [Natural]
b, Natural
1)]
                xc :: [(Natural, Natural)]
xc = [(Natural
Item [Natural]
c, Natural
1)]
                xaxb :: [(Natural, Natural)]
xaxb = [(Natural
Item [Natural]
a, Natural
1), (Natural
Item [Natural]
b, Natural
1)]

                ql :: F
ql = Map Natural Natural -> F
getCoef (Map Natural Natural -> F) -> Map Natural Natural -> F
forall a b. (a -> b) -> a -> b
$ [Item (Map Natural Natural)] -> Map Natural Natural
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (Map Natural Natural)]
xa
                qr :: F
qr = Map Natural Natural -> F
getCoef (Map Natural Natural -> F) -> Map Natural Natural -> F
forall a b. (a -> b) -> a -> b
$ [Item (Map Natural Natural)] -> Map Natural Natural
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (Map Natural Natural)]
xb
                qo :: F
qo = Map Natural Natural -> F
getCoef (Map Natural Natural -> F) -> Map Natural Natural -> F
forall a b. (a -> b) -> a -> b
$ [Item (Map Natural Natural)] -> Map Natural Natural
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (Map Natural Natural)]
xc
                qm :: F
qm = Map Natural Natural -> F
getCoef (Map Natural Natural -> F) -> Map Natural Natural -> F
forall a b. (a -> b) -> a -> b
$ [Item (Map Natural Natural)] -> Map Natural Natural
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (Map Natural Natural)]
xaxb
                qc :: F
qc = Map Natural Natural -> F
getCoef (Map Natural Natural -> F) -> Map Natural Natural -> F
forall a b. (a -> b) -> a -> b
$ Map Natural Natural
forall k a. Map k a
empty
            Bool -> Maybe ()
forall (f :: Type -> Type). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Polynomial' F
Polynomial' Fr
p Polynomial' Fr -> Polynomial' Fr -> Polynomial' Fr
forall a. AdditiveGroup a => a -> a -> a
- [(Fr, M Natural Natural (Map Natural Natural))] -> Polynomial' Fr
forall c i j.
Polynomial c i j =>
[(c, M i j (Map i j))] -> P c i j (Map i j) [(c, M i j (Map i j))]
polynomial [(F
Fr
ql, [Item (M Natural Natural (Map Natural Natural))]
-> M Natural Natural (Map Natural Natural)
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (M Natural Natural (Map Natural Natural))]
xa), (F
Fr
qr, [Item (M Natural Natural (Map Natural Natural))]
-> M Natural Natural (Map Natural Natural)
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (M Natural Natural (Map Natural Natural))]
xb), (F
Fr
qo, [Item (M Natural Natural (Map Natural Natural))]
-> M Natural Natural (Map Natural Natural)
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (M Natural Natural (Map Natural Natural))]
xc), (F
Fr
qm, [Item (M Natural Natural (Map Natural Natural))]
-> M Natural Natural (Map Natural Natural)
forall l. IsList l => [Item l] -> l
fromList [(Natural, Natural)]
[Item (M Natural Natural (Map Natural Natural))]
xaxb), (Fr
qc, M Natural Natural (Map Natural Natural)
forall a. MultiplicativeMonoid a => a
one)] Polynomial' Fr -> Polynomial' Fr -> Bool
forall a. Eq a => a -> a -> Bool
== Polynomial' Fr
forall a. AdditiveMonoid a => a
zero
            (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)
-> Maybe (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)
forall a. a -> Maybe a
forall (m :: Type -> Type) a. Monad m => a -> m a
return (F
Fr
ql, F
Fr
qr, F
Fr
qo, F
Fr
qm, Fr
qc, Natural -> Fr
forall a b. FromConstant a b => a -> b
fromConstant Natural
Item [Natural]
a, Natural -> Fr
forall a b. FromConstant a b => a -> b
fromConstant Natural
Item [Natural]
b, Natural -> Fr
forall a b. FromConstant a b => a -> b
fromConstant Natural
Item [Natural]
c)
        getCoefs [Natural]
_ = Maybe (F, F, F, F, F, F, F, F)
Maybe (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)
forall a. Maybe a
Nothing

    in [(F, F, F, F, F, F, F, F)] -> (F, F, F, F, F, F, F, F)
forall a. HasCallStack => [a] -> a
head ([(F, F, F, F, F, F, F, F)] -> (F, F, F, F, F, F, F, F))
-> [(F, F, F, F, F, F, F, F)] -> (F, F, F, F, F, F, F, F)
forall a b. (a -> b) -> a -> b
$ ([Natural] -> Maybe (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr))
-> [[Natural]] -> [(Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe [Natural] -> Maybe (F, F, F, F, F, F, F, F)
[Natural] -> Maybe (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)
getCoefs [[Natural]]
perms

fromPlonkConstraint :: (F, F, F, F, F, F, F, F) -> Polynomial' F
fromPlonkConstraint :: (F, F, F, F, F, F, F, F) -> Polynomial' F
fromPlonkConstraint (F
ql, F
qr, F
qo, F
qm, F
qc, F
a, F
b, F
c) =
    let xa :: M Natural Natural (Map Natural Natural)
xa = [(Fr -> Natural
forall (p :: Natural). Zp p -> Natural
fromZp F
Fr
a, Natural
1)]
        xb :: M Natural Natural (Map Natural Natural)
xb = [(Fr -> Natural
forall (p :: Natural). Zp p -> Natural
fromZp F
Fr
b, Natural
1)]
        xc :: M Natural Natural (Map Natural Natural)
xc = [(Fr -> Natural
forall (p :: Natural). Zp p -> Natural
fromZp F
Fr
c, Natural
1)]
        xaxb :: M Natural Natural (Map Natural Natural)
xaxb = [(Fr -> Natural
forall (p :: Natural). Zp p -> Natural
fromZp F
Fr
a, Natural
1), (Fr -> Natural
forall (p :: Natural). Zp p -> Natural
fromZp F
Fr
b, Natural
1)]

    in [(Fr, M Natural Natural (Map Natural Natural))] -> Polynomial' Fr
forall c i j.
Polynomial c i j =>
[(c, M i j (Map i j))] -> P c i j (Map i j) [(c, M i j (Map i j))]
polynomial [(F
Fr
ql, M Natural Natural (Map Natural Natural)
xa), (F
Fr
qr, M Natural Natural (Map Natural Natural)
xb), (F
Fr
qo, M Natural Natural (Map Natural Natural)
xc), (F
Fr
qm, M Natural Natural (Map Natural Natural)
xaxb), (F
Fr
qc, M Natural Natural (Map Natural Natural)
forall a. MultiplicativeMonoid a => a
one)]

addPublicInput :: Natural -> [Polynomial' F] -> [Polynomial' F]
addPublicInput :: Natural -> [Polynomial' F] -> [Polynomial' F]
addPublicInput Natural
i [Polynomial' F]
ps = Natural -> Polynomial' Fr
forall c i j.
Polynomial c i j =>
i -> P c i j (Map i j) [(c, M i j (Map i j))]
var Natural
i Polynomial' Fr -> [Polynomial' Fr] -> [Polynomial' Fr]
forall a. a -> [a] -> [a]
: [Polynomial' F]
[Polynomial' Fr]
ps

removeConstantVariable :: (Eq c, Field c, Scale c c, FromConstant c c) => Polynomial' c -> Polynomial' c
removeConstantVariable :: forall c.
(Eq c, Field c, Scale c c, FromConstant c c) =>
Polynomial' c -> Polynomial' c
removeConstantVariable = ((Natural -> Polynomial' c)
 -> M Natural Natural (Map Natural Natural) -> Polynomial' c)
-> (Natural -> Polynomial' c) -> Polynomial' c -> Polynomial' c
forall {k1} c i (j :: k1) b m.
Algebra c b =>
((i -> b) -> M i j m -> b)
-> (i -> b) -> P c i j m [(c, M i j m)] -> b
evalPolynomial (Natural -> Polynomial' c)
-> M Natural Natural (Map Natural Natural) -> Polynomial' c
forall i j b.
(MultiplicativeMonoid b, Exponent b j) =>
(i -> b) -> M i j (Map i j) -> b
evalMapM (\Natural
x -> if Natural
x Natural -> Natural -> Bool
forall a. Eq a => a -> a -> Bool
== Natural
0 then Polynomial' c
forall a. MultiplicativeMonoid a => a
one else Natural -> Polynomial' c
forall c i j.
Polynomial c i j =>
i -> P c i j (Map i j) [(c, M i j (Map i j))]
var Natural
x)

toPlonkArithmetization :: forall a n . KnownNat a => Vector n Natural -> ArithmeticCircuit F
    -> (PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a)
toPlonkArithmetization :: forall (a :: Natural) (n :: Natural).
KnownNat a =>
Vector n Natural
-> ArithmeticCircuit F
-> (PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a,
    PolyVec F a, PolyVec F a, PolyVec F a, PolyVec F a)
toPlonkArithmetization Vector n Natural
ord ArithmeticCircuit F
ac =
    let f :: (Item l, Item l, Item l, Item l, Item l, Item l, Item l, Item l)
-> l
f (Item l
x0, Item l
x1, Item l
x2, Item l
x3, Item l
x4, Item l
x5, Item l
x6, Item l
x7) = [Item l
x0, Item l
x1, Item l
x2, Item l
x3, Item l
x4, Item l
x5, Item l
x6, Item l
x7]
        vars :: [Natural]
vars   = [Natural] -> [Natural]
forall a. Ord a => [a] -> [a]
nubOrd ([Natural] -> [Natural]) -> [Natural] -> [Natural]
forall a b. (a -> b) -> a -> b
$ [Natural] -> [Natural]
forall a. Ord a => [a] -> [a]
sort ([Natural] -> [Natural]) -> [Natural] -> [Natural]
forall a b. (a -> b) -> a -> b
$ Natural
0 Natural -> [Natural] -> [Natural]
forall a. a -> [a] -> [a]
: (Polynomial' Fr -> [Natural]) -> [Polynomial' Fr] -> [Natural]
forall (t :: Type -> Type) a b.
Foldable t =>
(a -> [b]) -> t a -> [b]
concatMap (Set Natural -> [Natural]
Set Natural -> [Item (Set Natural)]
forall l. IsList l => l -> [Item l]
toList (Set Natural -> [Natural])
-> (Polynomial' Fr -> Set Natural) -> Polynomial' Fr -> [Natural]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Polynomial' Fr -> Set Natural
forall c. MultiplicativeMonoid c => Polynomial' c -> Set Natural
variables) (Map Natural (Polynomial' Fr) -> [Polynomial' Fr]
forall k a. Map k a -> [a]
elems (Map Natural (Polynomial' Fr) -> [Polynomial' Fr])
-> Map Natural (Polynomial' Fr) -> [Polynomial' Fr]
forall a b. (a -> b) -> a -> b
$ ArithmeticCircuit Fr -> Map Natural (Polynomial' Fr)
forall a. ArithmeticCircuit a -> Map Natural (Constraint a)
acSystem ArithmeticCircuit F
ArithmeticCircuit Fr
ac)
        ac' :: ArithmeticCircuit Fr
ac'    = ArithmeticCircuit Fr -> ArithmeticCircuit Fr
forall a.
MultiplicativeMonoid a =>
ArithmeticCircuit a -> ArithmeticCircuit a
mapVarArithmeticCircuit ArithmeticCircuit F
ArithmeticCircuit Fr
ac
        inputs :: Vector n Natural
inputs = (Natural -> Natural) -> Vector n Natural -> Vector n Natural
forall a b. (a -> b) -> Vector n a -> Vector n b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Natural] -> Natural -> Natural
mapVar [Natural]
vars) Vector n Natural
ord
        system :: [Polynomial' Fr]
system = (Natural -> [Polynomial' Fr] -> [Polynomial' Fr])
-> [Polynomial' Fr] -> Vector n Natural -> [Polynomial' Fr]
forall a b. (a -> b -> b) -> b -> Vector n a -> b
forall (t :: Type -> Type) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Natural -> [Polynomial' F] -> [Polynomial' F]
Natural -> [Polynomial' Fr] -> [Polynomial' Fr]
addPublicInput (Map Natural (Polynomial' Fr) -> [Polynomial' Fr]
forall k a. Map k a -> [a]
elems (Map Natural (Polynomial' Fr) -> [Polynomial' Fr])
-> Map Natural (Polynomial' Fr) -> [Polynomial' Fr]
forall a b. (a -> b) -> a -> b
$ ArithmeticCircuit Fr -> Map Natural (Polynomial' Fr)
forall a. ArithmeticCircuit a -> Map Natural (Constraint a)
acSystem ArithmeticCircuit Fr
ac') Vector n Natural
inputs

    in case ([Fr] -> PolyVec Fr a) -> [[Fr]] -> [PolyVec Fr a]
forall a b. (a -> b) -> [a] -> [b]
map (Vector Fr -> PolyVec Fr a
forall c (size :: Natural).
(Ring c, KnownNat size) =>
Vector c -> PolyVec c size
toPolyVec (Vector Fr -> PolyVec Fr a)
-> ([Fr] -> Vector Fr) -> [Fr] -> PolyVec Fr a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Fr] -> Vector Fr
forall a. [a] -> Vector a
V.fromList) ([[Fr]] -> [PolyVec Fr a]) -> [[Fr]] -> [PolyVec Fr a]
forall a b. (a -> b) -> a -> b
$ [[Fr]] -> [[Fr]]
forall a. [[a]] -> [[a]]
transpose ([[Fr]] -> [[Fr]]) -> [[Fr]] -> [[Fr]]
forall a b. (a -> b) -> a -> b
$ (Polynomial' Fr -> [Fr]) -> [Polynomial' Fr] -> [[Fr]]
forall a b. (a -> b) -> [a] -> [b]
map ((Item [Fr], Item [Fr], Item [Fr], Item [Fr], Item [Fr], Item [Fr],
 Item [Fr], Item [Fr])
-> [Fr]
(Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr) -> [Fr]
forall {l}.
IsList l =>
(Item l, Item l, Item l, Item l, Item l, Item l, Item l, Item l)
-> l
f ((Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr) -> [Fr])
-> (Polynomial' Fr -> (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr))
-> Polynomial' Fr
-> [Fr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Polynomial' F -> (F, F, F, F, F, F, F, F)
Polynomial' Fr -> (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)
toPlonkConstraint (Polynomial' Fr -> (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr))
-> (Polynomial' Fr -> Polynomial' Fr)
-> Polynomial' Fr
-> (Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Polynomial' Fr -> Polynomial' Fr
forall c.
(Eq c, Field c, Scale c c, FromConstant c c) =>
Polynomial' c -> Polynomial' c
removeConstantVariable) [Polynomial' Fr]
system of
            [Item [PolyVec Fr a]
ql, Item [PolyVec Fr a]
qr, Item [PolyVec Fr a]
qo, Item [PolyVec Fr a]
qm, Item [PolyVec Fr a]
qc, Item [PolyVec Fr a]
a, Item [PolyVec Fr a]
b, Item [PolyVec Fr a]
c] -> (Item [PolyVec Fr a]
PolyVec F a
ql, Item [PolyVec Fr a]
PolyVec F a
qr, Item [PolyVec Fr a]
PolyVec F a
qo, Item [PolyVec Fr a]
PolyVec F a
qm, Item [PolyVec Fr a]
PolyVec F a
qc, Item [PolyVec Fr a]
PolyVec F a
a, Item [PolyVec Fr a]
PolyVec F a
b, Item [PolyVec Fr a]
PolyVec F a
c)
            [PolyVec Fr a]
_                             -> [Char]
-> (PolyVec Fr a, PolyVec Fr a, PolyVec Fr a, PolyVec Fr a,
    PolyVec Fr a, PolyVec Fr a, PolyVec Fr a, PolyVec Fr a)
forall a. HasCallStack => [Char] -> a
error [Char]
"toPlonkArithmetization: something went wrong"