17 research outputs found
A Temporal Framework for Hypergame Analysis of Cyber Physical Systems in Contested Environments
Game theory is used to model conflicts between one or more players over resources. It offers players a way to reason, allowing rationale for selecting strategies that avoid the worst outcome. Game theory lacks the ability to incorporate advantages one player may have over another player. A meta-game, known as a hypergame, occurs when one player does not know or fully understand all the strategies of a game. Hypergame theory builds upon the utility of game theory by allowing a player to outmaneuver an opponent, thus obtaining a more preferred outcome with higher utility. Recent work in hypergame theory has focused on normal form static games that lack the ability to encode several realistic strategies. One example of this is when a player’s available actions in the future is dependent on his selection in the past. This work presents a temporal framework for hypergame models. This framework is the first application of temporal logic to hypergames and provides a more flexible modeling for domain experts. With this new framework for hypergames, the concepts of trust, distrust, mistrust, and deception are formalized. While past literature references deception in hypergame research, this work is the first to formalize the definition for hypergames. As a demonstration of the new temporal framework for hypergames, it is applied to classical game theoretical examples, as well as a complex supervisory control and data acquisition (SCADA) network temporal hypergame. The SCADA network is an example includes actions that have a temporal dependency, where a choice in the first round affects what decisions can be made in the later round of the game. The demonstration results show that the framework is a realistic and flexible modeling method for a variety of applications
A survey of large-scale reasoning on the Web of data
As more and more data is being generated by sensor networks, social media and organizations, the Webinterlinking this wealth of information becomes more complex. This is particularly true for the so-calledWeb of Data, in which data is semantically enriched and interlinked using ontologies. In this large anduncoordinated environment, reasoning can be used to check the consistency of the data and of asso-ciated ontologies, or to infer logical consequences which, in turn, can be used to obtain new insightsfrom the data. However, reasoning approaches need to be scalable in order to enable reasoning over theentire Web of Data. To address this problem, several high-performance reasoning systems, whichmainly implement distributed or parallel algorithms, have been proposed in the last few years. Thesesystems differ significantly; for instance in terms of reasoning expressivity, computational propertiessuch as completeness, or reasoning objectives. In order to provide afirst complete overview of thefield,this paper reports a systematic review of such scalable reasoning approaches over various ontologicallanguages, reporting details about the methods and over the conducted experiments. We highlight theshortcomings of these approaches and discuss some of the open problems related to performing scalablereasoning
Design and Evaluation of Algorithms for Parallel Classification of Ontologies
Description Logics are a family of knowledge representation formalisms with formal semantics. In recent years, DLs have influenced the design and standardization of the Web Ontology Language OWL. The acceptance of OWL as a web standard has promoted the widespread utilization of DL ontologies on the web. One of the most frequently used inference services of description logic reasoners classifies all named classes of OWL ontologies into a subsumption hierarchy. Due to emerging OWL ontologies from the web community consisting of up to hundreds of thousand of named classes and the increasing availability of multi-processor and multi- or many-core computers, the need for parallelizing description logic inference services to achieve a better scalability is expected.
The contribution of this thesis has two aspects. On a theoretical level, it first presents algorithms to construct a TBox in parallel, which are independent of a particular DL logic, however they sacrifice completeness. Then, a sound and complete algorithm for TBox classification in parallel is presented. In this algorithm all the subsumption relationships between concepts of a partition assigned to a single thread are found correctly, in other words, correctness of the TBox subsumption hierarchy is guaranteed. Thereafter, we provide an extension of the sound and complete algorithm which is used to handle TBox classification concurrently and more efficiently. This thesis also describes an optimization technique suitable for better partitioning the list of concepts to be inserted into the TBox.
On a practical level, a running prototype, Parallel TBox Classifier was implemented for each generation of the classifier based on the above theoretical foundations, respectively. The Parallel TBox Classifier is used to evaluate the practical merit of the proposed algorithms as well as the effectiveness of the designed optimizations against existing state-of-the-art benchmarks. The empirical results illustrate that Parallel TBox Classifier outperforms the Sequential TBox Classifier on real world ontologies with a linear or superlinear speedup factor. Parallel TBox Classifier can form a basis to develop more efficient parallel classification techniques for real world ontologies with different sizes and DL complexities
Order-Sorted Equational Computation
The expressive power of many-sorted equational logic can be greatly enhanced by allowing for subsorts and multiple function declarations. In this paper we study some computational aspects of such a logic. We start with a self-contained introduction to order-sorted equational logic including initial algebra semantics and deduction rules. We then present a theory of order-sorted term rewriting and show that the key results for unsorted rewriting extend to sort decreasing rewriting. We continue with a review of order-sorted unification and prove the basic results.
In the second part of the paper we study hierarchical order-sorted specifications with strict partial functions. We define the appropriate homomorphisms for strict algebras and show that every strict algebra is base isomorphic to a strict algebra with at most one error element. For strict specifications, we show that their categories of strict algebras have initial objects. We validate our approach to partial functions by proving that completely defined total functions can be defined as partial without changing the initial algebra semantics. Finally, we provide decidable sufficient criteria for the consistency and strictness of ground confluent rewriting systems
CLASS: A Logical Foundation for Typeful Programming with Shared State
Software construction depends on imperative state sharing and concurrency, which are
naturally present in several application domains and are also exploited to improve the
structure and efficiency of computer programs. However, reasoning about concurrency
and shared mutable state is hard, error-prone and the source of many programming bugs,
such as memory leaks, data corruption, deadlocks and non-termination.
In this thesis, we develop CLASS: a core session-based language with a lightweight
substructural type system, that results from a principled extension of the propositions-astypes
correspondence with second-order classical linear logic. More concretely, CLASS
offers support for session-based communication, mutex-protected first-class reference cells,
dynamic state sharing, generic polymorphic algorithms, data abstraction and primitive
recursion.
CLASS expresses and types significant realistic programs, that manipulate memoryefficient
linked data structures (linked lists, binary search trees) with support for updates
in-place, shareable concurrent ADTs (counters, stacks, functional and imperative queues),
resource synchronisation methods (fork-joins, barriers, dining philosophers, generic corecursive
protocols). All of these examples are guaranteed to be safe, a result that follows
by the logical approach.
The linear logical foundations guarantee that well-typed CLASS programs do not
go wrong: they never deadlock on communication or reference cell acquisition, do not
leak memory and always terminate, even if they share complex data structures protected
by synchronisation primitives. Furthermore, since we follow a propositions-as-types
approach, we can reason about the behaviour of concurrent stateful processes by algebraic
program manipulation.
The feasibility of our approach is witnessed by the implementation of a type checker
and interpreter for CLASS, which validates and guides the development of many realistic
programs. The implementation is available with an open-source license, together with
several examples.A construção de software depende de estado partilhado imperativo e concorrência, que
estão naturalmente presentes em vários domínios de aplicação e que também são explorados
para melhorar o a estrutura e o desempenho dos programas. No entanto, raciocinar
sobre concorrência e estado mutável partilhado é difícil e propenso à introdução de erros e
muitos bugs de programação, tais como fugas de memória, corrupção de dados, programas
bloqueados e programas que não terminam a sua execução.
Nesta tese, desenvolvemos CLASS: uma linguagem baseada em sessões, com um
sistema de tipos leve e subestrutural, que resulta de uma extensão metodológica da
correspondência proposições-como-tipos com a lógica linear clássica de segunda ordem.
Mais concretamente, a linguagem CLASS oferece suporte para comunicação baseada em
sessões, células de memória protegidas com mutexes de primeira classe, partilha dinâmica
de estado, algoritmos polimórficos genéricos, abstração de dados e recursão primitiva.
A linguagem CLASS expressa e tipifica programas realistas significativos, que manipulam
estruturas de dados ligadas eficientes (listas ligadas, árvores de pesquisa binária)
suportando actualização imperativa local, TDAs partilhados e concorrentes (contadores,
pilhas, filas funcionais e imperativas), métodos de sincronização e partilha de recursos
(bifurcar-juntar, barreiras, jantar de filósofos, protocolos genéricos corecursivos). Todos
estes exemplos são seguros, uma garantia que resulta da nossa abordagem lógica.
Os fundamentos, baseados na lógica linear, garantem que programas em CLASS bem
tipificados não incorrem em erros: nunca bloqueiam, quer na comunicação, quer na
aquisição de células de memória, nunca causam fugas de memória e terminam sempre,
mesmo que compartilhem estruturas de dados complexas protegidas por primitivas de
sincronização. Além disso, uma vez que seguimos uma abordagem de proposições-comotipos,
podemos raciocinar sobre o comportamento de processos concorrentes, que usam
estado, através de manipulação algébrica.
A viabilidade da nossa abordagem é evidenciada pela implementação de um verificador
de tipos e interpretador para a linguagem CLASS, que valida e orienta o desenvolvimento
de vários programs realistas. A implementação está disponível com uma licença
de acesso livre, juntamente com inúmeros exemplos