Loading...

PPT – Quantum Computational Geometry PowerPoint presentation | free to view - id: 214c6c-ZDc1Z

The Adobe Flash plugin is needed to view this content

Quantum Computational Geometry

- Dr. Marco Lanzagorta
- Center for Computational Science
- US Naval Research Laboratory
- Email marco.lanzagorta_at_nrl.navy.mil

Objective

- To investigate how a quantum computer could be

used as a fully functional computational device

to solve real problems found in a wide variety of

scientific, industrial and military software

systems. - Explore the applications of QC beyond its use as

a dedicated cryptographic device or a quantum

physics simulator.

Presentation Outline

- Introduction
- Grovers Quantum Search Algorithm
- Quantum Computational Geometry
- Quantum Computer Graphics
- Conclusions

Introduction

- From bits to qubits
into the realm of quantum

information

From Bits to Qubits

- Qubits
- A qubit is the quantum unit of information.
- Represented by a quantum state, it has a value of

0, 1, or any superposition - qgt a0gt b1gt
- A quantum computer is in a state determined by a

quantum superposition

- Bits
- A bit is the classical unit of information.
- Represented by an electric/electronic on/off

switch, it has a value of either 0 or 1. - A classical computer is in a state determined by

a set of bits - S 0100111001

Probabilistic Computing

- If a classical computer is in the state 01,

when we check the output we will always read 01

with probability 1. - If a quantum computer is in the state
- Pgt a00gt b01gt c10gt d11gt
- after a measurement we will observe the state

00 with probability a2, 01 with probability

b2, - One of the goals of quantum information

processing systems is to transform the quantum

state in such a way that we will have a

meaningful result with probability close to 1.

Large Computational Space

- In a classical computer, we require O(N Log(N))

bits to store N records. - Example 24 bits can store 8 records.
- A quantum system encodes exponentially more

information than a classical one. We only require

O(Log(N)) qubits to store N records. - Example 24 qubits can store more than 16 million

records! - Of course, after a measurement of the state, we

can only access 24 bits of logical information. - Although most of the quantum information is

inaccessible, we can still exploit this

information processing capability.

Quantum Parallel Computation

- Let U be a linear operator such that
- Any function f can be represented with a quantum

array that implements the U linear operator. - If U is applied to a superposition then
- Therefore, U is being applied simultaneously to

all the states in the superposition, and leads to

an entangled state.

Quantum Information

- Quantum information is radically different from

classical information. - Therefore, the processing, manipulation,

transmission, encryption, distribution and

observation protocols for quantum information are

vastly different than those in classical

computing. - To learn more GMU QIT Spring 2005 Course!
- Besides the theoretical foundations of quantum

information, special emphasis will be made on

fault-tolerant quantum computing, quantum

cryptography, quantum communications and quantum

networks.

Grovers Quantum Search Algorithm

- Searching a database using a quantum computer

Grovers Algorithm

- Quantum algorithm developed by Grover to

perform a search of an item from an unsorted,

unstructured list of N records. - Performs the search in
- Instead of the O(N) required by brute force

methods in classical computing. - This algorithm can be formalized into a theorem

about the general solution of an NP problem.

Quantum Oracles (1)

- A quantum oracle is a black box which computes

the value of a function. - Let us consider a function f such that f(x)1 if

x y, and f(x) 0 for any other case. - Then, an oracle marks the solution of a search

problem by shifting the phase of the solution.

Quantum Oracles (2)

- We define I as the operator such that
- Ixgt -xgt if xy, and Ixgtxgt in any other

case

I

Quantum Search Problem (1)

- Let us suppose we have an unsorted unstructured

list of N 2n records and one of these records y

satisfies a given property. - Our objective is to use a quantum oracle to

search for y. - We define a function such that f(x)1 if x y,

and f(x) 0 for any other case. - We create a n-qubit state which is the uniform

superposition of N independent quantum states - y gt a S xgt where a 1/Sqrt(N)
- Each state xigt represents (points at) an element

of the list of records that need to be searched.

Quantum Search Problem (2)

- When we measure the quantum state y gt, the

probability that the result will be the solution

to the search problem is equal to 1/N. - lty y gt a S ltyxgt a 1/sqrt(N)
- P rr1/N
- Our aim is to modify y gt to concentrate the

amplitudes at xy. - This can be done by using quantum operators.

Grovers Algorithm (1)

- We use the f function to build a quantum oracle

and a quantum operator I such that Ixgt -xgt if

