-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | The Quantum IO Monad is a library for defining quantum computations in Haskell
--   
--   The Quantum IO Monad is a library for defining quantum computations in
--   Haskell
@package QIO
@version 1.0

module QIO.Vec
newtype Vec x a
Vec :: [(a, x)] -> Vec x a
unVec :: Vec x a -> [(a, x)]
empty :: Vec x a
(<@@>) :: (Num x, Eq a) => Vec x a -> a -> x
(<**>) :: (Num x) => x -> (Vec x a) -> Vec x a
(<++>) :: (Vec x a) -> (Vec x a) -> Vec x a
instance (Show x, Show a) => Show (Vec x a)
instance (Num n) => Monad (Vec n)

module QIO.QioSyn
type CC = Complex RR
amp :: CC -> RR
type RR = Float
newtype Qbit
Qbit :: Int -> Qbit
type Rotation = (Bool, Bool) -> CC
data U
UReturn :: U
Rot :: Qbit -> Rotation -> U -> U
Swap :: Qbit -> Qbit -> U -> U
Cond :: Qbit -> (Bool -> U) -> U -> U
Ulet :: Bool -> (Qbit -> U) -> U -> U
data QIO a
QReturn :: a -> QIO a
MkQbit :: Bool -> (Qbit -> QIO a) -> QIO a
ApplyU :: U -> (QIO a) -> QIO a
Meas :: Qbit -> (Bool -> QIO a) -> QIO a
rot :: Qbit -> Rotation -> U
swap :: Qbit -> Qbit -> U
cond :: Qbit -> (Bool -> U) -> U
ulet :: Bool -> (Qbit -> U) -> U
urev :: U -> U
unot :: Qbit -> U
uhad :: Qbit -> U
uphase :: Qbit -> RR -> U
mkQbit :: Bool -> QIO Qbit
applyU :: U -> QIO ()
measQbit :: Qbit -> QIO Bool
rid :: Rotation
rnot :: Rotation
rhad :: Rotation
rphase :: RR -> Rotation
rrev :: Rotation -> Rotation
show' :: U -> Int -> Int -> String
spaces :: Int -> String
instance Num Qbit
instance Enum Qbit
instance Eq Qbit
instance Ord Qbit
instance Show U
instance Show Rotation
instance Show Qbit
instance Eq Rotation
instance Monad QIO
instance Monoid U

module QIO.Qdata
class Qdata a qa | a -> qa, qa -> a
mkQ :: (Qdata a qa) => a -> QIO qa
measQ :: (Qdata a qa) => qa -> QIO a
letU :: (Qdata a qa) => a -> (qa -> U) -> U
condQ :: (Qdata a qa) => qa -> (a -> U) -> U
condQRec :: (Qdata a qa) => [qa] -> [(a -> U)] -> U
qIntSize :: Int
newtype QInt
QInt :: [Qbit] -> QInt
int2bits :: Int -> [Bool]
bits2int :: [Bool] -> Int
instance Show QInt
instance Qdata Int QInt
instance (Qdata a qa) => Qdata [a] [qa]
instance (Qdata a qa, Qdata b qb) => Qdata (a, b) (qa, qb)
instance Qdata Bool Qbit

module QIO.Heap
class (Eq h) => Heap h
initial :: (Heap h) => h
update :: (Heap h) => h -> Qbit -> Bool -> h
(?) :: (Heap h) => h -> Qbit -> Maybe Bool
forget :: (Heap h) => h -> Qbit -> h
hswap :: (Heap h) => h -> Qbit -> Qbit -> h
type HeapMap = Map Qbit Bool
instance Heap HeapMap

module QIO.QioClass
newtype UnitaryC
U :: (Int -> HeapMap -> HeapMap) -> UnitaryC
unU :: UnitaryC -> Int -> HeapMap -> HeapMap
uRotC :: Qbit -> Rotation -> UnitaryC
uSwapC :: Qbit -> Qbit -> UnitaryC
uCondC :: Qbit -> (Bool -> UnitaryC) -> UnitaryC
uLetC :: Bool -> (Qbit -> UnitaryC) -> UnitaryC
runUC :: U -> UnitaryC
data StateC
StateC :: Int -> HeapMap -> StateC
fv :: StateC -> Int
heap :: StateC -> HeapMap
initialStateC :: StateC
runQStateC :: QIO a -> State StateC a
runC :: QIO a -> a
instance Monoid UnitaryC

