Mohsen Lesani

Fuzzy Trust Aggregation And Personalized Trust Inference In Virtual Social Networks

Virtual marketplaces on the Web provide people with great facilities to buy and sell goods similar to conventional markets. In traditional business, reputation is subjectively built for known persons and companies as the deals are made in the course of time. As it is important to do business with trustful individuals and companies, there is a need to survive the reputation concept in virtual markets. Auction sites generally employ reputation systems based on feedbacks that provide a global view to a cyber dealer. In contrast to global trust, people usually infer their personal trust about someone whose reputation is completely or partially unknown by asking their trusted friends. Personal reputation is what makes a person trusted for some people and untrusted for others. There should be a facility for users in a virtual market to specify how much they trust a friend and also a mechanism that infers the trust of a user to another user who is not directly a friend of her. There are two main issues that should be addressed in trust inference. First, the trust modeling and aggregation problem needs to be challenged. Second, algorithms should be introduced to find and select the best paths among the existing trust paths from a source to a sink. First, as trust to a person can be stated more naturally using linguistic expressions, this work suggests employing linguistic terms for trust specification. To this end, corresponding fuzzy sets are defined for trust linguistic terms and a fuzzy trust aggregation method is also proposed. Comparing the fuzzy aggregation method to the existing aggregation methods shows superiority of fuzzy approach especially at aggregating contradictory information. Second, this paper proposes an incremental trust inference algorithm. The results show improvement in preciseness of inference for the proposed inference algorithm over the existing and recently proposed algorithm named TidalTrust.

MrCrypt: static analysis for secure cloud computations

In a common use case for cloud computing, clients upload data and computation to servers that are managed by a third-party infrastructure provider. We describe MrCrypt, a system that provides data confidentiality in this setting by executing client computations on encrypted data. MrCrypt statically analyzes a program to identify the set of operations on each input data column, in order to select an appropriate homomorphic encryption scheme for that column, and then transforms the program to operate over encrypted data. The encrypted data and transformed program are uploaded to the server and executed as usual, and the result of the computation is decrypted on the client side. We have implemented MrCrypt for Java and illustrate its practicality on three standard benchmark suites for the Hadoop MapReduce framework. We have also formalized the approach and proven several soundness and security guarantees.

Communicating memory transactions

Many concurrent programming models enable both transactional memory and message passing. For such models, researchers have built increasingly efficient implementations and defined reasonable correctness criteria, while it remains an open problem to obtain the best of both worlds. We present a programming model that is the first to have opaque transactions, safe asynchronous message passing, and an efficient implementation. Our semantics uses tentative message passing and keeps track of dependencies to enable undo of message passing in case a transaction aborts. We can program communication idioms such as barrier and rendezvous that do not deadlock when used in an atomic block. Our experiments show that our model adds little overhead to pure transactions, and that it is significantly more efficient than Transactional Events. We use a novel definition of safe message passing that may be of independent interest.

Chapar: certified causally consistent distributed key-value stores

Today’s Internet services are often expected to stay available and render high responsiveness even in the face of site crashes and network partitions. Theoretical results state that causal consistency is one of the strongest consistency guarantees that is possible under these requirements, and many practical systems provide causally consistent key-value stores. In this paper, we present a framework called Chapar for modular verification of causal consistency for replicated key-value store implementations and their client programs. Specifically, we formulate separate correctness conditions for key-value store implementations and for their clients. The interface between the two is a novel operational semantics for causal consistency. We have verified the causal consistency of two key-value store implementations from the literature using a novel proof technique. We have also implemented a simple automatic model checker for the correctness of client programs. The two independently verified results for the implementations and clients can be composed to conclude the correctness of any of the programs when executed with any of the implementations. We have developed and checked our framework in Coq, extracted it to OCaml, and built executable stores.

A framework for formally verifying software transactional memory algorithms

We present a framework for verifying transactional memory (TM) algorithms. Specifications and algorithms are specified using I/O automata, enabling hierarchical proofs that the algorithms implement the specifications. We have used this framework to develop what we believe is the first fully formal machine-checked verification of a practical TM algorithm: the NOrec algorithm of Dalessandro, Spear and Scott. Our framework is available for others to use and extend. New proofs can leverage existing ones, eliminating significant work and complexity.

Applying and Inferring Fuzzy Trust in Semantic Web Social Networks

