secure distributed protocols have been an important and fruitful area of research for modern cryptography . in thissetting , there is a group of participants who wish to perform some joint task , despite the fact that some of the participants in the protocol may cheat in order to obtain additional information or corrupt the outcome .we investigate a quantum version of an extensively studied classical problem , _ secure multi - party computation _ ( or _ secure function evaluation _ ) , first introduced by . a multi - party quantum computing ( mpqc ) protocol allows participants to compute an -input quantum circuit in such a way that each party is responsible for providing one of the input states .the output of the circuit is broken into components , and receives the output .note that the inputs to this protocol are arbitrary quantum states the player providing an input need only have it in his possession ; he does not need to know a classical description of it .moreover , unlike in the classical case , we can not assume without loss of generality that the result of the computation will be broadcast .instead , each player in the protocol receives some part of the output .informally , we require two security conditions : + _ - soundness and completeness : _ no coalition of or fewer cheaters should be able to affect the outcome of the protocol beyond their ability to choose their inputs .+ _ - privacy : _ no coalition of or fewer cheaters should learn anything beyond what they can deduce from their initial knowledge of their input and from their part of the output .* verifiable quantum secret sharing*.  in order to construct mpqc protocols , we consider a subtask which we call _ verifiable quantum secret sharing_. in classical cryptography , a verifiable secret sharing scheme is a two phase protocol with one player designated as the `` dealer '' .after the first phase ( _ commitment _ ) , the dealer shares a secret amongst the players . in the second phase ( _ recovery _ ) , the players reconstruct the value publicly .the natural quantum version of this allows a dealer to share a state ( possibly unknown to him but nonetheless in his possession ) .because quantum information can not be cloned , we can not require that the state be reconstructed publicly ; instead , the recovery phase also has a designated player , the reconstructor .we require that , despite any malicious actions by players : + _ - soundness : _ as long as is honest and the dealer passes the commitment phase successfully , then there is a unique quantum state which can be recovered by .+ _ - completeness : _when is honest , then he always passes the commitment phase .moreover , when is also honest , then the value recovered by is exactly s input .+ _ - privacy : _ when is honest , no other player learns info about s input until the recovery step .note that for quantum data , the privacy condition is redundant : any information obtained about the shared state would imply some disturbance of that state , contradicting the completeness requirement . *contributions*.  we give a protocol for verifiable quantum secret sharing that tolerates any number of cheaters .we show that this is optimal , by proving that vqss is impossible when . based on techniques from fault - tolerant quantum computing, we use our vqss protocol to construct a multi - party quantum computation protocol tolerating any cheaters .( mpqc is similar to standard fault - tolerance but with a different error model , see previous work ) .our protocols run in time polynomial in both , the number of players , and , the security parameter .the error of the protocols is exponentially small in .  beyond these specific results ,there are a number of conceptual contributions of this paper to the theory of quantum cryptographic protocols .we provide a simple , general framework for defining and proving the security of distributed quantum protocols in terms of equivalence to an ideal protocol involving a third party .this follows the definitions for classical multi - party protocols .the analysis of our protocols leads us to consider various notions of local `` neighborhoods '' of quantum states , and more generally of quantum codes .we discuss three notions of a neighborhood .the notion most often used for the analysis of quantum error correction and fault - tolerance is insufficient for our needs , but we show that a very natural generalization ( specific to so - called `` css '' codes ) is adequate for our purposes . along the way , we provide modified versions of the classical sharing protocols of .the new property our protocols have is that dealers do not need to remember the randomness they use when constructing shares to distribute to other players .this allows them to replace a random choice of coins with the _ superposition _ over all such choices .* classical mpc*.  multi - party computing was introduced by goldreich , micali and wigderson , who showed that _ under computational assumptions _ , secure multi - party evaluation of any function was possible tolerating any minority of cheating players , i.e. if and only if .if one assumes pairwise secure channels but no computational assumptions , then one can compute any function securely if and only if  .if one further assumes the availability of a secure broadcast channel , then one can in fact tolerate , and no more ( ) .all of these protocols rely on verifiable secret sharing as a basic tool .our solution draws most heavily on the techniques of chaum , crpeau and damgrd .  beyond these basic protocols ,much work has focused on finding proper definitions of security , e.g. .we adopt a simple definition based on the initial definitions of canetti .   * quantum secret sharing*.  relatively little work exists on multi - party cryptographic protocols with quantum data .secret sharing with a quantum secret was first studied by cleve et al . , who showed an equivalence with quantum error - correcting codes ( qecc ) .their scheme is the basis of our protocols .chau deals with classical computations , but also mentions the problem of verifiable quantum secret sharing as an open question .   * fault - tolerant quantum computing*.  the goal of ftqc is to tolerate _ non - malicious _ faults occurring within a single computer .one assumes that at every stage in the computation , every qubit in the circuit has some known probability of suffering a random error , i.e. of becoming completely scrambled .moreover , errors are assumed to occur _ independently _ of each other and of the data in the computation .one can view multi - party computation as fault - tolerant computing with a different error model , one that is suited to distributed computing .the mpqc model is weaker in some respects since we assume that errors will always occur in the same , limited number of positions , i.e. errors will only occur in the systems of the corrupted players .in other respects , the error model of mpqc is stronger : in our setting errors may be _ maliciously _ coordinated . in particular , they will not be independently placed , and they may in fact depend on the data of the computation the adversaries will use any partial information known about the other players data , as well as information about their own data , to attempt to corrupt the computation . for example , several ftqc algorithms rely on the fact that at certain points in the computation , at most one error is likely to occur .such algorithms will fail when errors are placed adversarially .techniques from ftqc are nonetheless useful for multi - party computing .we will draw most heavily on techniques due to aharonov and ben - or .   in this paper, we use a simple simulation - based framework for proving the security of quantum protocols , similar to early classical definitions .we specify a task by giving a protocol for implementing it in an ideal model where players have access to a trusted third party .we prove a given protocol secure by showing a simulator which translates any attack in the real - world protocol into an ( almost ) equally successful attack in the ideal model .we assume that every pair of participants is connected by perfect ( i.e. authenticated , unjammable , secret ) quantum and classical channels , and that there is a classical authenticated broadcast channel to which all players have access . because we will always consider settings where , we can also assume that players can perform _ classical _ multi - party computations securely in our setting . ] .the adversary is an arbitrary quantum algorithm ( or family of circuits ) ( not necessarily polynomial time ) , and so the security of our protocols does not rely on computational assumptions .the real and ideal models , as well as the notion of security , are specified more carefully in . in this paper, we use the following informal specifications of the ideal protocols .the real protocols are secure if they succeed in simulating the ideal ones .* multi - party quantum computation*.  [ sec : mpc - def ] all players hand their inputs to the , who runs the desired circuit and hands back the outputs . note that the only kind of cheating which is possible is that cheaters may choose their own input .in particular , cheaters can not force the protocol to abort .* verifiable quantum secret sharing*.  [ sec : vqss - def ] in the sharing phase , the dealer gives his secret system to the trusted party . in the reconstruction phase, the sends the secret system to the reconstructor .the only catch is that in the ideal model , honest players should not learn the identity of until after the first phase has finished ( otherwise , could simply send the secret state to in the first phase without violating the definition ) .we present the notation necessary for reading the protocols and proofs in this paper . for a more detailed explanation of the relevant background ,see or a textbook such as .we will work with -dimensional quantum systems , for some prime .such a system is called a qupit , and the `` computational '' basis states are labelled by elements in .we will also be working in the fourier basis , which is given by the unitary transformation .a basis for the operators on a qupit is given by the pauli operators , where , , and .tensor products of these operators yield the pauli basis for the set of operators on a register of qupits .the weight of a tensor product operator is the number of components in which it is not the identity .   *quantum codes*.  the error - correcting codes used in this paper are quantum css codes .these are defined via two classical linear codes such that .if we denote for a classical code , then we can write the css code as .thus , is the set of states of qubits which yield a codeword of when measured in the computational basis and a codeword of when measured in the fourier basis .specifically , we will use quantum reed - solomon codes from .we specify a quantum rs code by a single parameter .the classical reed - solomon code is the set of all vectors , where is any univariate polynomial of degree at most .the related code is the subset of corresponding to polynomials which interpolate to 0 at the point 0 .that is : : \\deg(q ) \leq \delta\ } $ ] and .the code has minimum distance , and an efficient error correction procedure .let .there are constants such that the dual of the code is just the code , rescaled by in the coordinate ; similarly , the dual of is a rescaled version of .denote these duals by , respectively .the quantum code for parameter is the css code obtained from codes and .it encodes a single qupit , and has minimum distance ( thus , it corrects errors ) .moreover , errors can be corrected efficiently , given the syndrome of a corrupted codeword , i.e. the syndrome measured in the computational basis and the syndrome measured in the fourier basis .* transversal operations*.  a nice result from fault - tolerant computing is that one can in fact perform many operations on data encoded by a quantum rs code using only local operations and classical information transmitted between the components .consider the following gates :  [ gate : x ] shift : ,  sum : ,  scalar multiplication : , ,  [ gate : z ] phase shift : ,  fourier transform : ,  toffoli ( multiplication ) : .these gates are universal  , in the sense that a sequence of these gates can approximate any unitary operation with arbitrary accuracy . beyond these , in order to simulate arbitrary quantum circuits one should also be able to introduce qupits in some known state ( say ) , as well as to discard qupits . for any csscode, the gates [ gate : x ] through [ gate : z ] from the set above can be implemented _ transversally _ , that is using only local operations which affect the same component of two codewords .measurement and the remaining two operations can be performed almost transversally .   * measurement*.  for a quantum rs code , measuring each component of the encoding of yields a vector where .this operation is not quite transversal since after the qupit - wise measurement , the classical information must be gathered together in order to extract the measurement result .nonetheless , it can tolerate arbitrary corrupton of of the positions in the codeword if classical error correction is first applied to the vector of measurement results .* fourier and toffoli gates*.  for css codes , applying the fourier transform transversally maps data encoded with the codes to the fourier transform of that data , encoded with the dual code defined via the codes . for quantum rs codes, rescaling each component of the dual code of produces the code .this allows one to perform the map , where is the encoding map for a code .  when , we have , so the fourier transform is in fact transversal , but the toffoli gate is difficult to perform .  when , neither the fourier transform nor the toffoli gate is transversal , but they can both be reduced to _ degree reduction _ via transversal operations  .degree reduction maps an arbitrary state encoded using to encoded with .the circuit we use for degree reduction is due to gottesman and bennett .we start with one block encoded using ( system ) , and an ancilla block in the state ( system ) .perform a sum gate from to ( this can be done transversally by a property of the codes ) .measure in the computational basis , obtaining , and apply to .the system now contains the data , encoded using .this entire procedure can be performed transversally except for the measurement step . however , as noted above , measurement requires only classical communication between the components .one of the ideas behind classical multi - party computing protocols is to ensure that data is encoded in a state that remains `` close '' to a codeword , differing only on those positions held by cheaters ( call that set ) . for classical codes , `` close '' means that the real word should differ from a codeword only on , so that any errors introduced by cheaters are correctable . for a code ,let the -neighborhood be the set of vectors differing from a codeword of by positions in , i.e. , equivalently , one can define as the set of words obtained by distributing a ( correct ) codeword to all players , and then having all players send their shares to some ( honest ) reconstructor .  for quantum codes , there is more than one natural definition of the neighborhood corresponding to a set of positions .let be partitioned according to two sets .we say a mixed state is `` in '' if all states in the mixture lie in , i.e. where is the projector onto .we consider three definitions of a `` -neighborhood '' of a css code .let be an arbitrary state of the coding space .[ nbhd1 ] differs from a state in only by some quantum superoperator acting only on : + .[ nbhd2 ] can not be distinguished from a state in by looking only at positions in .+ .[ nbhd3 ] specifically for css codes , one can require that the state pass checks on in both bases , i.e. that measuring either the syndrome in the computational basis , or the syndrome in the fourier basis , yields 0 .the set of states which pass this test is :   in general , these notions form a strict hierarchy : + .only notion ( [ nbhd3 ] ) is always a subspace ( see for details ) .  in the analysis of quantum error correction and fault - tolerance schemes , it is sufficient to consider notion ( [ nbhd1 ] ) , for two reasons .on one hand , one starts from a correctly encoded state . on the other hand ,the errors introduced by the environment will be independent of the encoded data ( and in fact they must be for error correction to be possible at all in that context ) .  in our setting , however , we can not make such assumptions .the cheaters might possess states which are entangled with the data in the computation , and so the errors they introduce will not be independent of that data . instead , we show that our verifiable sharing protocol guarantees a condition similar to notion ( [ nbhd3 ] ) ( see lemma [ lem : l2-sound ] ) . in order to provide some intuition for the proofs of section [ sec:2ls ] , we characterize notion ( 3 ) below .   * well - definedness of decoding for *.  the set is a subspace , since it is defined in terms of measurement outcomes .more particularly , it is spanned by the states of :  [ lem : charact ] if is in , then we can write , where , the are pauli operators on and .  to check if is in , we measure the syndrome in the computational basis and the syndrome in the fourier basis . however , the distribution on this outcome measurement will not change if we first measure the and syndromes , i.e. if we first make a measurement which projects into one of the subspaces ( i.e. maps to with probability , where is the projector for the space ) .the new state lies completely in one of the spaces .however , is either contained in ( if there is an operator equivalent to which acts only on ) or _ orthogonal _ to ( if no such operator exists ) .thus for all which act on more than .hence is a mixture of states each of which is a linear combination of elements of the spaces , where acts only on .this has a useful corollary , namely that decoding is well - defined for states in .formally , there are two natural `` reconstruction operators '' for extracting the secret out of a state which has been shared among several players .suppose that has distance and .first , is the decoding operator for the error - correcting code , which would be applied by an honest player holding all of the shares . for any operator of weight less than and for any state in ,we have ( i.e. the error is not only corrected but also identified ) .it will then discard the system containing the syndrome information .second , is the `` ideal recovery operator '' , defined by identifying the set of cheaters and applying the simple interpolation circuit to any set of good players positions ( this corresponds to erasure recovery ) .[ prop : l1-well - defined ] for any state in , the state is well - defined and is equal to .our protocols guarantee conditions similar to , and well - definedness is essential for proving simulatability .consider a particular basis state .the decoding operator will produce the state , since errors of weight at most can be identified uniquely .the ideal operator will extract the encoded state . without loss of generality ,the ideal recovery operator will replace with , the final output .in both cases , the output can be written as tensored with some ancilla whose state depends only on the syndrome ( and which identifies uniquely ) .once that state is traced out , the outputs of both operators will be identical . another way to seethis is that the ideal operator can simulate the real operator : one can go from the output of the ideal operator to that of the real operator by applying a transformation which only affects the ancilla . for a state expressed as in lemma [ lem : charact ] , the final outcome will be .in this section we define a two - tiered protocol for vqss . it is based on the vqss protocols of as well as on the literature on quantum fault - tolerance and error correction , most notably on .detailed proofs for the claims of this section are in .however , some intuition is given by the proofs of section [ sec : nbhds ] .in the vss protocol of , the dealer takes his secret , splits it into shares and gives the component to player .player then shares this secret by splitting it into shares and giving the share to player .thus , there are total shares , which can be thought of as the leaves of a tree with depth 2 and fan - out : each leaf is a share ; the branch corresponds to the shares created by player , and the root corresponds to the initial shares created by the dealer .player holds the leaf in each branch of this tree .we will run a cut - and - choose protocol in order to guarantee some kind of consistency of the distributed shares .  during the protocol we accumulate sets of apparent cheaters : one set for the dealer ( this corresponds to a set of branches emanating from the root ) , and one set for each player ( this corresponds to a subset of the leaves in branch ) .these sets all have size at most .at the end of the protocol , we want to guarantee certain invariants .say has minimum distance , and each codeword corresponds to a single value .[ def : tgood ] we say a tree of field elements is with respect to the code and the sets if :  for each ( i.e. , corresponding to an honest player ) , we have , i.e. all apparent cheaters are real cheaters .  for each branch , the shares held by the honest players _ not in _ should all be consistent with some codeword in , i.e. the vector of all shares should be in , where is the set of cheating players .: because there are at most players in and at most cheaters , there are at least honest players remaining , and so the polynomial above is uniquely defined .this guarantees that for each branch , there is a unique value which is obtained by interpolating the shares of the honest players not in .  for ,the values defined by the previous property are all consistent with a codeword of ( i.e. the vector is in ) .we will abbreviate this as , when the sets , ,, are clear from the context .the vqss protocol is described in protocols [ prot : vqss ] and [ prot : qr ] .intuitively , it guarantees that a tree of quantum shares would yield a tree of classical values if measured in either the computational basis or the fourier basis .we use the codes and , with , although there is in fact no need to do this : the protocol will work for any css code with distance at least , so long as the codes are efficiently decodable .the protocol can be tweaked for efficiency .the final protocol takes three rounds .each player sends and receives qubits , and the broadcast channel is used times overall , where is the soundness error of the protocol ( this requires setting ) .why is this a secure vqss protocol ?we want to show that the protocol is equivalent to the `` ideal model '' , where at sharing time the dealer sends his secret system to a trusted outside party , and at reveal time the trusted party sends to the designated receiver . to do that , we will use two main technical claims .* soundness*.  [ sec : l2-sound ] we must show that at the end of the protocol , if the dealer passes all tests then there is an well - defined `` shared state '' which will be recovered by the dealer .to do so , we guarantee a property similar to ( notion ( [ nbhd3 ] ) of section [ sec : nbhds ] ) .  [lem : l2-sound ] the system has high fidelity to the following statement : `` either the dealer is caught ( i.e. ) or measuring all shares in the computational ( resp .fourier ) basis would yield a tree with respect to the code ( resp . ) . ''proof of this is via a `` quantum - to - classical '' reduction , similar to that of .first , checks in the computational and fourier bases do nt interfere with each other , since they commute for css codes .second , in a given basis , we can assume w.l.o.g . that all ancillae are first measured in that basis , reducing to a classical analysis similar to .   *ideal reconstruction*.  in order to prove soundness carefully , we define an _ ideal interpolation _ circuit for trees : pick the first honest players not in , say . for each , pick honest players not in and apply the normal interpolation circuit ( i.e. erasure - recovery circuit ) for the code to their shares to get some qupit . applying the interpolation circuit again , we extract some system which we take to be the output of the ideal interpolationreal _ recovery operator is given by protocol [ prot : qr ] .the following lemma then applies , following essentially from proposition [ prop : l1-well - defined ] .[ lem : l2-well - defined ] given a tree of qupits which is in both bases , the outputs of and are the same .in particular , this means that no changes made by cheaters to their shares can affect the outcome of .lemmas [ lem : l2-sound ] and [ lem : l2-well - defined ] show that there is essentially a unique state which will be recovered in the reconstruction phase when the receiver is honest .* completeness*.  [ sec : l2-complete ] as discussed earlier , the protocol is considered complete if when the dealer is honest , the state that is recovered by an honest reconstructor is exactly the dealer s input state .the key property is that _ when the dealer is honest , the effect of the verification phase on the shares which never pass through cheaters hands is the identity . _consider the case where the dealer s input is a pure state .on one hand , we can see by inspection that an honest dealer will always pass the protocol .moreover , since the shares that only go through honest players hands remain unchanged , it must be that if some state is reconstructed , then that state is , since the ideal reconstruction operator uses only those shares .finally , we know that since the dealer passed the protocol the overall tree must be in both bases , and so some value will be reconstructed .thus , on input , an honest reconstructor will reconstruct .we have proved :  [ purestate ] if and are honest , and the dealer s input is a pure state , then will reconstruct a state with fidelity to the state .not surprisingly , this lemma also guarantees the privacy of the dealer s input . by a strong form of the no cloning theorem, any information the cheaters could obtain would cause some disturbance , at least for a subset of the inputs .thus , the protocol is in fact also private .* simulatability*.  the claims above show that the protocol satisfies an intuitive notion of security . in this sectionwe sketch a proof that the protocol satisfies a more formal notion of security : it is equivalent to a simple ideal model protocol .the equivalence is _ statistical _ , that is the outputs of the real and ideal protocols may not be identical but will have very high fidelity to one another .[ thm : vqss ] protocols [ prot : vqss ] and [ prot : qr ] are a statistically secure vqss scheme .  the ideal protocol is sketched in section [ sec : def ] . to show equivalence , we will give a transformation that takes an adversary for our protocol and turns it into an adversary for the ideal protocol . to give the transformation, we exhibit a simulator which acts as an intermediary between and the ideal protocol , making believe that it is experiencing the real protocol .the idea is that the simulator will simulate the regular vqss  protocol either on input provided by a cheating dealer or on bogus data , and then extract and/or change the shared state as needed .we give a sketch of the simulation procedure in algorithm [ alg : vqss - sim ] .why does this simulation work ?  when is cheating :when is cheating , the simulation is trivially faithful , since there is _ no difference _ between the simulation and the real protocol : runs the normal sharing protocol , then runs the interpolation circuit , sending the result to . in the reconstruction phase , gets the same state back from , and runs the interpolation circuit in reverse .thus , the two executions of the interpolation circuit cancel out .  when is honest , the faithfulness of the simulation comes from lemma [ lem : l2-well - defined ]: in the real protocol , outputs the result of the regular decoding operator . in the simulation, gets the output of the ideal interpolation .since the shared state has high fidelity to a tree ( by lemma [ lem : l2-sound ] ) , the outputs will be essentially identical in both settings ( i.e. they will have high fidelity ) .  when is honest :  when is also honest , the faithfulness of the simulation follows from the completeness and privacy properties of the real protocol .privacy implies that the adversary can not tell that it is actually participating in a sharing of rather than the dealer s state , and completeness means that in the real protocol gets a state with high fidelity to that received by in the ideal protocol .  when is a cheater , does not get from until the reconstruction phasethen he applies the ideal interpolation circuit to extract the state used during the verification phase , swaps with , then runs the ideal interpolation circuit backwards .since the ideal interpolation circuit only acts on shares of the honest players , is capable of performing these operations without tipping off to the fact that it is in a simulation . by the completeness property of the real protocol and the no - cloning theorem ,the residual state left over after the ideal interpolation circuit ( i.e. , the state of the cheaters ) has almost no correlation to the data shared using the circuit , so swapping in and running the circuit backwards gives us a state with high fidelity to the state that would have resulted from sharing directly with the same .thus , the simulation is faithful in this case as well .we have essentially proved theorem [ thm : vqss ] .two - level sharings produced by the same dealer ( using the protocol above ) have some additional properties , which will be useful for multi - party computation .first of all , notice that there is no problem in tracking the sets incrementally across various invocations of the protocol for the same dealer , and so we assume below that these sets are the same for different sharings from the same dealer.  some operations can be applied transversally to valid sharings . applying the linear operation ( denoted ) to all shares of two sharings effectively applies to the shared states .similarly , applying the fourier rotation transversally changes the sharing to the dual code and applies a logical fourier rotation . finally , measuring all shares of a valid sharing in the computational basis and applying classical decoding yields the same result as measuring the shared state .thus , players can measure without exchanging quantum information .[ rem : share0 ] the dealer can additionally use the protocol to prove to all players that the system he is sharing is exactly the state : the ancillas he uses in this case will all be sharings of ( instead of ) .the verification step is the same as before , except now players verify that the reconstructed codeword at the top level interpolates to 0 .similarly , the dealer can prove that he is sharing a state .this will be useful for sharing ancillas in the mpqc protocol .[ lem : no4 ] no 4-player vqss scheme tolerates one cheater .suppose such a scheme exists .consider a run of the protocol in which all players behave perfectly honestly until the end of the sharing phase , at which point one ( unknown ) player introduces an arbitrary error .however , an honest `` receiver '' ruth , given access to the state of all players , must still be able to recover the shared state .thus , the joint state of all players constitutes a four - component qecc correcting one error . however , no such code exists , not even a mixed - state one , by the quantum singleton bound  .the optimality of our vqss scheme is an immediate corollary , since any protocol tolerating cheaters could be used to construct a four - person protocol tolerating one cheater by having each participant simulate players in the original protocol :  no vqss scheme for players exists which tolerates all coalitions of cheaters .  notethat we have only proved the impossibility of _ perfect _ vqss protocols .however , the quantum singleton bound still holds when exact equality is replaced by approximate correctness , and so in fact even statistical vqss schemes are impossible when .in this section we show how to use the vqss protocol of the previous section to construct a multi - party quantum computing scheme . first , we give a modified vqss protocol . at the end of the protocol ,all players hold a single qupit . with high fidelity , either the dealer will be caught cheating or the shares of all honest players will be consistent in both the computational and fourier bases , i.e. there is no set of `` apparent cheaters '' .we then apply fault - tolerant techniques to achieve secure distributed computation.   we will now restrict attention to protocols tolerating cheaters , instead of cheaters as before .thus , we take for simplicity , and as before we set ( thus ). we will work with the css code given by and .recall that this is the css code for which there exist nearly - transversal fault - tolerant procedures ( section [ sec : prelim ] ) .our goal is to share a state so that at the end all shares of honest players lie in .the new scheme is given in protocol [ prot : l3-vqss ] .the idea is that the previous vqss scheme allows distributed computation of linear gates and fourier transforms on states shared by the same dealer .it also allows verifying that a given shared state is either or . the players will use this to perform a distributed computation of the encoding gate for the code , the dealer will share the secret system , as well as states and states .players then apply the ( linear ) encoding gate , and each player gets sent all shares of his component of the output . as before , the main lemmas are soundness and completeness of the protocol :  at the end of the sharing phase , the system has high fidelity to `` either the dealer is caught or the players shares lie in '' .when is honest , on pure state input , the shared state will have high fidelity to ( i.e. will differ from only on the cheaters shares ) .note the dealer can also prove that he has shared a state ( by showing that his input is ) .given the protocol of the previous section , and known fault - tolerant techniques , there is a natural protocol for secure multi - party computation of a circuit : have all players distribute their inputs via the top - level sharing ( protocol [ prot : l3-vqss ] ) ; apply the gates of one - by - one , using the ( essentially ) transversal implementation of the gates described in section [ sec : prelim ] ; then have all players send their share of each output to the appropriate receiver .see protocol [ prot : mpqc ] .the only sticking point in the analysis is that the fault - tolerant procedures require some interaction when measuring a shared state .all players measure their share and broadcast the result , applying classical decoding to the resulting word .if the errors occurring in the measured ancilla were somehow correlated or entangled with errors in the real data , one could imagine that measuring and broadcasting them might introduce further entanglement .however , this will not be a problem : on one hand , any errors will occur only in the cheaters shares , and so provide nothing beyond what the cheaters could learn themselves ; on the other hand , the honest players will discard all the information from the broadcast except the decoded measurement result ( each honest player performs the decoding locally based on the broadcast values , so all honest players obtain the same result ) .again , the cheaters can do this themselves .suppose that all inputs and ancillas are shared at the beginning via states in .then the result of applying the protocol for a given circuit , and then sending all states to an honest decoder is the same as sending all states to and having apply to the reconstructed states .[ thm : mpqc - secure ] for any circuit , protocol [ prot : mpqc ] is a statistically secure implementation of multi - party quantum computation as long as .the proof of this is by simulation , as before .the key observation is that when the simulator is controlling the honest players , the adversary can not tell the difference between the regular protocol and the following ideal - model simulation :   runs the input phase as in the protocol , using as the inputs for honest players . in this phase ,if any dealer is caught cheating , sends `` i am cheating '' to the on behalf of that player . `` swaps '' the cheaters inputs with bogus data , and sends the data to the .that is , he applies the interpolation circuit to honest players shares to get the various input systems ( for ) , and then runs the interpolation circuit backwards , with the state replacing the original data . now runs the computation protocol with the adversary on the bogus data .( because no information is revealed on the data , the adversary can not tell this from the real protocol . ) receives the true computation results destined to cheating players from . `` swaps '' these back into the appropriate sharings , and sends all shares of the wire to player ( again , he does this only for ) .the proof that this simulation succeeds follows from the security of the top - level sharing protocol and the previous discussion on fault - tolerant procedures .given our results , the most obvious open question is if mpqc  is possible when .another natural direction of research is to find a vqss protocol with zero error .for example , the techniques of for the classical case do not seem to apply to the quantum setting .finally , one can ask what tasks are achievable when we allow cheating players to force the abortion of the protocol ( usually called an `` optimistic protocol '' ) .thanks to richard cleve for helpful discussions .thanks madhu sudan for patience , support and advice .b. chor , s. goldwasser , s. micali , and b. awerbuch .verifiable secret sharing and achieving simultaneity in the presence of faults ( extended abstract ) . in _ proc . of 26thfocs _ , pages 383395 , portland , oregon , 2123 oct .ieee .r. cramer , i. damgrd , s. dziembowski , m. hirt , and t. rabin .efficient multiparty computations with dishonest minority . in j.stern , editor , _ proc . of eurocrypt 99_ , volume 1592 of _iacr , springer - verlag , 1999 .o. goldreich , s. micali , and a. wigderson . how to play any mental game or a completeness theorem for protocols with honest majority . in _ proc .of 19th stoc _, pages 218229 , new york city , 2527 may 1987.  s. goldwasser and l. a. levin .fair computation of general functions in presence of immoral majority . in a.j. menezes and s. a. vanstone , editors , _ proc . of crypto90 _ , volume 537 of _ lncs _ , pages 7793 .iacr , springer - verlag , 1991 .

