317,074 research outputs found
A feasible algorithm for typing in Elementary Affine Logic
We give a new type inference algorithm for typing lambda-terms in Elementary
Affine Logic (EAL), which is motivated by applications to complexity and
optimal reduction. Following previous references on this topic, the variant of
EAL type system we consider (denoted EAL*) is a variant without sharing and
without polymorphism. Our algorithm improves over the ones already known in
that it offers a better complexity bound: if a simple type derivation for the
term t is given our algorithm performs EAL* type inference in polynomial time.Comment: 20 page
ML with PTIME complexity guarantees
Implicit Computational Complexity is a line of research where the possibility to inference a valid property for a program implies that the program runs in particular complexity class. Soft type systems are one of the research threads within the field. We present here a soft type system with ML-like polymorphism that enjoys decidable typechecking, type inference and typability problems and gives polynomial time computational guarantees for the running time of typed
programs
Unification in the Description Logic EL
The Description Logic EL has recently drawn considerable attention since, on
the one hand, important inference problems such as the subsumption problem are
polynomial. On the other hand, EL is used to define large biomedical
ontologies. Unification in Description Logics has been proposed as a novel
inference service that can, for example, be used to detect redundancies in
ontologies. The main result of this paper is that unification in EL is
decidable. More precisely, EL-unification is NP-complete, and thus has the same
complexity as EL-matching. We also show that, w.r.t. the unification type, EL
is less well-behaved: it is of type zero, which in particular implies that
there are unification problems that have no finite complete set of unifiers.Comment: 31page
A tier-based typed programming language characterizing Feasible Functionals
The class of Basic Feasible Functionals BFF is the type-2 counterpart of
the class FP of type-1 functions computable in polynomial time. Several
characterizations have been suggested in the literature, but none of these
present a programming language with a type system guaranteeing this complexity
bound. We give a characterization of BFF based on an imperative language
with oracle calls using a tier-based type system whose inference is decidable.
Such a characterization should make it possible to link higher-order complexity
with programming theory. The low complexity (cubic in the size of the program)
of the type inference algorithm contrasts with the intractability of the
aforementioned methods and does not overly constrain the expressive power of
the language
Lower Complexity Bounds for Lifted Inference
One of the big challenges in the development of probabilistic relational (or
probabilistic logical) modeling and learning frameworks is the design of
inference techniques that operate on the level of the abstract model
representation language, rather than on the level of ground, propositional
instances of the model. Numerous approaches for such "lifted inference"
techniques have been proposed. While it has been demonstrated that these
techniques will lead to significantly more efficient inference on some specific
models, there are only very recent and still quite restricted results that show
the feasibility of lifted inference on certain syntactically defined classes of
models. Lower complexity bounds that imply some limitations for the feasibility
of lifted inference on more expressive model classes were established early on
in (Jaeger 2000). However, it is not immediate that these results also apply to
the type of modeling languages that currently receive the most attention, i.e.,
weighted, quantifier-free formulas. In this paper we extend these earlier
results, and show that under the assumption that NETIME =/= ETIME, there is no
polynomial lifted inference algorithm for knowledge bases of weighted,
quantifier- and function-free formulas. Further strengthening earlier results,
this is also shown to hold for approximate inference, and for knowledge bases
not containing the equality predicate.Comment: To appear in Theory and Practice of Logic Programming (TPLP
Simple and Effective Type Check Removal through Lazy Basic Block Versioning
Dynamically typed programming languages such as JavaScript and Python defer
type checking to run time. In order to maximize performance, dynamic language
VM implementations must attempt to eliminate redundant dynamic type checks.
However, type inference analyses are often costly and involve tradeoffs between
compilation time and resulting precision. This has lead to the creation of
increasingly complex multi-tiered VM architectures.
This paper introduces lazy basic block versioning, a simple JIT compilation
technique which effectively removes redundant type checks from critical code
paths. This novel approach lazily generates type-specialized versions of basic
blocks on-the-fly while propagating context-dependent type information. This
does not require the use of costly program analyses, is not restricted by the
precision limitations of traditional type analyses and avoids the
implementation complexity of speculative optimization techniques.
We have implemented intraprocedural lazy basic block versioning in a
JavaScript JIT compiler. This approach is compared with a classical flow-based
type analysis. Lazy basic block versioning performs as well or better on all
benchmarks. On average, 71% of type tests are eliminated, yielding speedups of
up to 50%. We also show that our implementation generates more efficient
machine code than TraceMonkey, a tracing JIT compiler for JavaScript, on
several benchmarks. The combination of implementation simplicity, low
algorithmic complexity and good run time performance makes basic block
versioning attractive for baseline JIT compilers
NGOs and the Foreign donations
There has been possibility on the new type of corruption done by the NGOs by using the access on the foreign aid in Indonesia. In the other hand, the role of the NGOs in Indonesia is still important in order to gain the social empowerment for the sake of social conductivity on social process i.e.: economy, politics, and cultural. We built the model by using fuzzy inference system to approach the complexity of the measurement problem of the effectiveness the foreign aid received by the NGOs. Eventually, we show how the fuzzy adaptive system should be built as the analytical tools for evaluating the activities of the NGOs regarding the donation they received and the social empowerment function inherent in them.NGOs, Indonesia, Foreign Aid, International Donators, Fuzziology, fuzzy set, fuzzy inference system.
- …