module QIO.VecEq
class VecEq v
vzero :: (VecEq v) => v x a
(<+>) :: (VecEq v, Eq a, Num x) => v x a -> v x a -> v x a
(<*>) :: (VecEq v, Num x) => x -> v x a -> v x a
(<@>) :: (VecEq v, Eq a, Num x) => a -> v x a -> x
fromList :: (VecEq v) => [(a, x)] -> v x a
toList :: (VecEq v) => v x a -> [(a, x)]
newtype VecEqL x a
VecEqL :: [(a, x)] -> VecEqL x a
unVecEqL :: VecEqL x a -> [(a, x)]
vEqZero :: VecEqL x a
vEqPlus :: (Eq a, Num x) => VecEqL x a -> VecEqL x a -> VecEqL x a
vEqTimes :: (Num x) => x -> VecEqL x a -> VecEqL x a
vEqAt :: (Eq a, Num x) => a -> VecEqL x a -> x
add :: (Eq a, Num x) => (a, x) -> VecEqL x a -> VecEqL x a
class EqMonad m
eqReturn :: (EqMonad m, Eq a) => a -> m a
eqBind :: (EqMonad m, Eq a, Eq b) => m a -> (a -> m b) -> m b
data AsMonad m a
Embed :: m a -> AsMonad m a
Return :: a -> AsMonad m a
Bind :: AsMonad m a -> (a -> AsMonad m b) -> AsMonad m b
unEmbed :: (Eq a) => AsMonad m a -> m a
instance (Show x, Show a) => Show (VecEqL x a)
instance (EqMonad m) => Monad (AsMonad m)
instance (VecEq v, Num x) => EqMonad (v x)
instance VecEq VecEqL

module QIO.Qio
type Pure = VecEqL CC HeapMap
updateP :: Pure -> Qbit -> Bool -> Pure
newtype Unitary
U :: (Int -> HeapMap -> Pure) -> Unitary
unU :: Unitary -> Int -> HeapMap -> Pure
uRot :: Qbit -> Rotation -> Unitary
unitaryRot :: Rotation -> Bool
uMatrix :: Qbit -> (CC, CC, CC, CC) -> Unitary
uSwap :: Qbit -> Qbit -> Unitary
uCond :: Qbit -> (Bool -> Unitary) -> Unitary
uLet :: Bool -> (Qbit -> Unitary) -> Unitary
runU :: U -> Unitary
data StateQ
StateQ :: Int -> Pure -> StateQ
free :: StateQ -> Int
pure :: StateQ -> Pure
initialStateQ :: StateQ
pa :: Pure -> RR
data Split
Split :: RR -> Pure -> Pure -> Split
p :: Split -> RR
ifTrue :: Split -> Pure
ifFalse :: Split -> Pure
split :: Pure -> Qbit -> Split
class (Monad m) => PMonad m
merge :: (PMonad m) => RR -> m a -> m a -> m a
data Prob a
Prob :: Vec RR a -> Prob a
unProb :: Prob a -> Vec RR a
evalWith :: (PMonad m) => QIO a -> State StateQ (m a)
eval :: (PMonad m) => QIO a -> m a
run :: QIO a -> IO a
sim :: QIO a -> Prob a
instance PMonad Prob
instance Monad Prob
instance (Show a) => Show (Prob a)
instance PMonad IO
instance Monoid Unitary

module QIO.QExamples
q0 :: QIO Qbit
q1 :: QIO Qbit
qPlus :: QIO Qbit
qMinus :: QIO Qbit
randBit :: QIO Bool
share :: Qbit -> QIO Qbit
bell :: QIO (Qbit, Qbit)
test_bell :: QIO (Bool, Bool)
hadTwice :: Bool -> QIO Bool
hadTwice' :: Bool -> QIO Bool
alice :: Qbit -> Qbit -> QIO (Bool, Bool)
uZZ :: Qbit -> U
bobsU :: (Bool, Bool) -> Qbit -> U
bob :: Qbit -> (Bool, Bool) -> QIO Qbit
teleportation :: Qbit -> QIO Qbit
test_teleport :: QIO (Bool, Bool)
teleport_true' :: QIO Qbit
teleport_true :: QIO Bool
teleport_random' :: QIO Qbit
teleport_random :: QIO Bool
u :: (Bool -> Bool) -> Qbit -> Qbit -> U
deutsch :: (Bool -> Bool) -> QIO Bool
problem :: QIO Bool