Abstract: _ secure multi - party computing _ , also called _ secure function evaluation _ , has been extensively studied in classical cryptography . we consider the extension of this task to computation with quantum inputs and circuits . our protocols are information - theoretically secure , i.e. no assumptions are made on the computational power of the adversary . for the weaker task of _ verifiable quantum secret sharing _ , we give a protocol which tolerates any cheating parties ( out of ) . this is shown to be optimal . we use this new tool to show how to perform any multi - party quantum computation as long as the number of dishonest players is less than .   [ this version appears with the permission of the acm . only minor typographical changes have been made from the version which appeared in the proceedings of _ stoc 2002_. ]


the primary purpose of this article is to suggest a method for incorporating computation into upper - level classical mechanics courses .there is an emerging consensus in the physics community that computational skills are important for physicists, but too often there is little or no computation included in the physics curriculum. probably the best way to strengthen the computational component of the physics curriculum is to incorporate computation into all components of the curriculum .several institutions have developed large - scale computational physics programs, which typically include at least one dedicated computational physics course as well as computational components in other upper - level courses .other institutions offer a single computational physics course along with an otherwise traditional curriculum . with a variety of good computational physicstextbooks available it may appear that there is no reason not to offer at least one course in computational physics .unfortunately , the reality is that there are constraints that may prevent some departments from offering such a course .these constraints may involve the number of physics faculty , the computational background of the physics faculty , low student enrollment in physics courses , or even political resistance to curricular changes . for faculty who face these constraints but desire to include some computation in the physics curriculum, the best approach may be to incorporate computation into existing courses . even departments that have a computational physics course may be looking for ways to increase the role of computation in the physics curriculum .we believe that the intermediate classical mechanics course , typically taken by students in their sophomore or junior year , is ideally suited for incorporating computation .computation can contribute to a variety of learning goals , and different approaches to incorporating computation into physics courses will likely emphasize different goals .one goal of including computation in physics courses is simply to improve students learning of physics concepts .computer visualizations and interactive simulations are particularly useful in this regard .computation can also open the door to new and important topics such as nonlinear dynamics and chaos . including computation in physics coursescan also increase physics students familiarity with widely - used computational tools and help students see how these tools can be applied to solving physics problems .finally , computation can be used to introduce students to important numerical algorithms . in many casesthese algorithms can provide insight into important physics concepts , in addition to serving as tools for carrying out computations .although all of these learning goals can be achieved through a dedicated course in computational physics , as mentioned above this may not be a practical approach in all departments .incorporating computation into a standard course may be an effective way to introduce computation into the physics curriculum , perhaps as a temporary solution until a dedicated computational course can be added .computation can be included in a standard course even if the students have no computational background ( although , of course , more can be done if the students have had a course in programming or computational physics ) .we feel that the standard ( sophomore / junior level ) intermediate classical mechanics course is well suited for including computation .students in classical mechanics can benefit tremendously from computer visualizations , which help them to build intuition about classical dynamics .classical mechanics provides an excellent forum for introducing a variety of important numerical tools such as ode solvers , root finding , numerical integration , numerical linear algebra , etc .some important topics in modern classical mechanics , like chaos , can not be effectively taught without computation .another advantage of the classical mechanics course is that it is typically taught early in the upper - level physics curriculum , often immediately after the introductory sequence .introducing students to computation at this early stage gives them the opportunity to use their computational skills in later physics and mathematics courses .to begin using computation in a classical mechanics course one must first make choices about which computational tools to use and how to use them .choosing the right computational platform can be difficult , as each platform has advantages and disadvantages .symbolic and numeric mathematics software packages ( such as mathematica , maple , and matlab , each of which has its own advantages and disadvantages ) offer quick and relatively easy ways to perform computational work , provide a wide range of computational tools , and include high - quality visualization tools .the downside is that these tools can be used with little understanding of the numerical methods that are being employed .furthermore , these software packages can be quite expensive .the other main alternative is to have students create programs from scratch using a standard programming language like fortran , java , or python .students who do their own coding must develop an understanding of the models they are studying as well as the numerical methods that are employed .this solution is generally inexpensive since free compilers are available for these languages on a variety of operating systems .many common programming tasks can be carried out with the aid of freely - available numeric libraries , like open source physics ( osp) and scipy, to reduce the time that must be spent creating the programs . however , in spite of these libraries there is still a great deal of programming `` overhead '' that must be addressed and instructors whose students have no programming background may not have sufficient time to teach the necessary programming skills .there are some intermediate solutions available , such as the easy java simulations ( ejs ) package, which automates many programming tasks and allows users to focus on the numerical algorithms that are used .however , ejs does not offer the broad range of functionality that is available with a standard programming language or a software package like mathematica .we have chosen to use mathematica and matlab in our classical mechanics courses , but we plan to move toward using java / osp and ejs for some topics .we like mathematica for its powerful symbolic mathematics capabilities , and matlab because it is widely used in industry .both of these packages are tools that students will likely be able to use in other classes and perhaps throughout their careers .programming in java with the osp library provides an opportunity to share both programs and curricular materials with the broader physics community and contribute to ( as well as benefit from ) a larger project. ejs provides simple tools for quickly creating visualizations and simulations .each of these options , as well as the others listed above , will be more or less suited to an individual instructor s specific situation .instructors must be guided by the background of their students ( do they have programming experience ? ) , their own computational experience ( with what platforms is the instructor familiar ? ) , as well as other practical considerations ( are there funds available to pay for software licenses ? will the software be supported by qualified campus staff ? ) .the choice of platform ( or platforms ) should also be guided by how the instructor intends to use the computational tools in the course . in our classical mechanics courses we use computation in two main ways : for in - class demonstrations and for student computational projects .typically we will demonstrate computer solutions to physics problems as part of our in - class lecture .the code used to construct the solution is made available to students so that they can examine the code and `` experiment '' with it at their leisure .we then follow up these demonstrations by assigning computational projects that students must complete on their own or in small groups .early in the course these projects may involve only minor modifications of the code used in the demonstrations , perhaps to study the same phenomenon in a new system . in this way the demonstration code serves as a template that helps the students complete the computational project .as the course proceeds we demand more from our students , expecting them to construct computational solutions without a template ( but using computational tools they have seen before ) .these computational projects can easily be made the basis of formal writing assignments in which students must present their analytic and numerical work along with figures , typeset equations ( possibly in /latex ) , and a thorough discussion of the physics .because the software packages we use tend to hide the details of the numerical algorithms they employ , we feel that it is important to provide students with some explicit instruction on algorithms .we focus on simple algorithms , rather than the sophisticated algorithms employed by the software packages we use , for a few important computational tasks .this instruction enhances students knowledge of computation because it emphasizes the fact that computations require _ some _ algorithms and that the choice of algorithm can critically affect the success of the computation .in addition , teaching students about algorithms can sometimes lead to a better understanding of important physics concepts .  as an example of how we use algorithms in our course ,let us consider an object of mass oscillating in one dimension on an ideal spring with force constant .the equation of motion for this simple harmonic oscillator is easy to solve analytically , but we can also take a numerical approach to the problem . the simplest algorithm that we might consider for this purposeis the euler algorithm : where , , and represent the displacement from equilibrium , the velocity , and the net force at time . for this system .although the software packages we use have their own built - in ode solvers , we can also use these packages to implement a simple algorithm like the euler algorithm .the solid red curve in figure [ euler](a ) shows the trajectory of the object in phase space ( position versus velocity ) generated by the euler algorithm when kg , n / m , m , , and s. the dashed blue curve in fig .[ euler](a ) shows the exact solution .it is clear from this result that the euler algorithm is unstable since the trajectory produced by the algorithm spirals continually outward away from the exact solution .this also means that the euler algorithm does not conserve energy : it is clear that with the euler algorithm the object s maximum displacement and maximum speed are steadily increasing , so its total mechanical energy must also be steadily increasing .  the failure of the euler algorithm to conserve energy is related to yet another failure : the failure to preserve phase space volume . according to liouville s theorem , a conservative system ( such as our simple harmonic oscillator ) must preserve the volume ( or area ) occupied by an ensemble of trajectories in phase space .figure [ euler](a ) shows the locations generated by the euler algorithm for a trajectory ensemble at times , 1.8 , 3.6 , and 5.4 s. at the points are randomly distributed within a square region around m , .as time passes the cluster of points moves through phase space and the shape of the region becomes distorted .however , it is clear from figure [ euler](a ) that the size of the region also grows over time , in clear contradiction to liouville s theorem .in fact , it is easy to show that the euler algorithm does nt preserve phase space volume .if we treat equation [ eu ] as a two - dimensional map , then this map will preserve phase space volume if and only if the jacobian of the map , defined by has determinant equal to one .a quick calculation will show that for the euler algorithm , in the case of the simple harmonic oscillator .  these problems with the euler algorithm can be fixed with a simple modification , leading to what is known as the euler - cromer algorithm. this algorithm simply updates the velocity first , and then uses the new velocity to update the position .the equations describing this algorithm are : where all quantities are defined as for the euler algorithm above .this algorithm is stable and conserves energy , on average , for oscillatory motion. we can quickly illustrate this by applying this new algorithm to our simple harmonic oscillator . the results are shown in figure [ euler](b ) .it is clear that the solution produced by the algorithm remains close to the exact solution , coinciding with the exact solution at every quarter period .similarly , the total energy oscillates about the correct value with a period equal to half of the oscillator s period .furthermore , this algorithm appears to preserve phase space volume .this can be easily proved by showing that the jacobian for equation [ ec ] has determinant equal to one .once these algorithms ( and their differences ) have been demonstrated , students should be given a chance to use them .they can explore the behavior of the algorithms as the time step is increased or decreased .they can compare the results of these algorithms with the results obtained using the built - in ode solver supplied by the software package .they can make modifications to the model by adding drag forces or driving forces .note that students are not restricted to drag forces linear in the velocity , or sinusoidal driving forces .in fact , it is very instructive to consider the case of a quadratic drag force ( a nonlinear system ) and compare the results to those obtained with a linear drag force ( a linear system ) .if these non - conservative forces are added then neither algorithm will preserve phase - space volume , as can be easily seen by finding the determinant of the jacobian ( and noting that is no longer a function of only ) . carrying out this calculation using the euler - cromer algorithmmakes it clear that for drag forces , where , the determinant of the jacobian is less than one indicating that phase space volume will shrink over time .this is exactly what one should expect for a dissipative system .other algorithms for common numerical tasks may be worth discussing in class .algorithms for root finding ( newton - raphson method , bisection method ) and numerical integration ( trapezoid approximation , simpson s rule , monte carlo methods ) are useful and simple enough to present without absorbing too much class time .although class time spent discussing algorithms may take away from time spent discussing physics , the above example shows that it is possible to teach important physical concepts along with algorithms . as another example , the newton - raphson method illustrates the concept of a stable attractor which is important for understanding the dynamics of dissipative systems .computational assignments should be chosen with care to ensure that they take full advantage of what computing offers .one way to do this is to use computation to break out of the restrictions imposed by the need for an analytic solution ( or approximate solution ) .we have already mentioned the case of the harmonic oscillator with a quadratic drag force .two other examples of this type are motion in a non - inertial reference frame and motion of a charged particle in electric and magnetic fields .traditional courses tend to focus on cases where analytic solutions are possible , such as the eastward deflection of an object that drops from rest to earth or the cyclotron motion of an electron in a magnetic field .computation allows students to solve more realistic problems such as long - range projectile motion on earth and the motion of an electron in combined electric and magnetic fields . solving such problems computationally not only allows students to tackle realistic problems , it also allows students to visualize the motion in these systems .figure [ proj ] shows two calculated trajectories , one with non - inertial forces and one without , for a long - range projectile fired due east from rome , georgia . visualizingthis motion helps students get a sense of the magnitude of the effect of non - inertial forces .figure [ charge ] shows an osp application that simulates a charged particle moving in the presence of constant ( but general ) three dimensional electric and magnetic fields .students can experiment with the parameters of the calculation without performing a tedious analytic analysis .trajectory of a long - range projectile fired due east from rome , georgia .one path is calculated by taking non - inertial forces into account , while the other path ignores these apparent forces.,width=288,height=288 ]   an osp application for visualizing the motion of a charged particle in the presence of three dimensional constant electric and magnetic fields.,width=288,height=288 ]  some topics can not be taught at all without computation .the most obvious example of this is chaos .computational solutions of systems like the driven , damped pendulum can be used to illustrate important concepts of dissipative chaos such as sensitive dependence on initial conditions , period doubling bifurcations , poincar sections , and strange attractors .simple iterated function systems like the logistic map can be used to delve deeper into dissipative chaos with bifurcation diagrams and lyapunov exponents . while these topics are now included in many textbooks, theycan not really be taught effectively without letting students carry out some computations .once students have mastered the necessary computational skills , even the more advanced topic of hamiltonian chaos becomes accessible through the study of two - dimensional area - preserving maps. in fact , students who have already seen the euler - cromer algorithm will be familiar with some of the properties of area - preserving maps .computational projects can also be chosen to introduce important numerical methods .numerical integration can be introduced in the context of finding the period of a pendulum undergoing large amplitude oscillations .numerical root - finding techniques can be used to determine the time of flight for a projectile with air resistance .numerical determination of eigenvalues and eigenvectors can be used in the context of finding principle axes for rigid - body motion or normal modes of coupled oscillator systems .many textbooks now have computational exercises among their end - of - the - chapter homework problems , and these can be a valuable source of ideas for computational projects. one of us ( jh ) has written a textbook for classical mechanics that explicitly incorporates computation throughout the book and includes a wide variety of computational projects. in addition , anyone can obtain most of our computational materials ( except solutions to student projects ) written in matlab or mathematica .we plan to update these websites with new materials as they are created .we also plan to port these materials to java / osp or ejs .these materials will be made available through the bq - osp database. instructors wishing to include computation in their physics courses are also encouraged to consult computational physics texts and the open source physics website. course in intermediate classical mechanics provides an excellent opportunity for including computation without requiring the resources and commitment needed for developing a new computational course or program .many topics that are typically covered in an intermediate classical mechanics course can benefit from a computational approach .the examples discussed in this article provide just a small sample .the intermediate classical mechanics course is also a good place to introduce computation because it typically comes early in the curriculum .ideally this course would be preceded by a computational physics course and followed by other upper - level physics courses that include computational work .we have found that even if computation is required only in classical mechanics students will use the computational skills they have gained to solve problems in a wide variety of other physics and mathematics courses .an early exposure to computational work can also lead to opportunities for undergraduate research in computational physics .each instructor must decide how much computation to include , which computational topics to cover , and how computation will be used in the course .these decisions must be based on a wide variety of factors , including the computational skills of the students , the computational background of the instructor , the computational resources ( both hardware and software ) available , and time and content coverage constraints .nonetheless , we feel that it is both possible and important to include computation somewhere in the physics curriculum .we hope that this article provides some guidance for those who wish to include computation in the curriculum , but can not create a dedicated course or program in computational physics .one of us ( jh ) wishes to thank david m. cook for his inspiring workshop dealing with computational physics and which he attended .he also wishes to thank wolfgang christian and francisco esquembre for their invaluable help in developing osp java applications following osp workshops held by wolfgang christian , mario belloni , and anne cox .rubin landau , `` computational physics : a better model for physics education ?, '' computing in science & eng . * 8 * , no . 5 , 2230 ( 2006 ) ; marty johnston , `` implementing curricular change , '' computing in science & eng . * 8 * , no . 5 , 3237 ( 2006 ) ; jaime r. taylor and b. alex king iii , `` using computational methods to reinvigorate an undergraduate physics curriculum , '' computing in science & eng .* 8 * , no . 5 , 3843 ( 2006 ) ; david m. cook , _ computation in the lawrence physics curriculum _( department of physics , lawrence university , appleton , wi , 2006 ) ; h. gould , `` computational physics and the undergraduate curriculum , '' computer physics communications * 127 * , 610 ( 2000 ) .harvey gould , jan tobochnik , and wolfgang christian,_an introduction to computer simulation methods : applications to physical systems _( addison - wesley , new york , ny , 2007),3rd . ed . ; rubin h. landau and manuel j. paez,_computational physics : problem solving with computers _( john wiley & sons , new york , ny , 1997 ) . ;steven e. kunin and dawn c. meredith,_computational physics : fortran version_(addison - wesley , reading ma , 1990 ) ; samuel s. m. wong,_computational methods in physics & engineering _ ( prentice hall , englewood clifts , nj , 1992 ) ; alejandro l. garcia,_numerical methods for physics _ ( prentice hall , upper saddle river , nj , 2000 ) , 2nd . ed . ; nicholas j. giordano and hisao nakanishi,_computational physics _ ( pearson , prentice hall , upper saddle river , nj , 2006 ) , 2nd . ed . ; paul l. devries,_a first course in computational physics _( john wiley , new york , ny , 1994 ) ; david m. cook,_computation and problem solving in undergraduate physics & engineering _ ( department of physics , lawrence university , appleton , wi , 2003 ) .kelly r. roos,``an incremental approach to computational physics education , '' computing in science & eng . * 8 * , no.5 , 4450 ( 2006 ) .norman chonacky and david winch , `` 3ms for instruction : reviews of maple , mathematica , and matlab , '' computing in science & eng . *3 , 713 ( 2005 ) ; norman chonacky and david winch , `` 3ms for instruction , part 2 : maple , mathematica , and matlab , '' computing in science & eng .* 7 * , no .4 , 1423 ( 2005 ) .john r. taylor , _ classical mechanics _ ( university science books , saualito , ca 2005 ) ; stephen t. thornton and jerry b. marion,_classical dynamics of particles and systems _( thomson - brooks / cole , belmont , ca 2004 ) , 5th ed . ; grant r. fowles and george l. cassidy,_analytical mechanics _ ( thomson - brooks / cole , belmont , ca 2005 ) , 7th ed .the matlab code used is available upon request by e - mailing the author .osp applications not included in ref . will be made freely available here : www.westga.edu/~jhasbun/osp/osp.htm in tandem with the textbook release .