xy, and Ixgtxgt in any other case. - We define the operator D by
- Off diagonal elements 2/N
- Diagonal elements (-12/N)
- D performs an inversion about the mean

Grovers Algorithm (2)

- We consecutively apply k times the DI operator to

the state y gt - This leads to
- Which has as solution
- where

Grovers Algorithm (3)

- To find a solution to the search problem we need

b(k) 1 and a(k) 0. - Then, for large N
- k (p/4) Sqrt (N) (1/2)
- Therefore, by using Grovers algorithm, we can

find the solution of the searching problem in

O(Sqrt(N)) time! - Note If we use a single-qubit Hadamard gate,

then we have O(Sqrt(N) Log(N)) instead. This

result depends on the specific quantum computers

architecture.

Visualization of the Effect of a Single Grover

Iteration

b

3

DI ygt

y

Q

1

Q/2

a

Q/2

I ygt

2

Grovers Algorithm is Optimal

- It can be shown that Grovers algorithm is

optimal for an unsorted unstructured search

space. - This means that no other quantum algorithm can

solve the searching problem in less than O(N1/2).

- However, it may be possible to exploit the search

space structure to increase performance. - For example, Shors algorithm reduces factoring

to a periodicity problem of O(log(N)).

Formalization (1)

- Theorem 1
- By using a quantum circuit making O(N1/2) queries

to a black-box function f, one can decide with

non-vanishing correctness probability if there is

an element in the set such that f(x)1. - In other words, it states that Grovers algorithm

provides the right answer in O(N1/2).

Formalization (2)

- Theorem 2
- By using a quantum circuit, any problem in NP can

be solved with non vanishing correctness

probability in time O(N1/2P(log(N))), where P is

a polynomial depending on the particular problem. - In other words, it generalizes Grovers algorithm

to any problem in NP. However, the number of

elements to search may grow exponentially - N O(2M)
- In such case, the asymptotic complexity of the NP

problem remains exponential.

Some Generalization of Grovers Algorithm

- Grovers algorithm can easily be generalized for

the case where the list of N records has k

solutions to the search problem. - Grovers algorithm can be generalized to the case

where the number of solutions is unknown. - Grovers algorithm can be generalized to

calculate the mean and median of N elements. - Grovers algorithm works with almost any

transformation, it is not restricted to the use

of the Hadamard operator.

Unsorted Unstructured Datasets

- If there is no way to sort and/or structure the

dataset, then Grovers algorithm is unbeatable. - Shapes, colors, images, graphs, semantic

memories - However, most scientific, industrial, military

and financial datasets are alphanumerical strings

that can be sorted, structured and ordered.

What Grovers Algorithm Isn't Good For (1)

- Grover's algorithm has been hyped and

misrepresented as a tool to search a commercial

database. - QC literature usually ignores the existence of

classical data structures. - Speed up classical computational tasks
- Reorganize the original format of the data set in

a way that increases efficiency, abstraction and

reusability - Caveats Require a non-constant time process to

store the data, and it may increase the

space/storage complexity of the original data

set.

What Grovers Algorithm Isn't Good For (2)

- For 1-dimensional data queries, if a classical

algorithm is permitted to spend O(N Log(N)) time

to structure the database - A variety of searches can be performed in

O(Log(N)) time or better. - A hash table can be created in O(N) and it can

find an item in a list in O(1). - Therefore, classical data structures seem to be

superior to any quantum algorithm in terms of

asymptotic query-time complexity.

What Grovers Algorithm Isn't Good For (3)

- Grover's Algorithm has been hyped to offer a

solution to the "unsorted database problem". For

this alleged problem, the O(N log N)

preprocessing is not permitted. - However, Grover's algorithm still requires O(N)

preprocessing to move records from classical disk

space to quantum memory, and newer classical

methods can sort integers with complexity

approaching O(N).

Summary

- Grover's algorithm offers a general mechanism for

satisfying search queries on a set of N records

in O(N1/2) time. - Exact-match retrieval of records from a

1-dimensional datasets do not really exploit the

potential benefits of Grover's algorithm. - Grovers algorithm is most appropriate for some

multidimensional spatial search problems found in

the realm of computational geometry.

Quantum Computational Geometry

- What Grovers Algorithm is good for

Computational Geometry

- Computational Geometry is concerned with the

computational complexity of geometric problems

that arise in a variety of disciplines. - Computer Graphics
- Computer Vision
- Virtual Reality
- Multi-Object Simulation and Visualization
- Multi-Target Tracking.

Some Computational Geometry Problems

- Many of the most fundamental problems in

computational geometry involve - Multidimensional searches
- Search for those objects in space that satisfy a

