Theoretical Computer Science
POPL '88 Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Information and Computation
LICS '98 Proceedings of the 13th Annual IEEE Symposium on Logic in Computer Science
Linear logic and elementary time
Information and Computation - Special issue: ICC '99
Soft linear logic and polynomial time
Theoretical Computer Science - Implicit computational complexity
Optimizing optimal reduction: A type inference algorithm for elementary affine logic
ACM Transactions on Computational Logic (TOCL)
Resource control for synchronous cooperative threads
Theoretical Computer Science - Concurrency theory (CONCUR 2004)
Feasible reactivity in a synchronous Π-calculus
Proceedings of the 9th ACM SIGPLAN international conference on Principles and practice of declarative programming
APLAS '09 Proceedings of the 7th Asian Symposium on Programming Languages and Systems
Typing termination in a higher-order concurrent imperative language
Information and Computation
An elementary affine λ-calculus with multithreading and side effects
TLCA'11 Proceedings of the 10th international conference on Typed lambda calculi and applications
A polytime functional language from light linear logic
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
Type-Based complexity analysis for fork processes
FOSSACS'13 Proceedings of the 16th international conference on Foundations of Software Science and Computation Structures
| Hi-index | 0.00 |
The framework of Light Logics has been extensively studied to control the complexity of higher-order functional programs. We propose an extension of this framework to multithreaded programs with side effects, focusing on the case of polynomial time. After introducing a modal λ-calculus with parallel composition and regions, we prove that a realistic call-by-value evaluation strategy can be computed in polynomial time for a class of well-formed programs. The result relies on the simulation of call-by-value by a polynomial shallow-first strategy which preserves the evaluation order of side effects. Then, we provide a polynomial type system that guarantees that well-typed programs do not go wrong. Finally, we illustrate the expressivity of the type system by giving a programming example of concurrent iteration producing side effects over an inductive data structure.