Abstract: there is a growing consensus that physics majors need to learn computational skills , but many departments are still devoid of computation in their physics curriculum . some departments may lack the resources or commitment to create a dedicated course or program in computational physics . one way around this difficulty is to include computation in a standard upper - level physics course . an intermediate classical mechanics course is particularly well suited for including computation . we discuss the ways we have used computation in our classical mechanics courses , focusing on how computational work can improve students understanding of physics as well as their computational skills . we present examples of computational problems that serve these two purposes . in addition , we provide information about resources for instructors who would like to include computation in their courses .


this paper deals with selective pressure and diversity in cellular genetic algorithms ( cgas ) which are a subclass of genetic algorithms where the population is embedded in a grid .these concepts are closely related to the exploration / exploitation trade - off .previous studies on cgas selected the size and the shape of neighborhoods , or the shape of the grid as basic parameters to tune the search process .altering these structural parameters entails a deep change in the way we deal with the problem .for instance , there is no built - in mean to swap from a rectangular grid to a square grid without misshaping the neighborhood relation .we suggest using _ anisotropic selection _ ( as ) to promote diversity and to control accurately the selective pressure in genetic search . the main advantage of the _ anisotropic selection _scheme is that it allows to control the exploration / exploitation trade - off without affecting neither the grid topology nor the neighborhood shape ; so the cellular genetic algorithm we propose merely works on a square grid and a simple von neumann neighborhood shape .+ the paper is divided in 6 sections .section [ section1 ] gives a brief definition of cgas and an overview of existing techniques used to control the exploration / exploitation tradeoff .section [ section2 ] introduces the as scheme .section [ section3 ] studies the influence of as on the selective pressure . in section [ section4 ]we compare as and rectangular grids topologies influence on the selective pressure . in section [ section5 ]we show how as promotes the emergence of niches . in section [ section6 ]we use a cga on a quadratic assignment problem to measure the correlation between anisotropy and performance .finally we tie together the results of the previous sections and suggest directions for further research .this section presents a brief overview on cellular genetic algorithms and a standard technique to measure the selective pressure .[ section1 ]   cellular genetic algorithms are a subclass of genetic algorithms ( gas ) in which exploration and population diversity are enhanced thanks to the existence of small overlapped neighborhoods . such algorithms are specially well suited for complex problems .we assume a two - dimensional toroidal grid as a spatial population structure .each grid cell contains one individual of the population .the overlapping neighborhoods provide an implicit mechanism for migration of genetic material throughout the grid .a genetic algorithm is assumed to be running simultaneously on each grid cell , continuously selecting parents from the neighborhood of that grid cell in order to produce an offspring which replaces the current individual .   a standard technique to study the induced selection pressure without introducing the perturbing effect of variation operators is to let selection be the only active operator , and then monitor the number of best individual copies in the population .the takeover time is the time it takes for the single best individual to conquer the whole population .the grid is initialized with one cell having the best fitness and all the other having a null fitness . since no other evolution mechanism butselection takes place , we can observe the way the best individual spreads over the grid by counting generation after generation the number of copies of this one .a shorter takeover time thus means a higher selective pressure .it has been shown that when we move from a panmictic population , as in standard ga , to a spatially structured one of the same size with synchronous updating of the cells , the global selection pressure induced on the entire population is weaker .links have been established between takeover time and neighborhood size and shape or grid topology .neighborhood size and shape in a cga are parameters that have some influence on the takeover time. a larger overlap of local neighborhoods of the same shape speeds up the best individual s spreading over the grid .the influence of the shape is given by sarma and de jong through a measure on the neighborhood which represents the spatial dispersion of a cell pattern .rather than the size of the neighborhood in terms of individuals , the key particularity of a local neighborhood is its radius .the takeover time decreases while the radius increases in a spatially structured population .[ sec - effectgridtopo ] we measure the relation between grid topology and selective pressure for rectangular grids where the population size is fixed to .we use the following grid shapes : ; ; ; ; and individuals .the selection strategy is a binary tournament .for each cell we randomly choose two individuals in its neighborhood .the best one then replaces the individual of the cell on the grid if it is fitter or with probability 0.5 if fitnesses are equal .figure [ fig - crois - tournoi ] shows the average of independant runs of growth of against generations ; the takeover time is reached when is equal to the size of the grid ( see table i ) . the average growth rate , that is the number of new best individual copies per time unit , of these curves for four rectangular grid shapes ( , , , ) is plotted in figure [ acrois_tournoi ] .this figure helps us to understand the growth of .the growth rate is the same for all grids for the first generations .then , the spreading speeds down to reach a constant speed for rectangular grids .this constant is where is the probability of selecting the best individual when there is one copy of it in the neighborhood and the shortest side of the grid .more accurately , decreases when is filled by copies of the best individual ( see figure [ display_rec](b ) ) .then , the speed becomes constant until the best individual has spread over to the other side ( see figure [ display_rec](c ) ) .this explains why the grid curve has no constant period : the two sides are filled at the same time .finally , the growth rate falls down to zero as the best individual finishes conquering the grid .the results of the experiments we conducted are in agreement with e.alba and j.troya observations that narrow grid shapes induce low selective pressure .we will see in the next sections that this behavior can be observed with the as too .[ cols="^ " , ]   [ display_two ]we experiment a cga using anisotropic selection on a quadratic assignment problem ( qap ) : nug30 .our aim here is not to obtain better results with respect to other optimization methods , but rather to observe the behavior of a cga with as . in particular , we seek an optimal value for the anisotropy degree .the qap is an important problem in both theory and practice .it was introduced by koopmans and beckmann in 1957 and is a modal for many practical problems .+ the qap can be described as the problem of assigning a set of facilities to a set of locations with given distances between the locations and given flows between the facilities .the goal is to place the facilities on locations in such a way that the sum of the products between flows and distances is minimal .+ given facilities and locations , two matrices  ] where is the distance between locations and and the flow between facilities and , the objective function is : + where gives the location of facility in the current permutation .+ nugent , vollman and ruml suggested a set of problem instances of different sizes noted for their difficulty .the instances they suggested are known to have multiple local optima , so they are difficult for a genetic algortihm .we experiment our algorithm on their 30 variables instance called nug30 .we consider a population of 400 individuals placed on a square grid .each individual represents a permutation of .we need a special crossover that preserves the permutations :  * select two individuals and as genitors . *choose a random position .* find and so that and . *swap positions and from and positions and from .* repeat times this procedure where is the length of an individual .this crossover is an extended version of the upmx crossover proposed in .the mutation operator consists in randomly selecting two positions from the individual and exchanging these positions .the crossover rate is 1 and we perform one mutation per individual in average . + we consider 500 runs for each anisotropy degree .each run stops after 1500 generations .figure [ alpha - perf ] shows the average performance of the algorithm towards : for each value of we average the best solution of each run .performances are growing with and then fall down as is getting closer to its limit value .this curve shows the influence of the selective pressure on the performances and how important it is to control it accurately .the best average performance is observed for , which corresponds to a good exploration / exploitation tradeoff . in the neighborhood of this optimal valuethe algorithm favors propagation of good solutions in the vertical direction with few interactions on the left or right sides .this kind of dynamics is well adapted to multi - modal problems as we can reach local optima on each columns of the grid and then migrate them horizontally to find new solutions .performances would probably improve if the selective pressure did not remain static during the search process .as in , we can define some criteria to self - adjust the anisotropy degree along generations .furthermore , we can assign a different anisotropy degree to each cell of the grid , so that we can determinate criteria to self - adjust selective pressure locally upon measures on neighborhoods .this paper presents a new selection scheme in cellular genetic algorithms .the main objective is to control the exploration / exploitation tradeoff in a flexible way .we propose to exploit the cellular ga characteristics to promote diversity during a genetic search process .previous studies on cgas selected structural parameters , as neighborhood or grid shape , to tune the selective pressure .the main drawback of these techniques is that altering a structural parameter entails a deep change in the way we deal with the problem .the new selection scheme we suggest is based on _ fuzzy neighborhood _ where a cell is chosen according to different probabilities . in order to favor one direction rather than the other one , _anisotropic selection _ chooses individuals in fuzzy neighborhood .experiments performed in order to establish relation between the takeover time and the degree of anisotropy are consistent with our expectation that selection pressure decreases with the degree of anisotropy .analysis of the growth curves allows to distinguish three different phases in the diffusion process .experimental results establish linear correlation in takeover between as and cga using rectangular grid .then we point out capabilities of as to promote the emergence of niches . finally , using a cga with as on a qapwe have shown the existence of an anisotropic optimal value of such that the best average performance is observed .this paper is a preliminary investigation and a more extensive analysis must be made to confirm that equilibrium between exploration and exploitation makes as a good technique for complex problems in static or dynamic environments .future work should address the following issues : comparison between as and changes in the neighborhood shape and size , measuring as effects with cga using mutation and crossover , change the balance of directions dynamically .the latter point is an important feature : by tuning the control parameter , it would be possible to make the algorithm to self - adjust the selective pressure , depending on global or local measures .this adaptive ability has two important advantages : first , parameter may vary in a continuous way , second , variations of this parameter have affect neither on the grid topology nor on the neighborhood shape .such self - adaptive algorithms have been studied in previous works , but they need to change the grid topology to control the selective pressure , which means it is uniform in the grid . as allows different propagation speeds on each area of the grid , promoting diversification and intensification ( exploitation ) at the same time on different spots . in general , we have to continue investigation of _ anisotropic selection _ to assess its validity and generality .m. giacobini , a. tettamanzi , and m. tomassini .modelling selection intensity for linear cellular evolutionary algorithms . in p.l. et al . ,editor , _ artificial evolution , sixth international conference , evolution artificielle , ea 2003 _ , lecture notes in computer science , pages 345356 , marseille , france , october 2003 . springer .

