The semantics of most logics of time and probability is given via a probability distribution over threads , where a thread is a structure specifying what will be true at different points in time (in the future). When assessing the probabilities of statements such as “Event a will occur within 5 units of time of event b ,” there are many different semantics possible, even when assessing the truth of this statement within a single thread. We introduce the syntax of annotated probabilistic temporal (APT) logic programs and axiomatically introduce the key notion of a frequency function (for the first time) to capture different types of intrathread reasoning, and then provide a semantics for intrathread and interthread reasoning in APT logic programs parameterized by such frequency functions. We develop a comprehensive set of complexity results for consistency checking and entailment in APT logic programs, together with sound and complete algorithms to check consistency and entailment. The basic algorithms use linear programming, but we then show how to substantially and correctly reduce the sizes of these linear programs to yield better computational properties. We describe a real world application we are developing using APT logic programs.

A proposed framework for predicting a group's behavior associates two vectors with that group. The context vector tracks aspects of the environment in which the group functions; the action vector tracks the group's previous actions. Given a set of past behaviors consisting of a pair of these vectors and given a query context vector, the goal is to predict the associated action vector. To achieve this goal, two families of algorithms employ vector similarity. CONVEXk _NN algorithms use k-nearest neighbors in high-dimensional metric spaces; CONVEXMerge algorithms look at linear combinations of distances of the query vector from context vectors. Compared to past prediction algorithms, these algorithms are extremely fast. Moreover, experiments on real-world data sets show that the algorithms are highly accurate, predicting actions with well over 95-percent accuracy.

There's a constant need to reason about diverse cultures all over the world. Past cultural-reasoning research has focused primarily on techniques to organize, catalog, and reason about cultural and historical artifacts of the kind typically stored in a museum. This is extremely valuable. However, the term "cultural reasoning" as we use it in the previous examples (and in this article) focuses on understanding how different cultural groups today make decisions and what factors those decisions are based on. An architecture that supports cultural reasoning should, for example, be able to pinpoint characteristics that differentiate organizations engaging political action within legitimate frameworks from those engaging in violence and terror. Key in all this is that cultural reasoning must go hand in hand with environmental reasoning. We believe that any architecture to support cultural reasoning about a given group, political entity, business, or religious organization should contain these components: 1) a semantic Web extraction engine to elicit data about the organization, 2) an opinion-mining engine that captures the organization's opinions, 3) an algorithm to correlate environmental variables with actions that the organization takes, and 4) a simulation or game environment within which analysts and users can see what the organization has done and what it might do in hypothetical situations

Recent interest in managing uncertainty in data integration has led to the introduction of probabilistic schema mappings and the use of probabilistic methods to answer queries across multiple databases using two semantics: by-table and by-tuple. In this paper, we develop three possible semantics for aggregate queries: the range, distribution, and expected value semantics, and show that these three semantics combine with the by-table and by-tuple semantics in six ways. We present algorithms to process COUNT, AVG, SUM, MIN, and MAX queries under all six semantics and develop results on the complexity of processing such queries under all six semantics. We show that computing COUNT is in PTIME for all six semantics and computing SUM is in PTIME for all but the by-tuple/distribution semantics. Finally, we show that AVG, MIN, and MAX are PTIME computable for all by-table semantics and for the by-tuple/range semantics.We developed a prototype implementation and experimented with both real-world traces and simulated data. We show that, as expected, naive processing of aggregates does not scale beyond small databases with a small number of mappings. The results also show that the polynomial time algorithms are scalable up to several million tuples as well as with a large number of mappings.