18,747 research outputs found
Secure self-calibrating quantum random bit generator
Random bit generators (RBGs) are key components of a variety of information
processing applications ranging from simulations to cryptography. In
particular, cryptographic systems require "strong" RBGs that produce
high-entropy bit sequences, but traditional software pseudo-RBGs have very low
entropy content and therefore are relatively weak for cryptography. Hardware
RBGs yield entropy from chaotic or quantum physical systems and therefore are
expected to exhibit high entropy, but in current implementations their exact
entropy content is unknown. Here we report a quantum random bit generator
(QRBG) that harvests entropy by measuring single-photon and entangled
two-photon polarization states. We introduce and implement a quantum
tomographic method to measure a lower bound on the "min-entropy" of the system,
and we employ this value to distill a truly random bit sequence. This approach
is secure: even if an attacker takes control of the source of optical states, a
secure random sequence can be distilled.Comment: 5 pages, 2 figure
FPGA Implementations Comparison of Neuro-cortical Inspired Convolution Processors for Spiking Systems
Image convolution operations in digital computer systems are usually
very expensive operations in terms of resource consumption (processor
resources and processing time) for an efficient Real-Time application. In these
scenarios the visual information is divided in frames and each one has to be
completely processed before the next frame arrives. Recently a new method for
computing convolutions based on the neuro-inspired philosophy of spiking
systems (Address-Event-Representation systems, AER) is achieving high
performances. In this paper we present two FPGA implementations of AERbased
convolution processors that are able to work with 64x64 images and
programmable kernels of up to 11x11 elements. The main difference is the use
of RAM for integrators in one solution and the absence of integrators in the
second solution that is based on mapping operations. The maximum equivalent
operation rate is 163.51 MOPS for 11x11 kernels, in a Xilinx Spartan 3 400
FPGA with a 50MHz clock. Formulations, hardware architecture, operation
examples and performance comparison with frame-based convolution
processors are presented and discussed.Ministerio de Ciencia e Innovación TEC2006-11730-C03-02Junta de Andalucía P06-TIC-0141
Postprocessing for quantum random number generators: entropy evaluation and randomness extraction
Quantum random-number generators (QRNGs) can offer a means to generate
information-theoretically provable random numbers, in principle. In practice,
unfortunately, the quantum randomness is inevitably mixed with classical
randomness due to classical noises. To distill this quantum randomness, one
needs to quantify the randomness of the source and apply a randomness
extractor. Here, we propose a generic framework for evaluating quantum
randomness of real-life QRNGs by min-entropy, and apply it to two different
existing quantum random-number systems in the literature. Moreover, we provide
a guideline of QRNG data postprocessing for which we implement two
information-theoretically provable randomness extractors: Toeplitz-hashing
extractor and Trevisan's extractor.Comment: 13 pages, 2 figure
Randomized Benchmarking of Multi-Qubit Gates
As experimental platforms for quantum information processing continue to
mature, characterization of the quality of unitary gates that can be applied to
their quantum bits (qubits) becomes essential. Eventually, the quality must be
sufficiently high to support arbitrarily long quantum computations. Randomized
benchmarking already provides a platform-independent method for assessing the
quality of one-qubit rotations. Here we describe an extension of this method to
multi-qubit gates. We provide a platform-independent protocol for evaluating
the performance of experimental Clifford unitaries, which form the basis of
fault-tolerant quantum computing. We implemented the benchmarking protocol with
trapped-ion two-qubit phase gates and one-qubit gates and found an error per
random two-qubit Clifford unitary of , thus setting the first
benchmark for such unitaries. By implementing a second set of sequences with an
extra two-qubit phase gate at each step, we extracted an error per phase gate
of . We conducted these experiments with movable,
sympathetically cooled ions in a multi-zone Paul trap - a system that can in
principle be scaled to larger numbers of ions.Comment: Corrected description of parallel single-qubit benchmark experiment.
Results unchange
Barrel Shifter Physical Unclonable Function Based Encryption
Physical Unclonable Functions (PUFs) are circuits designed to extract
physical randomness from the underlying circuit. This randomness depends on the
manufacturing process. It differs for each device enabling chip-level
authentication and key generation applications. We present a protocol utilizing
a PUF for secure data transmission. Parties each have a PUF used for encryption
and decryption; this is facilitated by constraining the PUF to be commutative.
This framework is evaluated with a primitive permutation network - a barrel
shifter. Physical randomness is derived from the delay of different shift
paths. Barrel shifter (BS) PUF captures the delay of different shift paths.
This delay is entangled with message bits before they are sent across an
insecure channel. BS-PUF is implemented using transmission gates; their
characteristics ensure same-chip reproducibility, a necessary property of PUFs.
Post-layout simulations of a common centroid layout 8-level barrel shifter in
0.13 {\mu}m technology assess uniqueness, stability and randomness properties.
BS-PUFs pass all selected NIST statistical randomness tests. Stability similar
to Ring Oscillator (RO) PUFs under environment variation is shown. Logistic
regression of 100,000 plaintext-ciphertext pairs (PCPs) failed to successfully
model BS- PUF behavior
JWalk: a tool for lazy, systematic testing of java classes by design introspection and user interaction
Popular software testing tools, such as JUnit, allow frequent retesting of modified code; yet the manually created test scripts are often seriously incomplete. A unit-testing tool called JWalk has therefore been developed to address the need for systematic unit testing within the context of agile methods. The tool operates directly on the compiled code for Java classes and uses a new lazy method for inducing the changing design of a class on the fly. This is achieved partly through introspection, using Java’s reflection capability, and partly through interaction with the user, constructing and saving test oracles on the fly. Predictive rules reduce the number of oracle values that must be confirmed by the tester. Without human intervention, JWalk performs bounded exhaustive exploration of the class’s method protocols and may be directed to explore the space of algebraic constructions, or the intended design state-space of the tested class. With some human interaction, JWalk performs up to the equivalent of fully automated state-based testing, from a specification that was acquired incrementally
- …