Abstract: in this paper we introduce a new selection scheme in cellular genetic algorithms ( cgas ) . _ anisotropic selection _ ( as ) promotes diversity and allows accurate control of the selective pressure . first we compare this new scheme with the classical rectangular grid shapes solution according to the selective pressure : we can obtain the same takeover time with the two techniques although the spreading of the best individual is different . we then give experimental results that show to what extent as promotes the emergence of niches that support low coupling and high cohesion . finally , using a cga with anisotropic selection on a quadratic assignment problem we show the existence of an anisotropic optimal value for which the best average performance is observed . further work will focus on the selective pressure self - adjustment ability provided by this new selection scheme .   [ heuristic methods ]


data compression is an area in the field of information theory that studies ways of obtaining efficient representations of information . given some general data , for instance ,text , picture , movie , represented in some form of a binary computer file the aim in data compression is to obtain a new shorter binary description of this data .this is done by assuming or searching for a structure in the data that permits removing unimportant repetitions or redundancy that exists in the original representation of the data .the development of data compression algorithm can be divided into two phases . the first phase is referred to as modelling . in this phasewe try to remove any redundancy that exists in the data and describe it in the form of a model .the second phase is coding . in this phase a description of the model and a description of how the data differs from the model are encoded . producing this descriptionis based on a prediction step .for instance , in lossless image compression the calic algorithm decides what will be the value of the next pixel in a picture , then encodes the difference between this predicted value and true value using huffman or arithmetic coding .another example is in text compression : the ppm algorithm computes the probability distribution of the next symbol and uses arithmetic coding to encode the value .  in this paperwe pose the following question : can a compressor be used for prediction ? that is , given some compressor can we use it as a black - box ( i.e. , not changing its internal workings ) to predict the next symbol in a data sequence of symbols ?the motivation behind this question is mainly theoretical since practically one can design a predictor by tackling the problem directly without the need for data compression .for instance , by modeling the source that produces the data and doing statistical estimation to learn the model s parameters and then use the estimator to predict the next symbol given the observed part of the sequence .in contrast to other works that consider compression as a means of doing inference by expanding on rissanen s minimum description length principle we take a direct approach that uses a ready - made compression algorithm as stage in our inference .theoretically , the question that we pose is interesting since prediction by compression , if it is possible , would further strengthen a basic principle of pattern recognition and statistical learning theory . the principle is known as occam s razor ( see ) : it says that given several possible explanations for an observed data one should choose the simplest explanation that is consistent with the data .as far as prediction is concerned we may interpret this principle as follows : let be a finite alphabet consisting of symbols and denote by the space of all finite sequences of symbols .given a sequence representing some observed data , , , then according to this principle one should predict the next symbol as one which requires the shortest additional description given . the word shortest is crucial since it is the basis of occam s principle . but how should one obtain the shortest description of a data sequence ?an obvious approach is to use data compression .let us denote by  ] ,  ] , representing all the possible continuations of the data sequence .compress each one and measure the length )) ] .this is our theoretical interpretation of occam s principle for the prediction paradigm .the current paper aims to check if this interpretation works in reality .our setup consists of a source capable of producing random binary sequences .the source is based on a markov chain with states which we represent as the set of binary vectors , respectively , using bits .this number of bits is referred to as the _ order _ of the source which we denote by .we alternatively use the decimal or binary representations of states . given that the source is at a state then it can change into one of only two states or .we denote the transitions into these states as the -transition and -transition , respectively . associated with state there is a conditional probability distribution  ] for each of the four states . herethe bayes optimal decision is at every state and the bayes error is . for the compressor we used ppmd without controlling the parameter( the maximal possible context size is left to be the default size of ) .our first attempt at a compression - based predictor was to try to predict not just the next single bit of but a whole future subsequence ( of length ) of .with each prediction time we associated two counters which keep the number of times that we covered bit and the number of times we predicted the value for this time instant , respectively .we divided the prediction process into two phases . in the first phase initialize all counts to zero then at each prediction time we considered prediction candidates and chose the one with the best score value ( score is specified below ) . once a subsequence was decided at time we incremented by one the counts of all covered time instants and incremented by one the counts corresponding to those time instants in the range whose value .we left the counts of the remaining time instants unchanged .this was repeated for all prediction times .then the second phase started .for all time , decide the value if else decide .we let the candidate length in bits be a parameter and together with the parameter ( describe above ) we repeated the prediction over many runs where for each run we set a different parameter value , , in increments of and .we used the following function to score a prediction candidate subsequence given the history for all times : )\label{eq : s1}\ ] ] where  ] as the extra description length needed for describing given the knowledge of ( extra meaning beyond what is needed to describe just ) .note resembles kolmogorov s combinatorial notion of conditional entropy ( see also ) . resembles kolmogorov s combinatorial information measure .indeed measures the information that provides about it shows the reduction in description length of once is used as an input for describing .however still , this did not improve the previous results .  at this point we decided to change the source .we increased the number of states to still with only two possible transitions outgoing from each state with probability and .thus the bayes error is .this made the source more complex , however , unlike before , here we used bit combinations chosen at random ( and not bits ) to represent each of the states and the sequence was now generated based on the state combinations in a non - overlapping manner . this introduced redundancy in the sequence representation .for instance , suppose the state combinations are the strings , , , and suppose that the transitions are obtained by shifting in a circular manner the bit to the left or right by one position .then an example of a sequence is : .such a scheme led to some improvement but the minimal error obtained was still above hence larger than bayes error .   at this pointwe had some more insight , mainly , that adding redundancy to the source somewhat improves prediction by compression .but in general one can not change the source of the data .so we chose to leave the source as generating the data sequence based on single bit transitions , i.e. , -transition and -transition , as described in the first paragraph on section [ sub : initial - investigation ] .the idea at this stage was to extract the information from and form a new sequence based on -bit words of where the value of is fixed in advance in the range .we call this process _peeling_. let us describe it through an example : suppose and suppose then the extracted words are ( in sequence ) : , , , .we then complete each such _ -codeword _ into an -bit word ( a byte ) by inserting zeros in the front .for this example it yields , , , .we then create a random injective map from the set to characters whose utf-8 representation fall in the range u+ to ( we write to denote a string of zeros ) .note that for this range of utf-8 each character is represented by a single byte .this is important since when we compare candidates for prediction we base it on the compressed length of the representation ( in this the representation is utf-8 encoded characters ) .having chosen to limit to single - byte utf-8 representation ensures that any two candidate sequences made up of the same number of characters will be encoded with the same length encoding sequences .we map into a sequence of characters , for instance , the above sequence could be mapped into .each symbol represents a state ( we call them _ perceived states _ since they are from the perspective of the predictor ) .the number of such states is and it need not necessarily equal the number of source s states since may differ from ( the order of the source ) .we then convert this character sequence into a sequence specifying the pairwise transitions ( except the last entry which is half full ) and repeating each transition times ( we term it the _ repeat factor _ ) .we denote this as _ transition - encoding _ scheme . for this example , suppose then it takes the following form    where the symbol has a utf-8 code .note , the last transition ( the trailer ) is half full , in this example it is , and consists of the state ( in this case ) on the right of the last transition ( ) .thus is a sequence of bytes that encode perceived - state characters , a comma or the arrow symbol .clearly , has more redundancy than since its length is times longer than yet it contains the same amount of information .obviously if the source s order is known to the predictor then a good choice is to let .if it is not known , this method can still be used by scanning over all values while testing the probability of error ( on some training sequence ) . this way a value for will be selected whenthe minimal probability of error is obtained over this range .can the score function defined in ( [ eq : s2 ] ) be used here ?instead of we have so we need to represent prediction candidates in the utf-8 symbol sequence format , denoted as , of the from . only after converting into we may attempt to concatenate them to form an utf-8 symbol sequence . in this new representationwe are coding transitions between states rather than absolute states .prediction candidates should represent a transition starting from the state that corresponds to the symbol on the right of the last pairwise transition of .for instance in the above example , this last pairwise transition is hence we should only consider the two candidates that code transitions of the from where is a symbol whose -bit codeword starts with the first bits of the codeword of and ends either with a or ( denote them as the and candidates ) . but to form the concatenation means that the right symbol of these two candidates must be the left symbol of the first transition of ( in the above example this is the symbol ) .hence there may be a conflict constraints in determining the two candidates since as in this example the symbol may not be a symbol whose codeword agrees on the first bits with the symbol .hence the score ( [ eq : s2 ] ) is not suitable .this led us to consider the following new scoring function ,  )-\lambda(\chi_{h})\right)\label{eq : syx}\ ] ]  note that we may regard )-\lambda(\chi_{h})\equiv\lambda(\xi|\chi_{h}) ] and .this makes them be indistinguishable which leads to random prediction ( since we we predict a with probability when the scores are the same ) .we realized that this is a result of the compression algorithm imperfectness .it has some constant minimal file size that it never goes below no matter how short the sequence to be compressed is .hence the next idea was to consider extending the length of each candidate by repeating it times ( where is the repeat factor for .for instance , in the above example ( [ eq : xhi ] ) where using , then if its extension is now , the lengths of the compressed version of the two strings , become distinguishable ( in our experiments we used and ) .doing that led to significant improvement and we can now see the prediction error decreasing towards the bayes error with increasing history size and increasing ppm order .note that we are still treating the case where the peeling size equals the source order ( which is less - realistic since the predictor may not know the source s order ) .let us summarize the features of the final version of the predictor :  * _ aim _ : given history at bit time , we want to predict bit , * peel -codewords from and map them into utf-8 symbols representing predictor s perceived states * represent the transitions between these states in the form and repeat each times to form the sequence .* there are two prediction candidates , , corresponding to the two possible binary predictions of the next bit in .we use the same representation of state transition to represent the two candidates .we use a repeat factor of to obtain , .* use the scoring function to score each of the two candidates .if both have the same value then predict with probability .* otherwise , predict the next bit   the next series of trials were more realistic as we allowed the predictor s peeling size to be different from the source s order .let us review the results .in the first test we considered a source of order and peeling size . in this case the number of perceived states is greater than the number of source s states . to see the effect of the compressor s ppm order on the predictor s error we performed several trial runs changing the history size andppm order and measuring the prediction error .figure [ fig:1a ] shows how decreases with respect to .we plot the error for each value of averaged out over runs of the same history size and where , , , . at this rate of decreasethe prediction error would reach the bayes error of at about .note that the error starts decreasing from its maximal value only at . at this valuethe ppm compression captures the full trailer of .its context conditional probability distribution for the next character in the sequence contains full information about the perceived state ( in the above example this is the state ) .this is a necessary condition for ppm to estimate the transition probability correctly .figures [ fig:1a ] shows that decreases steadily as we increase the ppm order .figure [ fig:1b ] shows that there is hardly any effect on the error as the history size increases .what happens when ?we tested a predictor of peeling size on a sequence produced by a source of order .figures [ fig:2a ] and [ fig:2a-1 ] show that already from we see an error close to the bayes error .next , we tested a predictor of peeling size on a sequence produced by a source of order .figures [ fig:3a ] and [ fig:3b ] show that the predictor is inaccurate since even when the order is high we still see an error which is only slightly better than pure guessing .next , we tested a predictor of peeling size on a sequence produced by a source of order .we let the history size reach up to .figures [ fig:4a ] and [ fig:4b ] show that the predictor s error decreases with increasing ppm order albeit at a slower rate than the case of and ( figures [ fig:1a],[fig:1b ] ) .this suggests that the error rate not only depends on the difference ( which in both case equals ) but also on itself .  finally , we changed the compressor s algorithm from ppm to lzma which is a recently developed algorithm that incorporates the lempel - ziv dictionary - based compressor with a new predictive component .we tested the predictor with lzma on the problem of and and instead of ppm order we used the dictionary size as a parameter .as figure [ fig : source - model - has-1 ] shows , the error initially decreases but remains above the level even as we increase the dictionary size at an exponential rate . on this same problem the ppm predictor performed very well ( figure [ fig:2 ] ) .we are not sure why the lzma underperforms compared to the ppm approach .perhaps doing prediction based on dictionary - based compression requires a different transition - encoding scheme .this requires further investigation .source model has states ( ) , peeling size is .the predictor is based on lzma compression , a dictionary - based algorithm .the prediction error is plotted with respect to , where is size of the dictionary ]in this paper we raise a new question : can a compression algorithm be used as a black - box to obtain prediction ?we introduced a new scoring function which measures the amount of information that the history gives about a candidate future prediction .we showed through a series of empirical results that this scoring function leads to successful prediction by a predictor whose decision for the next bit is obtained by maximizing the score .prediction - by - compression works and agrees with the intuition that says to choose the candidate future prediction for which the history gives a maximal amount of information .

Abstract: it is well known that text compression can be achieved by predicting the next symbol in the stream of text data based on the history seen up to the current symbol . the better the prediction the more skewed the conditional probability distribution of the next symbol and the shorter the codeword that needs to be assigned to represent this next symbol . what about the opposite direction ? suppose we have a black box that can compress text stream . can it be used to predict the next symbol in the stream ? we introduce a novel criterion based on the length of the compressed data and use it to predict the next symbol . we examine empirically the prediction error rate and its dependency on some compression parameters .