certain query criteria. - Representation of spatial information
- Determination of the convex hull of a set of

points. - Determination of object-object intersections.

Relevance to Naval Systems

- These computational geometry problems arise in

a wide variety of defense systems of interest to

the US Navy. - Modeling Simulation of Combat Platforms
- VR Training Systems
- Command and Control Systems
- Missile Defense Systems
- Missile and Unmanned Aerial Vehicles Guidance

Systems - Data Fusion in Network Centric Warfare Systems
- Robotics

Example Graphics and Simulation

- Virtually all of the computational bottlenecks

in graphics and simulation applications involve

some variant of spatial search - Collision detection involves the identification

of intersections among spatial objects. - Ray tracing involves the identification of the

spatial object that is intersected first along a

line of sight.

Theoretical Limitations of Classical Computing

- Many optimality results have been established for

the application of classical algorithms to

various classes of problems. - Machine independent function defined by the

maximum number of steps taken on any instance of

size N. - An optimal O(f(N)) gives the best worst case

scenario. - When an optimality result is established, it

imposes a strict performance bound that we cannot

hope to exceed. - Many of the optimality results for

multi-dimensional search algorithms imply very

pessimistic prospects for the development of very

large systems.

Quantum Computational Geometry

- Grovers algorithm may be used to speed up

some of the most important computational geometry

algorithms - Quantum Multidimensional Range Searches
- Quantum Determination of the Complex Hull
- Quantum Determination of Object-Object

intersections

Quantum Computational Geometry Algorithms 1.

Quantum Multidimensional Range Searches

Introduction

- Multidimensional search algorithms are used to

find a number of specific elements from a

multidimensional set. - Multidimensional queries are widely used
- Missile Defense Systems.
- Navigation and Guidance Systems.
- Robots, unmanned aerial vehicles, cruise

missiles - Visualization, Modeling and Simulation Systems.
- Combat platforms (submarines, tanks ).
- Physical, atmospheric and oceanic phenomena.
- Scientific and Battlespace Visualization.
- Battlefield Command and Control Systems.

Multidimensional Range Searches

- Multidimensional search problems are usually cast

in the form of query-answer - Given a collection of points in space, one is to

find those that satisfy a certain query criteria. - Range queries require the identification of all

points within a d-dimensional coordinate aligned

box. - Range queries are the most general

multidimensional queries and special cases of

general region queries. - Optimality results for range queries provide

lower bounds for more sophisticated queries.

Classical Range Queries Linear Space

- Given a dataset of N points, a classical data

structure of size O(N) can be used to satisfy

range queries in O(N1-1/d k) time, where k is

the number of points satisfying the query and d

is the number of dimensions. This is optimal.

Classical Range Queries Non-Linear Space

- In many applications it is possible within the CC

framework to optimize a tradeoff between

execution time and storage. - In particular, range queries can be satisfied in

O(log d-1 N k) time using O(N log d-1 N)

storage. - The storage complexity becomes problematic for

large N, e.g., if N is 1 million, the storage in

3D is multiplied by a factor of 400.

Quantum Range Queries

- It can be shown that Grovers quantum search

algorithm permits general spatial search queries

to be performed with O((N/k)1/2 k log k)

complexity. - If k is essentially a constant, then quantum

range queries can be satisfied in O(N1/2) time,

where the exponent is independent of the

dimensionality.

Spatial Search Comparisons

d space dimensions

Practical Considerations (1)

- The observed performance of linear-space

classical data structures is often much better

than the theoretical worst case O(N1-1/d)

complexity, at least for small query ranges. - The O((log N)d) query complexity of sophisticated

classical range query structures is also the

best-case complexity. - It is conjectured that the run-time coefficients

associated with QC algorithms may be much smaller

than what is possible for classical computers.

Practical Considerations (2)

- By far the greatest practical advantage offered

by quantum computing is the ability to store

pointers to N data items using only log(N)

qubits. - QC offers the opportunity to handle very large

datasets, far beyond of what could be stored in a

classical computers memory. - The quantum O(N1/2) complexity may prove to be

problematic for large N if the QC run-time

coefficients are not extremely small.

Potential Applications

- Multidimensional Quantum Searches could be

important in several areas of interest - Multi-target tracking and multi-sensor data

fusion - Missile Defense
- Robotics
- Missile Guidance and Navigation systems
- Network Centric Warfare Systems
- Computer Graphics, modeling and simulation

Quantum Computational Geometry Algorithms 2.

Quantum Determination of the Convex Hull

