an execution model for exploiting and-or parallelism in logic programs (abstract)  several models have been developed for parallel execution of logic programming languages. most of them involve variations of two basic mechanisms: and parallelism and or parallelism.  our work [1] is situated between the and/or process model of conery [2] and the restricted and parallelism of degroot [3]. the model we have developped exploit both the and -and or- parallelism using a compile-time program-level and clause-level data dependence analysis to generate an execution graph that embodies the possible parallel executions. the execution graph is a directed acyclic graph, containing one node per atom of the clause body and two nodes for the head clause. simple tests on the terms provided at run-time determine which of the different possible executions graph is to be used.  the purpose of the program-level data dependence analysis is to tag the variables of each atom in the clause, that is, to distinguish the variables which will be yield ground, non ground or the both case after the atom reduction. this tagging allows us to get rid of the eventualities that can never happen during the execution of the program. this improves the clause- level analysis and consequently generates a reduced graph.  the result of clause-level data dependence analysis is the execution graph. it is based on the last analysis and on the dependence of atoms in the clause. this is constructed in three phases.  the first phase, presents an algorithm which automatically extracts the maximum of parallelism from the body of the clause. it starts from the initial context, and by assuming that execution of an atom transforms the context by eliminating all the variables present in the atom, assuming they become ground. we get the maximum of parallelism by choosing to execute first the atom(or atoms) that allow to instantiate the maximum  * permanent address: u.s.t.h.b, bp32 bab ezzouar algiers algeria number of variables in the clause using the tags and the weight of the atoms.  the second phase, enriches the graph by considering the possibility that an atom can produce after its execution independent non ground terms. in this case another ordering is deduced, consequently some edges are added to the graph.  the third phase deals with the possibility where the execution of the atom yields non ground but depended terms. in this case too, it means anticipating other ordering for the atoms, that is, we will consider that the atoms executed after an atom which supplies non ground dependent terms will be processed sequentially. in our approach, it is the only case where the degree of parallelism is less than that exploited in the dynamic approach of conery.  finally the graph is completed in the case where one or more nodes in the graph have no consumers (these are the nodes with no outcoming edge). we add edges which supply the logical values of the atom to the node representing the head of the clause.  the model support also the or-parallelism. the merge of the streams in the graph nodes is realized by a dynamic join algorithm that combines the multiple streams of partial solutions. we have adopted the algorithm proposed by li and martin in [4].  this model avoids the loss of parallelism due to the use of the static approach. the first improvement of this model, will be to limit the effect of the production of dependent terms to the atoms effectively affected. more details concerning this work can be found in [1].  m. belmesk