module QIO.QArith
swapQInt :: QInt -> QInt -> U
ifElseQ :: Qbit -> U -> U -> U
ifQ :: Qbit -> U -> U
cnot :: Qbit -> Qbit -> U
addBit :: Qbit -> Qbit -> Qbit -> U
carry :: Qbit -> Qbit -> Qbit -> Qbit -> U
addBits :: [Qbit] -> [Qbit] -> Qbit -> U
addBits' :: [Qbit] -> [Qbit] -> [Qbit] -> Qbit -> U
adder :: QInt -> QInt -> Qbit -> U
tadder :: (Int, (Int, Bool)) -> QIO (Int, (Int, Bool))
tRadder :: (Int, (Int, Bool)) -> QIO (Int, (Int, Bool))
tBiAdder :: (Int, (Int, Bool)) -> QIO (Int, (Int, Bool))
adderMod :: Int -> QInt -> QInt -> U
tadderMod :: Int -> (Int, Int) -> QIO (Int, Int)
multMod :: Int -> Int -> QInt -> QInt -> U
tmultMod :: Int -> Int -> Int -> QIO (Int, Int)
condMultMod :: Qbit -> Int -> Int -> QInt -> QInt -> U
inverseMod :: Int -> Int -> Int
inverseMod' :: Int -> Int -> [Int]
inverseMod'' :: Int -> Int -> [Int] -> Int
modExpStep :: Qbit -> Int -> Int -> QInt -> Int -> U
modExpStept :: Int -> Int -> Int -> Int -> QIO Int
modExp :: Int -> Int -> QInt -> QInt -> U
modExpt :: Int -> (Int, Int) -> QIO Int

module QIO.QIORandom
type CC = Complex RR
rX :: RR -> Rotation
rY :: RR -> Rotation
hadamards :: [Qbit] -> U
pow2 :: Int -> Int
pow2' :: Int -> Int -> Int
weightedU :: RR -> Qbit -> U
weightedBool :: RR -> QIO Bool
rlf :: [Bool] -> [Bool]
rlf_l :: Int -> [Bool]
rlf_n :: Int -> Int
trim :: Int -> [Qbit] -> [Qbit]
randomU :: Int -> [Qbit] -> U
randomU' :: Int -> [Qbit] -> U
randomQInt :: Int -> QIO QInt
randomQIO :: (Int, Int) -> QIO Int
randomInt :: Int -> QIO Int
random :: Int -> QIO Int
dice :: IO Int
inf_dice :: IO [Int]
dice_rolls :: Int -> IO [Int]
occs :: [Int] -> (Int, Int, Int, Int, Int, Int)
rs' :: [Int] -> Int -> Int
probs' :: Int -> IO (Int, Int, Int, Int, Int, Int)
probs :: Int -> IO (RR, RR, RR, RR, RR, RR)

module QIO.Qft
qft :: [Qbit] -> U
qftAcu :: [Qbit] -> [Bool] -> [Bool] -> U
qftBase :: [Bool] -> Qbit -> U
testCond :: [Qbit] -> U
testCondOk :: [Qbit] -> U
rotK :: Int -> Qbit -> U
tryQft :: Int -> QIO Int
tC :: (Qbit, Qbit) -> U
tC' :: (Qbit, Qbit) -> (Bool, Bool) -> U
testTC :: QIO (Bool, Bool)

module QIO.Shor
qftI :: QInt -> U
hadamardsI :: QInt -> U
shorU :: QInt -> QInt -> Int -> Int -> U
shor :: Int -> Int -> QIO Int
period :: Int -> Int -> Int
factor :: Int -> QIO (Int, Int)
runTime :: QIO a -> IO a
factorV' :: Int -> IO (Int, Int)
factorV :: Int -> IO ()
rand_co' :: Int -> QIO Int
rand_coprime :: Int -> QIO Int
half :: Int -> Int
reduce :: (Int, Int) -> (Int, Int)