The Convex Hull

- The convex hull of a set of points S is the

smallest convex set that contains S. - The determination of the convex hull is a

computational geometry problem that emphasizes

the representation of spatial information. - The convex hull of a set of points is used to

represent its spatial extent.

CC Convex Hull Algorithms

- The most efficient classical algorithm (known to

date) to compute the convex hull requires

O(N log(h)) time for N objects with h points

forming the convex hull. - h is usually a constant.
- The Jarvis-March algorithm calculates the convex

hull in O(N h), but it is a good candidate to be

ported to a quantum computer using Grovers

algorithm.

Jarvis-March Algorithm

- Identify a point in the convex hull (the one with

the minimum x-coordinate), then, for each point

in the dataset - Compute the angles between the line x0 and every

point in the dataset. The line with the smallest

clockwise angle goes through the next point in

the convex hull. - Overall complexity is O(N h).

Quantum Jarvis- March Algorithm

- Each successive point can be determined after the

application of a simple calculation for each of

the points in the dataset. - The angles for the points in each step can be

computed, and the minimum point retrieved in

O(N1/2) using Grovers algorithm. - Overall complexity of O(N1/2 h).

Comparison of Convex Hull Algorithms

N Total number of points. h Number of points

comprising the hull

Quantum Computational Geometry Algorithms 3.

Quantum Determination of Object-Object

Intersections

Classical Algorithms

- Given a set of N objects, in general it is

impossible to avoid spending O(N2) time checking

whether or not each pair of objects intersect. - For coordinated-aligned orthogonal boxes, it is

possible to determine the intersections in O(N

logd-2(N) m) time, where m is the total number

of intersections.

A Grover-Based Quantum Algorithm

- Assume that O(1) time is sufficient to determine

whether a pair of objects intersect. - Construct a quantum register that enumerates all

the possible N2 pairs of objects in O(log N)

time. - Use Grovers algorithm to determine which objects

intersect and retrieve them. - This algorithm has O(N/m1/2 m log m) time

complexity.

Comparison of Intersection Detection Algorithms

N Total number of objects

m Total number of intersections

Advantages of the Quantum Solution

- The quantum algorithm is attractive because of

its generality. - The complexity of the quantum algorithm holds for

any class of objects for which comparisons take

O(1) time. - Annuli with arbitrary radii for sonar

applications. - Nurbs and surface patches in computer graphics.
- No classical method exists for efficiently

identifying intersections among general objects

with curved surfaces.

Quantum Computer Graphics

- Using Quantum Computational Geometry in Computer

Graphics

Computer Graphics

- Computer Graphics are widely used in todays

world - Digital film and visual effects
- Video games
- Scientific visualization
- Battlefield visualization
- Flight simulators
- Architectural applications
- Medical Applications
- Computer Aided Design

Rendering

- In few words, rendering means to draw an object

on the computer screen. - In computer graphics, an object is decomposed

into several thousands of polygons or surfaces. - The rendering process has to render each

individual element, one at the time. - Rendering is a simple but extremely time

consuming process.

Rendering Example

Rendering Speed

- Rendering speed is an important issue. The

faster the rendering, the better - Efficient generation of high quality

photo-realistic images. - Cheaper production costs for film companies.
- Ability to interactively visualize and explore

larger scientific data-sets. - Trainers and trainees can also benefit from more

accurate, faster and photo-realistic simulations. - Battlefield commanders could rely on higher

quality Combat Planning, Decision Support and

Command Control systems.

Rendering as a search problem

- Most of the currently known rendering

algorithms have to perform several spatial

searches over the entire database of

objects/polygons in a scene. - These searches tend to be a BIG bottleneck in the

rendering process as the number of

objects/polygons grows into the order of millions.

Improving Classical Rendering

- Research is currently being done to speedup the

rendering of complex scenes. - New data structures and rendering algorithms.
- New hardware (graphic engines graphic cards).
- However, as we discussed in the previous section,

there are theoretical limits on the performance

of classical algorithms used in graphics and

simulation. - Note these are algorithmic limitations. The

algorithms asymptotic behavior is independent of

the computer hardwares speed and architecture.

Quantum Rendering

- Brute Force Approach Apply quantum search

algorithms to speed up some of the most important

rendering techniques - Z-Buffering
- Ray casting
- Level of Detail
- Image compression

Classical Ray Casting (1)

- Determines the visibility of surfaces by

tracing imaginary rays from the viewers eye to

the objects in the scene.

Eye

Scene

Screen

Classical Ray Casting (2)

