cabal-version:      2.4
name:               halo2
version:            0.1.0.0
synopsis:           Playing with Halo-y things.
-- description:
homepage:           https://nest.pijul.com/sellout/crypto-junk
bug-reports:        https://nest.pijul.com/sellout/crypto-junk/discussions
license:            AGPL-3.0-or-later
author:             Greg Pfeil
maintainer:         greg@technomadic.org
copyright:          2022 Greg Pfeil
category:           Cryptography
extra-source-files: CHANGELOG.md
library
    exposed-modules:  PLONKish
    ghc-options:     -Weverything
    build-depends:    base
                    , containers
                    , fin
                    , vec
    default-language: Haskell2010

        NoImplicitPrelude,

        Safe,

module Halo2.PLONKish

module PLONKish

import Control.Applicative (Applicative (..))
import Control.Category (Category(..))

import Data.Either.Combinators (maybeToLeft)

import Data.Eq (Eq (..))

import Data.Foldable (toList)

import Data.Foldable (Foldable (..))
import Data.Functor (Functor (..))

import Data.Maybe (catMaybes)

import Data.Maybe (Maybe (..), catMaybes, maybe)
import Data.Ord (Ord (..))

import Data.Semigroup (Sum (..))

import Data.Semigroup (Semigroup (..), Sum (..))

import Data.Traversable (Traversable)
import Data.Tuple qualified as Tuple

import Prelude (Bool, Either (..), Integer, Num (..), Show (..), flip, ($))

  maybeToLeft
    ( circuit {

  maybe
    ( pure $ circuit {

    Left

      if checkEqualityColumn config (fst x)

      if checkEqualityColumn config (Tuple.fst x)

          Just . IllegalEqualityColumn (fst x) $

          Just . IllegalEqualityColumn (Tuple.fst x) $

-- | This builds an elliptic curve from the two coefficients, returning a
--   function that, given the x component of a point will return the positive y
--   component. The negative component can be found via point inversion.
ellipticCurve :: Field f => f -> f -> f -> f
ellipticCurve a b x = sqrt $ x ** 3 + a * x + b

-- -- | This builds an elliptic curve from the two coefficients, returning a
-- --   function that, given the x component of a point will return the positive y
-- --   component. The negative component can be found via point inversion.
-- ellipticCurve :: Field f => f -> f -> f -> f
-- ellipticCurve a b x = sqrt $ x ** 3 + a * x + b

type F_101 = ()

-- type F_101 = ()

meh :: F_101 -> F_101
meh = ellipticCurve 0 3

-- meh :: F_101 -> F_101
-- meh = ellipticCurve 0 3

type ProvingKey = ()

-- type ProvingKey = ()

type VerificationKey = ()

-- type VerificationKey = ()

generateProvingKey :: Circuit f c r mcd -> ProvingKey
generateProvingKey = _

-- generateProvingKey :: Circuit f c r mcd -> ProvingKey
-- generateProvingKey = _

generateVerificationKey :: Circuit f c r mcd -> VerificationKey
generateVerificationKey = _

-- generateVerificationKey :: Circuit f c r mcd -> VerificationKey
-- generateVerificationKey = _

packages:
  ./halo2/halo2.cabal

# Crypto(graphy) Junk
Various packages playing with different crypto primitives, schemes, etc. in Haskell.
Probably none of it works. Mostly meant to look pretty.
If you do manage to depend on one of these packages, the modules are meant to be used with [package-qualified imports](https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/package_qualified_imports.html?highlight=package%20qualified). E.g.,
```haskell
{-# language PackageImports #-}
import "halo2" PLONKish.hs
```