lol: A library for lattice cryptography.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.



The \Lambda \ocirc \lambda library supports operations for ring-based lattice cryptography.

[Skip to ReadMe]


Change logNone available
Dependenciesarithmoi (>= && <0.5), base (==4.8.*), constraints (==0.4.*), containers (>= && <0.6), data-default (>=0.3.0 && <0.6), deepseq (>= && <1.5), MonadRandom (>=0.2 && <0.5), mtl (>=2.2.1 && <2.3), numeric-prelude (>=0.4.2 && <0.5), QuickCheck (==2.8.*), random (==1.1.*), reflection (>=1.5.1 && <2.2), repa (==3.4.*), singletons (>= && <2.1), storable-record (>=0.0.3 && <0.1), storable-tuple (>=0.0.1 && <0.1), tagged-transformer (>=0.7 && <0.9), th-desugar (>=1.5.4 && <1.6), transformers (>= && <0.5), type-natural (>= && <0.4), vector (==0.11.*), vector-th-unbox (>= && <0.3) [details]
CopyrightEric Crockett, Chris Peikert
AuthorEric Crockett, Chris Peikert
MaintainerEric Crockett <>
Home page
Bug tracker
Source repositoryhead: git clone
UploadedFri Oct 30 23:44:53 UTC 2015 by crockeea





Use ICC instead of GCC to compile C backend.


Compile via LLVM. This produces much better object code, but you need to have the LLVM compiler installed.


Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info


Maintainers' corner

For package maintainers and hackage trustees

Readme for lol-

[back to package description]
Overview of key modules, roughly from highest- to lowest-level:

* SymmSHE.hs, an implementation of a symmetric-key,
  somewhat-homomorphic encryption scheme that is essentially
  equivalent to the one from the toolkit paper [LPR'13].

* Cyc.hs, which defines an interface for using cyclotomic fields, 
  rings R, and quotient rings Rq=R/qR; as well as many other
  commonly used operations, e.g., converting
  between rings, decoding and decomposing elements, modulus
  reduction/rounding, etc. etc. Cyc is a safe wrapper around the
  UCyc type, which exposes some representation-dependent operations.
  UCyc (and hence Cyc) is implemented using a generic Tensor (described below).

* Tensor.hs, which defines a class that encapsulates all the necessary
  linear transformations for operating on representations of R- and
  Rq-elements, e.g., the CRT transform, converting between the
  powerful and decoding bases, generating error terms, etc.

* RepaTensor.hs, which gives an
  implementation of the Tensor class based on the "repa"
  package, a highly optimized and parallelizable array library.

* CTensor.hs, which gives an
  implementation of the Tensor class using a C backend via Haskell's FFI.

* FiniteField.hs, which gives an unoptimized implementation of finite field
  arithmetic. To use this module, you will need an instance of IrreduciblePoly.
  These instances provide irreducible polynomials for various degrees and base fields.
  One instance is provided for characteristic 2 fields of size up to 2^32 in 

* ZqBasic.hs, which is a basic implementation of Zq=Z/qZ arithmetic.

* Factored.hs, which contains support code for "reifying"
  runtime-chosen integers as static types (mainly, the types q and m
  that are floating around as parameters of many other data types),
  and "reflecting" those types as integers back to the code.