- Ray Casting Algorithm
- For each pixel in the screen
- Calculate ray from pixel position and center of

projection. - Shoot the ray and find p, the closest polygon

intersected. - Shade pixel according to p.
- Ray casting technique requires O(N) operations

per pixel for a single ray.

Quantum Ray Casting (1)

- The most obvious application of quantum computing

to ray casting is for the determination of

object-ray intersections. - In the sake of simplicity, we use bounding boxes

(bb). - For each object (polygon or surface) in the

scene, we create a sphere (or cube) that

completely surrounds it. - Then, the problem is reduced to calculate the

ray-bb intersections for each ray. - Using the equations of a line and a sphere

(cube), it is easy to determine if a ray

intersects a bb.

Quantum Ray Casting (2)

- We create a quantum register that holds an

enumeration of the N bounding boxes - We create a function f such that
- f(r, j i) 1 if the ray r intersects j i
- f(r, j i) 0 if the ray r does not

intersects j i

Quantum Ray Casting (3)

- We use a two-step quantum search algorithm, very

similar in nature to Grovers algorithm - First we find the subset of k objects that

intersect the ray. - Then, from these k objects we find the one that

lies closest to the screen. - Algorithm gives the right answer with probability

close to 1 in O(N1/2 k1/2 ) computational steps. - In most practical applications, k is close to be

a constant and k ltlt N.

Quantum Ray Casting (4)

- Quantum Ray Casting algorithm per ray (pixel)
- For each pixel in the screen
- Initialize the quantum register.
- Calculate ray from pixel position and center of

projection. - Apply the function f(r,x) to the quantum

register. - Perform the quantum search algorithm to find p,

the closest intersected polygon. - Shade pixel according to p.

Complexity Analysis (1)

- Memory initialization
- Recall that each memory initialization may take

up to O(Log(N)), depending on the computers

architecture. - This has to be done once per ray.
- Quantum search
- The quantum search algorithm for finding one

element out of N takes O(Sqrt(N)). - This has to be done once per ray.

Complexity Analysis (2)

- Therefore, the quantum algorithm has the

following query time and space complexities - Time O(NP Sqrt(N) ) (NP total number of rays)
- Space O(log(N))
- Naïve Classical Solution
- Time O(NP N)
- Space O(N)
- As N grows into the billions, the quantum

solution scales better in time and space

requirements

Using Data Structures in Classical Rendering

- So far, we have only used the most naïve

procedure for finding intersections and distances

in classical rendering algorithms. - A most likely situation is the use of data

structures, such as kd-trees, to speedup the

calculations. - In this case, the time complexity may be much

better than O(N) and even comparable to or better

than O(Sqrt(N)).

Quantum vs. Classical Rendering

- However, as we discussed in the previous section,

the only classical algorithms that achieve

query-time complexity superior to that of

Grovers algorithm do so at the expense of

non-linear space. - This makes the O(Sqrt(N)) query complexity and

O(log(N)) space complexity of quantum rendering

highly attractive. - Could be used to generate very detailed textures,

terrains, and virtual environments beyond what

could be stored in a classical computer.

Beyond Grovers algorithm based quantum rendering

- While Grovers O(Sqrt(N)) is proved to be an

optimal result, there may be hidden symmetries

in the problem that could allow better query

times. - For example, Shors algorithm for factorizing

large numbers in O(log(N)) is based on the

realization that factorization can be seen as a

periodicity problem. - A similar association may exist for rendering

algorithms. - Quantum Data Structures may also be developed to

speed up the rendering processing. - Further research in quantum rendering algorithms

is necessary!

Summary

- Even with a brute force approach, quantum

computers offer some benefits to computer

graphics. - Superior algorithmic speed and storage
- The large computational space available on a

quantum computer could allow the creation of

photorealistic virtual environments (like the one

showcased in The Matrix), far more complex than

what could be achieved with classical computers.

Conclusions

- Quantum Computational Geometry, is it as good as

it sounds?

On the positive side

- We have discussed efficient applications of

Grovers algorithm to computational geometry

problems. - We have described quantum algorithms which

outperform the best classical computing

algorithms currently known. - The algorithms describe combine classical and

quantum computing techniques, and resources from

both types of hardware.

On the negative side

- The success of these algorithms presumes
- A smooth integration between classical and

quantum computational systems. - The physical realization of an efficient

(approximate) quantum register copying circuit. - Quantum software able to compile general purpose

Grovers black box functions and oracles. - The engineering and manufacturing of stable

(quantum noise resistant) quantum registers with

logarithmic space complexity.