Social networks let the people find and know other people and benefit form their information. Semantic Web standard ontologies support social network sites for making use of other social networks information and hence help their expansion and unification, making them a huge social network. As social networks are public virtual social places much information may exist in them that may not be trustworthy to all. A mechanism in needed to rate coming news, reviews and opinions about a definite subject from users, according to each user preference. There should be a feature for users to specify how much they trust a friend and a mechanism to infer the trust from one user to another that is not directly a friend of the user so that a recommender site can benefit from these trust ratings for showing trustworthy information to each user from her or his point of view from not only her or his directly trusted friends but also the other indirectly trusted users. This work suggests using fuzzy linguistic terms to specify trust to other users and proposes an algorithm for inferring trust from a person to another person that may be not directly connected in the trust graph of a social network. The algorithm is implemented and compared to an algorithm that let the users to specify their trust with a number in a definite range. While according to the imprecise nature of the trust concept writing and reading a linguistic expression for trust is much more natural than a number for users, the results show that the algorithm offers more precise information than the previously used algorithm especially when contradictory beliefs should be composed and also when a more precise inference is potentially possible in searching deeper paths. As the trust graphs and inference are viewed abstractly, they can be well employed in other multi agent systems.

Fuzzy Trust Inference in Trust Graphs and its Application in Semantic Web Social Networks

People generate information or get it from the others. When one gets information from the others it is important to get it from trusted ones. Each individual in a society can get the information he needs form his trusted friends but there are also many other people in the society that he or she indirectly trusts and can benefit from their information. The idea of benefiting from the indirectly trusted people can well be employed in social networks where finding trusted people can be automated. There should be a feature for users to specify how much they trust a friend and a mechanism to infer the trust in the society trust graph from one user to another that is not directly a friend of the user so that a recommender site can benefit from these inferred trust ratings for showing trustworthy information to each user from her or his point of view from not only her or his directly trusted friends but also the other indirectly trusted users. A problem that is faced in inference in such a large network is contradictory information. This work suggests using fuzzy linguistic terms to specify trust to other users and proposes an algorithm for inferring trust from a person to another person that may be not directly connected in the trust graph of a social network. The algorithm is implemented and compared to the previous one that models trust as numbers in a range. While according to the imprecise nature of trust concept, writing and reading a linguistic expression for trust is much more natural than a number for users, the fuzzy composing strategy performs better than the previous algorithm in integrating conflicting beliefs and conveying the conflict in the inferred result.

Declarative fence insertion

Previous work has shown how to insert fences that enforce sequential consistency. However, for many concurrent algorithms, sequential consistency is unnecessarily strong and can lead to high execution overhead. The reason is that, often, correctness relies on the execution order of a few specific pairs of instructions. Algorithm designers can declare those execution orders and thereby enable memory-model-independent reasoning about correctness and also ease implementation of algorithms on multiple platforms. The literature has examples of such reasoning, while tool support for enforcing the orders has been lacking until now. In this paper we present a declarative approach to specify and enforce execution orders. Our fence insertion algorithm first identifies the execution orders that a given memory model enforces automatically, and then inserts fences that enforce the rest. Our benchmarks include three off-the-shelf transactional memory algorithms written in C/C++ for which we specify suitable execution orders. For those benchmarks, our experiments with the x86 and ARMv7 memory models show that our tool inserts fences that are competitive with those inserted by the original authors. Our tool is the first to insert fences into transactional memory algorithms and it solves the long-standing problem of how to easily port such algorithms to a novel memory model.

Semantics-preserving sharing actors

Actors interact by asynchronous message passing. A key semantic property of actors is that they do not share state. This facilitates data-race freedom, fault isolation and location transparency. On the other hand, strict avoidance of sharing can lead to inefficiency. We propose the sharing actor programming model that extends the actor programming model with single-writer multiple-reader sharing of data. We define the sharing actor theory and prove its semantic equivalence to the pure actor theory. We realize the sharing actor theory with an efficient implementation. The implementation benefits from sharing data but keeps it transparent to actors. To increase the confidence that the implementation complies with the semantics, we have built a checking tool based on deterministic replay of actor programs.

Automatic Atomicity Verification for Clients of Concurrent Data Structures

Mainstream programming languages offer libraries of concurrent data structures. Each method call on a concurrent data structure appears to take effect atomically. However, clients of such data structures often require stronger guarantees. For instance, a histogram class that is implemented using a concurrent map may require a method to atomically increment a histogram bar, but its implementation requires multiple calls to the map and hence is not atomic by default. Indeed, prior work has shown that atomicity errors in clients of concurrent data structures occur frequently in production code. We present an automatic and modular verification technique for clients of concurrent data structures. We define a novel sufficient condition for atomicity of clients called condensability. We present a tool called Snowflake that generates proof obligations for condensability of Java client methods and discharges them using an off-the-shelf SMT solver. We applied Snowflake to an existing suite of client methods from several open-source applications. It successfully verified 76.9% of the atomic methods without any change and verified the rest of them with small code refactoring and/or annotations.