Search

Comunicació presentada al AFRICACRYPT 2020: 12th International Conference on Cryptology in Africa, celebrat del 20 al 22 de juliol de 2021 al Caire, Egipte. This paper constructs unbounded simulation sound proofs for boolean circuit satisfiability under standard assumptions with proof size O(n+d) bilinear group elements, where d is the depth and n is the input size of the circuit. Our technical contribution is to add unbounded simulation soundness to a recent NIZK of González and Ràfols (ASIACRYPT’19) with very small overhead. Our new scheme can be used to construct the most efficient Signature-of-Knowledge based on standard assumptions that also can be composed universally with other cryptographic protocols/primitives. Karim Baghery was supported by CyberSecurity Research Flanders with reference number VR20192203.

In this paper we consider Levin's notion of mutual information in infinite 0-1-sequences, as defined in [Leonid Levin. Laws of Information Conservation (Nongrowth) and Aspects of the Foundation of Probability Theory. Problems of information transmission, vol. 10 (1974), pp. 206--211]. The respective information conservation inequalities were stated in that paper without proofs. Later some proofs appeared in the literature, however no proof of the probabilistic conservation inequality has been published yet. In this paper we prove that inequality and for the sake of completeness we present also short proofs of other properties of the said notion.

Theorem proving is one of the most widely used approaches to the verification of computer systems, and its theoretical basis is generally a proof system for formal derivation of logic formulas. In this paper, we propose a sound and complete proof system for Propositional Projection Temporal Logic (PPTL) with indexed expressions, which is a unified temporal logic that subsumes the well used Linear Temporal Logic (LTL). First, the syntax, semantics and logic laws of PPTL that allows indexed expressions are introduced, and the representation of LTL constructs by PPTL formulas is illustrated. Then, the proof system for the logic is presented which consists of axioms and inference rules for the derivation of both basic constructs and indexed expressions. To show the capability of the proof system, several examples of formal proofs are provided. Finally, the soundness and completeness of the proof system are demonstrated.

Pattern languages have been an object of study in various subfields of computer science for decades. This paper introduces and studies a decision problem on patterns called the finite distinguishability problem: given a pattern π, are there finite sets T + and T − of strings such that the only pattern language containing all strings in T + and none of the strings in T − is the language generated by π? This problem is related to the complexity of teacher-directed learning, as studied in computational learning theory, as well as to the long-standing open question whether the equivalence of two patterns is decidable. We show that finite distinguishability is decidable if the underlying alphabet is of size other than 2 or 3, and provide a number of related results, such as (i) partial solutions for alphabet sizes 2 and 3, and (ii) decidability proofs for variants of the problem for special subclasses of patterns, namely, regular, 1-variable, and non-cross patterns. For the same subclasses, we further determine the values of two complexity parameters in teacher-directed learning, namely the teaching dimension and the recursive teaching dimension.

We provide a new proof that the expected error rate of consistent support vector machines matches the minimax rate (up to a constant factor) in its dependence on the sample size and margin. The upper bound was originally established by [1] , while the lower bound follows from an argument of [2] together with reasoning about the VC dimension of large-margin classifiers. Our proof differs from the original in that many of our steps concern reasoning about the primal space, while the original carried out these steps by reasoning about the dual space. Our approach provides a unified framework for analyzing both the homogeneous and non-homogeneous cases, with slightly better results for the former. The fact that our analysis explicitly handles the non-homogeneous case offers significant improvements in the bounds compared to the usual textbook approach of reducing to the homogeneous case. We also extend our proof to provide a new upper bound on the error rate of transductive SVM, which yields an improved constant factor compared to inductive SVM. In addition to these bounds on the expected error rate, we also provide a simple proof of a margin-based PAC-style bound for support vector machines, and an extension of the agnostic PAC analysis that explicitly handles the non-homogeneous case.

We give a new approach to build tightly secure signatures for signing a vector of group elements in a bilinear group. We illustrate its usefulness to construct efficient signature schemes by giving two new constructions of partially structure preserving signature schemes, a weaker version of structure preserving signatures which are still compatible with Groth-Sahai Non-Interactive Zero-Knowledge Proofs. The first scheme is simpler to analyze, while the second scheme is more efficient and has a signature size of only 3 group elements. This is comparable to the state-of-the art in tightly secure signatures in bilinear groups without the partial structure preserving property. We finally give a third construction using the same ideas, a tightly secure signature scheme in bilinear groups which is comparable with the state-of-the-art.

When studying sequent calculi, proof theorists often have to prove properties about the systems, whether to show that they are “well-behaved”, amenable to automated proof search, complete with respect to another system, consistent, among other reasons. These proofs usually involve many very similar cases, which leads to authors rarely writing them in full detail, only pointing to one or two more complicated cases. Moreover, the amount of details makes them more error-prone for humans. Computers, on the other hand, are very good at handling details and repetitiveness. In this work we have formalized textbook proofs of the meta-theory of sequent calculi for linear logic in Abella. Using the infrastructure developed, the proofs can be easily adapted to other substructural logics. We implemented rules as clauses in an intuitive and straightforward way, similar to logic programming, using operations on multisets for the explicit contexts. Although the proofs are quite big, they use only elementary reasoning principles, which makes the proof techniques fairly portable to other formal reasoning systems.

Quasi-Adaptive Non-Interactive Zero-Knowledge (QANIZK) proofs make possible efficient NIZK with short proofs by allowing the common reference string to depend on the language. The strongest notion of (computational) soundness for QANIZK is Unbounded Simulation-Soundness (USS). For USS, however, the language is completely beyond the adversary's control. In this paper, we introduce a stronger notion of USS for QANIZK, called USS for Adversary-Dependent Languages (USS-ADL), by allowing the adversary to adaptively develop the language. We present a generic construction of efficient USS-ADL-QANIZK for diverse vector spaces (DVS) over graded rings, of which linear subspaces over bilinear groups are specific instantiations. – Our generic construction provides the first USS-QANIZK for DVS over graded rings. This complements Abdalla et al.'s work (Eurocrypt'15) of QANIZK with one-time simulation-soundness. – As for applications, USS-ADL-QANIZK leads to modular constructions of digital signature and linearly homomorphic (structure-preserving) signature schemes with black-box security reductions. The instantiations cover the efficient USS-QANIZK for linear subspaces over bilinear groups proposed by Kiltz and Wee (Eurocrypt'15), a variant of the efficient structure-preserving signature proposed by Kiltz et al. (Crypto'15) and the efficient linearly homomorphic structure-preserving signature proposed by Kiltz and Wee (Eurocrypt'15). Our USS-ADL-QANIZK provides a new perspective on their constructions and security proofs in a unified way.

Apart from few exceptions, the mathematical runtime analysis of evolutionary algorithms is mostly concerned with expected runtimes, occasionally augmented by tail bounds. In this work, we argue that stochastic domination is a notion that should be used more frequently in this area. Stochastic domination allows to formulate much more informative performance guarantees, it allows to decouple the algorithm analysis into the true algorithmic part of detecting a domination statement and the probability-theoretical part of deriving the desired probabilistic guarantees from this statement, and it helps finding simpler and more natural proofs. As particular results, we prove a variant of the fitness level theorem which shows that the runtime of the search heuristic is dominated by a sum of independent geometric random variables, we prove the first tail bounds for several classic runtime problems, and we give a short and natural proof for Witt's result that the runtime of any ( μ , p ) mutation-based algorithm on any function with unique optimum is subdominated by the runtime of a variant of the ( 1 + 1 ) EA on the OneMax function. As side-products, we determine the fastest unbiased ( 1 + 1 ) algorithm for the LeadingOnes benchmark problem, both in the general case and when restricted to static mutation operators, and we prove a Chernoff-type tail bound for sums of independent coupon collector distributions.

Larsen and Skou characterized bisimilarity over reactive probabilistic systems with a logic including negation, conjunction, and a diamond modality decorated with a probabilistic lower bound. Later on, working on continuous state spaces, Desharnais, Edalat, and Panangaden proved that negation is not necessary to characterize the same equivalence. In this paper, we redemonstrate the former result with a simpler proof and the latter result directly on discrete state spaces without resorting to measure-theoretic arguments. Moreover, we show that conjunction can be replaced by disjunction in both logics, still characterizing the same bisimilarity. To these ends, we introduce reactive probabilistic trees, a fully abstract model for reactive probabilistic systems that allows us to uniformly prove expressiveness of the four probabilistic modal logics by means of a compactness argument. Our proofs are constructive, as they induce for each considered logic an algorithm that builds a distinguishing formula in case of two inequivalent reactive probabilistic systems.

We give a characterization of NPDAs with reversal-bounded counters (NPCMs) in terms of context-free grammars with monotonic counters. We show that the grammar characterization can be used to give simple proofs of previously known results such as the semilinearity of the Parikh map of any language accepted by an NPCM. We prove a Chomsky–Schutzenberger-like theorem: A language L is accepted by an NPCM if and only if there is a k ≥ 1 and an alphabet Σ containing at least k distinguished symbols, p 1 , . . . , p k , such that L = h ( D ∩ E k ( R ) ) for some homomorphism h, Dyck language D ⊆ Σ ⁎ , and regular set R ⊆ Σ ⁎ , where E k ( R ) = { w | w ∈ R , | w | p 1 = ⋯ = | w | p k } . We also give characterizations of other machine models, such as visibly pushdown automata with reversal-bounded counters (VPCMs). We then investigate the complexity of some decision problems concerning these grammatical models. Finally, we introduce other grammatical models equivalent to NPCM.

It is well known that the "store language" of every pushdown automaton -- the set of store configurations (state and stack contents) that can appear as an intermediate step in accepting computations -- is a regular language. Here many models of language acceptors with various data structures are examined, along with a study of their store languages. For each model, an attempt is made to find the simplest model that accepts their store languages. Some connections between store languages of one-way and two-way machines generally are demonstrated, as with connections between nondeterministic and deterministic machines. A nice application of these store language results is also presented, showing a general technique for proving families accepted by many deterministic models are closed under right quotient with regular languages, resolving some open questions (and significantly simplifying proofs for others that are known) in the literature. Lower bounds on the space complexity for recognizing store languages for the languages to be non-regular are obtained., Comment: 19 pages, preprint to be submitted to a journal

An important open problem in computational complexity theory is to prove the size of circuits, namely, Boolean circuit lower bounds, necessary to solve explicit problems. We survey learning-theoretic approaches to proofs of Boolean circuit lower bounds in this paper. In particular, we discuss how to prove circuit lower bounds in uniform classes by assuming (or constructing) circuit-learning algorithms in several settings, such as the exact, probably approximately correct (PAC), and statistical query learning models.

Concurrent Constraint Programming (CCP) is a simple and powerful model of concurrency where processes interact by telling and asking constraints into a global store of partial information. Since its inception, CCP has been endowed with declarative semantics where processes are interpreted as formulas in a given logic. This allows for the use of logical machinery to reason about the behavior of programs and to prove properties of them. Nevertheless, the logical characterization of CCP programs exhibits normally a weak level of adequacy since proofs in the logical system may not correspond directly to traces of the program. In this paper, we study different encodings from CCP into intuitionistic linear logic (ILL) and we compare the level of adequacy attained in each. By relying on a focusing discipline, we show that it is possible to give a logical characterization to CCP with the highest level of adequacy. Moreover, we show how to characterize maximal-parallelism semantics for CCP by relying on a multi-focusing discipline for ILL. These results, besides giving proof techniques for CCP, entail (safe) optimizations for the execution of CCP programs. Finally, we show how to interpret CCP procedure calls as fixed points in ILL, thus opening the possibility of reasoning by induction about properties of CCP programs.

A graph-controlled insertion–deletion (GCID) system is a regulated extension of an insertion–deletion system. Such a system has several components and each component has some insertion–deletion rules. The transition is performed by any applicable rule in the current component on a string and the resultant string is then moved to the target component specified in the rule. The language of the system is the set of all terminal strings collected in the final component. The parameters in the size ( k ; n , i ′ , i ″ ; m , j ′ , j ″ ) of a GCID system denote (from left to right) the maximum number of components, the maximal length of the insertion string, the maximal length of the left context for insertion, the maximal length of the right context for insertion; the last three parameters follow a similar representation with respect to deletion. In this paper, we discuss the computational completeness of the families of GCID systems of size ( k ; 1 , i ′ , i ″ ; 1 , j ′ , j ″ ) with k ∈ { 3 , 5 } and for (nearly) all values of i ′ , i ″ j ′ , j ″ ∈ { 0 , 1 } . All proofs are based on the simulation of type-0 grammars given in Special Geffert Normal Form (SGNF). The novelty in our proof presentation is that the context-free and the non-context-free rules of the given SGNF grammar are simulated by GCID systems of different sizes and finally we combine them by stitching and overlaying to characterize the recursive enumerable languages. This proof presentation greatly simplifies and unifies the proof of such characterization results. We also connect some of the obtained GCID simulations to the domain of insertion–deletion P systems.

We extend the # operator in a natural way and derive new types of counting complexity classes. While in the case of # C classes (where C could be some circuit-based class like NC 1 ) only proofs for acceptance of some input are being counted, one can also count proofs for rejection. The Zap- C complexity classes we propose here implement this idea.We show that in certain cases Zap- C lies between # C and Gap- C which could help understanding the relationship between # C and Gap- C . In particular we consider Zap- NC 1 and polynomial size branching programs of bounded and unbounded width. Finally we argue about negative proofs in Turing machines and how those relate to open questions.

Arithmetizing computation is a crucial component of many fundamental results in complexity theory, including results that gave insight into the power of interactive proofs, multi-prover interactive proofs, and probabilistically-checkable proofs. Informally, an arithmetization is a way to encode a machine's computation so that its correctness can be easily verified via few probabilistic algebraic checks.We study the problem of arithmetizing nondeterministic computations for the purpose of constructing short probabilistically-checkable proofs (PCPs) with polylogarithmic query complexity. In such a setting, a PCP's proof length depends (at least!) linearly on the length, in bits, of the encoded computation. Thus, minimizing the number of bits in the encoding is crucial for minimizing PCP proof length.In this paper we show how to arithmetize any T-step computation on a nondeterministic Turing machine by using a polynomial encoding of length O ( T ? ( log ? T ) 2 ) . Previously, the best known length was ? ( T ? ( log ? T ) 4 ) . For nondeterministic random-access machines, our length is O ( T ? ( log ? T ) 2 + o ( 1 ) ) , while prior work only achieved ? ( T ? ( log ? T ) 5 ) .The polynomial encoding that we use is the Reed-Solomon code. When combined with the best PCPs of proximity for this code, our result yields quasilinear-size PCPs with polylogarithmic query complexity that are shorter, by at least two logarithmic factors, than in all prior work.Our arithmetization also enjoys additional properties. First, it is succinct, i.e., the encoding of the computation can be probabilistically checked in ( log ? T ) O ( 1 ) time; this property is necessary for constructing short PCPs with a polylogarithmic-time verifier. Furthermore, our techniques extend, in a certain well-defined sense, to the arithmetization of yet other NEXP-complete languages.

The "Three Squares Lemma" 9 famously explored the consequences of supposing that three squares occur at the same position in a string; essentially it showed that this phenomenon could not occur unless the longest of the three squares was at least the sum of the lengths of the other two. More recently, several papers 10,30,21,13 have greatly extended this result to a "New Periodicity Lemma" (NPL) by supposing that only two of the squares occur at the same position, with a third occurring in a neighbourhood to the right - in these cases also, similar restrictions apply. In this paper an alternative strategy is proposed: the consequences of having only two squares at neighbouring positions are carefully analyzed, and then the observation is made that the analysis applies in a straightforward way (though perhaps with complicated details) to the three neighbouring squares problem in its full generality. We then apply these new insights, first to proofs of the final two remaining unproved subcases (out of a total of 14) of the NPL 10, then to an instance of the more general problem.

We consider the problem of searching for a mobile intruder hiding in a road network given as the union of two or more lines, or two or more line segments, in the plane. Some of the intersections of the road network are occupied by stationary guards equipped with a number of searchlights, each of which can emit a single ray of light in any direction along the lines (or line segments) it is on. The goal is to detect the intruder, that is, to illuminate its location. Guards may alter the direction in which they aim a searchlight, but need to switch it off for some finite time interval to effect the change. In contrast, the intruder may move with arbitrary speed along the network (but cannot pass guards) and exploit this time interval to recontaminate previously illuminated sections of the network. For various classes of road networks characterized by the number n of lines (or line segments) comprising it and the number g ( ? n - 1 ) of possible locations of guards (fixed in advance and guaranteed to give complete coverage), we present several upper and lower bounds on the worst-case number of searchlights, each placed at one of the guard positions, required to successfully search a given road network. In particular, we prove the following results:1. min ? { 2 g - 1 , n - 2 } searchlights are sometimes necessary and min ? { 7 3 g , n } - 1 are always sufficient for searching a road network given as the union of n lines;2. ? ( g ? log ? n g ) searchlights are sometimes necessary and O ( g 2 ? log ? n ) searchlights are always sufficient for searching a road network given as the union of n line segments, and3.at most one searchlight per guard position, and hence a total of at most g searchlights, is always sufficient for searching a road network given as the union of axis-aligned lines or line segments. The proofs of the upper bounds induce algorithms for generating a search schedule for detecting the intruder using the claimed number of searchlights. The problem of searching for an intruder hiding in a road network is introduced.Upper and lower bounds on the worst-case number of searchlights are presented.The proofs of the upper bounds induce algorithms for generating a search schedule.

Cook and Reckhow proved in 1979 that the propositional pigeonhole principle has polynomial size extended Frege proofs. Buss proved in 1987 that it also has polynomial size Frege proofs; these Frege proofs used a completely different proof method based on counting. This paper shows that the original Cook and Reckhow extended Frege proofs can be formulated as quasipolynomial size Frege proofs. The key point is that st-connectivity can be used to define the Cook-Reckhow construction.

This article introduces and studies a proof system ?Exp+Res that enables us to refute quantified Boolean formulas (QBFs). The system ?Exp+Res operates in two stages: it expands all universal variables through conjunctions and refutes the result by propositional resolution. This approach contrasts with the Q-resolution calculus, which enables refuting QBFs by rules similar to propositional resolution. In practice, Q-resolution enables producing proofs from conflict-driven DPLL-based QBF solvers. The system ?Exp+Res can on the other hand certify certain expansion-based solvers. So a natural question is to ask which of the systems, Q-resolution and ?Exp+Res, is more powerful? The article gives several partial responses to this question. On the positive side, we show that ?Exp+Res can p-simulate tree Q-resolution. On the negative side, we show that ?Exp+Res does not p-simulate unrestricted Q-resolution. In the favor of ?Exp+Res we show that ?Exp+Res is more powerful than a certain fragment of Q-resolution, which is important for DPLL-based QBF solving.

In computer science, functional orbits – i.e., tracks left by the iterations of a function – in a finite domain naturally appear at a high or a low level. This paper introduces a Coq logical orbit framework, the purpose of which is to help rigorously developing software systems with some complex data structures from specification to implementation. The result is a Coq library of orbit concepts formalized as definitions, lemmas and theorems. Most of them are inspired by our previous work in geometric modelling, where combinatorial hypermaps were used to describe surface subdivisions appearing in computational geometry problems, e.g., building convex hulls or Delaunay diagrams. Now, this domain remains a reference for us, but our results are drastically extended and usable in other computer science areas. The proof of Floyd's cycle-detection algorithm, known as “the tortoise and the hare”, confirms that point. The library contains operations to observe, traverse and update orbits – addition, deletion, mutation, transposition – with proofs of their behavior. It focuses on the important case where the involved function is a partial injection. In this case, it defines a connectivity relationship and evaluates the variation of the number of connected components during updates.

A CNF is minimal if no shorter CNF representing the same function exists, where by CNF length we mean either the number of clauses or the total number of literals (sum of clause lengths). In this paper we develop a decomposition approach that can be in certain situations applied to a CNF formula when proving its minimality. We give two examples in which this decomposition approach is used. Both examples deal with pure Horn minimization, a problem defined as follows: given a pure Horn CNF, construct a logically equivalent pure Horn CNF which is the shortest possible (either w.r.t. the number of clauses or w.r.t. the total number of literals). Both presented examples give alternative proofs of known complexity results for pure Horn minimization.

We study bipartite games that arise in the context of nonlocality with the help of graph theory. Our main results are alternate proofs that deciding whether a no-communication classical winning strategy exists for certain games (called forbidden-edge and covering games) is NP-complete, while the problem of deciding if these games admit a nonsignalling winning strategy is in P. We discuss relations between quantum winning strategies and orthogonality graphs. We also show that every pseudotelepathy game yields both a proof of the Bell-Kochen-Specker theorem and an instance of a two-prover interactive proof system that is classically sound, but that becomes unsound when provers use shared entanglement.

This article describes an analytical framework for reasoning about the issue of tie breaking in algorithm theory. The core of this framework is the concept of robust algorithms. Such kind of algorithms have the convenient property that an arbitrary set of degenerate cases can be ignored without loss of generality during proofs of many important properties, e.g., runtime, space requirements, feasibility, competitive and approximation ratios. Here degeneracy is defined as a set of problem instances satisfying a certain property, and this property is independent from both the algorithm under consideration and the specific combinatorial problem structure. It turns out that robustness is related to the tie breaking policy of algorithms in two different ways. On the one hand, the set of inputs where a tie actually occurs is typically (but not always) a degenerate case. On the other hand, we show that for any algorithm there is a way to break ties such that it becomes robust. In particular, robustness is guaranteed by any tie breaking strategy that can be interpreted as symbolic perturbation. For many typical algorithms the implicit usage of symbolic perturbation can be easily verified and so the consideration of degenerate cases can be avoided during their analysis. The concept of robustness also gives a theoretical explanation of why tie breaking does often not matter at all.

International audience; We consider the following problem for oriented graphs and digraphs: Given an oriented graph (digraph) G, does it contain an induced subdivision of a prescribed digraph D? The complexity of this problem depends on D and on whether G must be an oriented graph or is allowed to contain 2-cycles. We give a number of examples of polynomial instances as well as several NP-completeness proofs.

Drift analysis has become a powerful tool to prove bounds on the runtime of randomized search heuristics. It allows, for example, fairly simple proofs for the classical problem how the (1+1) Evolutionary Algorithm (EA) optimizes an arbitrary pseudo-Boolean linear function. The key idea of drift analysis is to measure the progress via another pseudo-Boolean function (called drift function) and use deeper results from probability theory to derive from this a good bound for the runtime of the EA. Surprisingly, all these results manage to use the same drift function for all linear objective functions. In this work, we show that such universal drift functions only exist if the mutation probability is close to the standard value of $1/n$., Comment: 19 pages; This work contains parts of the GECCO 2010 and CEC 2010 papers of the same authors

Programming languages and logics, which are pervasive in Computer Science, have syntax which involves variable binding constructors. As such, reasoning about such languages in general, and formal reasoning in particular (such as within a theorem prover), requires frameworks within which the syntax may be properly represented. One key requirement is a correct representation of α-equivalence. The current literature provides a number of different definitions of the notion of α-equivalence. The formal definitions may be nameless as in the approach of de Bruijn, or have explicit names, as in the approaches that use either a renaming/substitution axiom, or instead use a notion of variable swapping. The first contribution of this paper is to draw together five definitions of α-equivalence relations and to prove formally and in detail, but using mathematics, that the relations are all equal. There are two key reasons for doing this: Firstly, the literature has many examples of proofs of results involving α-equivalence which contain technical errors. Such examples concern both the application of α-equivalence, and the meta-theory of α-equivalence itself. Secondly, the literature does not currently contain detailed presentations of such results. The point of giving the detail is partly to avoid falling into common error-traps, but mainly to provide clear mathematical machinery that will be useful to those working in the area. This includes systems of inductive rules and proofs by induction, and clear accounts of the key lemmas that support the main proofs. The second contribution is to provide two definitions of α-equivalence relations over (program) contexts, namely expressions with a single meta-variable (or “hole”). One of the definitions is already in the literature, and the other is new. We prove some basic properties of α-equivalence on contexts, and show that the two definitions give rise to the same relation.

We study non-standard number systems with negative base -@b. Instead of the Ito-Sadahiro definition, based on the transformation T"-"@b of the interval [-@b@b+1,1@b+1) into itself, we suggest a generalization using an interval [l,l+1) with l@?(-1,0]. Such numeration systems share many properties of positive base numeration introduced by Renyi, although the proofs are not always straightforward. In this paper we focus on the description of admissible digit strings and their periodicity. We address the question of the description of reference strings used in the admissibility condition. We give examples which contradict a result of Gora and show that in this aspect the negative base numeration significantly differs from the Renyi numeration.

The typical AI problem is that of making a plan of the actions to be performed by a controller so that it could get into a set of final situations, if it started with a certain initial situation.The plans, and related winning strategies, happen to be finite in the case of a finite number of states and a finite number of instant actions.The situation becomes much more complex when we deal with planning under temporal uncertainty caused by actions with delayed effects.Here we introduce a tree-based formalism to express plans, or winning strategies, in finite state systems in which actions may have quantitatively delayed effects. Since the delays are non-deterministic and continuous, we need an infinite branching to display all possible delays. Nevertheless, under reasonable assumptions, we show that infinite winning strategies which may arise in this context can be captured by finite plans.The above planning problem is specified in logical terms within a Horn fragment of affine logic. Among other things, the advantage of linear logic approach is that we can easily capture ‘preemptive/anticipative’ plans (in which a new action β may be taken at some moment within the running time of an action α being carried out, in order to be prepared before completion of action α).In this paper we propose a comprehensive and adequate logical model of strong planning under temporal uncertainty which addresses infinity concerns. In particular, we establish a direct correspondence between linear logic proofs and plans, or winning strategies, for the actions with quantitative delayed effects.

Recently, Herranz presented an identity-based ring signature scheme featuring signer verifiability where a signer can prove that he or she is the real signer by releasing an authorship proof. In this paper we show that this scheme is vulnerable to a key recovery attack in which a user’s secret signing key can be efficiently recovered through the use of two known ring signatures and their corresponding authorship proofs. In addition, we present a simple method to fix this security vulnerability by slightly modifying the authorship proof. Our modified scheme simplifies the original scheme and improves performance. To show that the modified scheme is unforgeable, we define two types of unforgeability notions for both signatures and authorship proofs. In these notions an adversary has opening capability to confirm the real signers of ring signatures and thus can manipulate authorship proofs in an adaptive way. We then prove that our modified scheme is secure in terms of these unforgeability notions.

A principal component analysis (PCA) neural network is developed for online extraction of the multiple minor directions of an input signal. The neural network can extract the multiple minor directions in parallel by computing the principal directions of the transformed input signal so that the stability-speed problem of directly computing the minor directions can be avoided to a certain extent. On the other hand, the learning algorithms for updating the net weights use constant learning rates. This overcomes the shortcoming of the learning rates approaching zero. In addition, the proposed algorithms are globally convergent so that it is very simple to choose the initial values of the learning parameters. This paper presents the convergence analysis of the proposed algorithms by studying the corresponding deterministic discrete time (DDT) equations. Rigorous mathematical proof is given to prove the global convergence. The theoretical results are further confirmed via simulations.

International audience; This paper presents an exact correspondence in typing and dynamics between polarised linear logic and a typed π-calculus based on IO-typing. The respective incremental constraints, one on geometric structures of proof-nets and one based on types, precisely correspond to each other, leading to the exact correspondence of the respective formalisms as they appear in Olivier Laurent (2003) (for proof-nets) and Kohei Honda et al. (2004) (for the π-calculus).

International audience; A focused proof system provides a normal form to cut-free proofs in which the application of invertible and non-invertible inference rules is structured. Within linear logic, the focused proof system of Andreoli provides an elegant and comprehensive normal form for cut-free proofs. Within intuitionistic and classical logics, there are various different proof systems in the literature that exhibit focusing behavior. These focused proof systems have been applied to both the proof search and the proof normalization approaches to computation. We present a new, focused proof system for intuitionistic logic, called LJF, and show how other intuitionistic proof systems can be mapped into the new system by inserting logical connectives that prematurely stop focusing. We also use LJF to design a focused proof system LKF for classical logic. Our approach to the design and analysis of these systems is based on the completeness of focusing in linear logic and on the notion of polarity that appears in Girard's LC and LU proof systems.

The Pict programming language is an implementation of the π-calculus in which executions of π-calculus terms are specified via an abstract machine. An important property of any concurrent programming language implementation is the fair execution of threads. After defining fairness for the π-calculus, we show that Pict abstract machine executions implement fair π-calculus executions. We also give new proofs of soundness and liveness for the Pict abstract machine.

In this paper a proof outline logic is introduced for the partial correctness of multi-threaded object-oriented programs like in Java. The main contribution is a generalization of the Owicki& Gries proof method for shared-variable concurrency to dynamic thread creation. This paper also provides a formal justification of this generalization in terms of soundness and completeness proofs.

We study the concept of finitary formal topology, a point-free version of a topological space with a basis of compact open subsets. The notion of finitary formal topology is defined from the perspective of the Basic Picture (introduced by the second author) and thus it is endowed with a binary positivity relation. As an application, we prove a constructive version of Stone’s representation theorem for distributive lattices. We work within the framework of a minimalist foundation (as proposed by Maria Emilia Maietti and the second author). Both inductive and co-inductive methods are used in most proofs.

The distinction between analytic and synthetic proofs is a very old and important one: An analytic proof uses only notions occurring in the proved statement while a synthetic proof uses additional ones. This distinction has been made precise by Gentzen’s famous cut-elimination theorem stating that synthetic proofs can be transformed into analytic ones.CERES (cut-elimination by resolution) is a cut-elimination method that has the advantage of considering the original proof in its full generality which allows the extraction of different analytic arguments from it. In this paper we will use an implementation of CERES to analyze Fürstenberg’s topological proof of the infinity of primes. We will show that Euclid’s original proof can be obtained as one of the analytic arguments from Fürstenberg’s proof. This constitutes a proof-of-concept example for a semi-automated analysis of realistic mathematical proofs providing new information about them.

This is a corrigendum for our paper [S. Milius, L.S. Moss, The category theoretic solution of recursive program schemes, Theoret. Comput. Sci. 366 (2006) 3–59]. The main results are correct, but we offer some changes to the definitions and proofs concerning interpreted recursive program schemes.

This paper gives a new proof for the approximation theorem and the characterisation of normalisability using intersection types for a system with ‘w and a ≤-relation that is contra-variant over arrow types. The technique applied is to define reduction on derivations and to show a strong normalisation result for this reduction. From this result, the characterisation of strong normalisation and the approximation result will follow easily; the latter, in its turn, will lead to the characterisation of (head) normalisability.

Soittola’s theorem characterizes R+- or N-rational formal power series in one variable among the rational formal power series with nonnegative coefficients. We present here a new proof of the theorem based on Soittola’s and Perrin’s proofs together with some new ideas that allows us to separate algebraic and analytic arguments.

We introduce a reasoning infrastructure for proving statements about resource consumption in a fragment of the Java Virtual Machine Language (JVML). The infrastructure is based on a small hierarchy of program logics, with increasing levels of abstraction: at the top there is a type system for a high-level language that encodes resource consumption. The infrastructure is designed to be used in a proof-carrying code (PCC) scenario, where mobile programs can be equipped with formal evidence that they have predictable resource behaviour.This article focuses on the core logic in our infrastructure, a VDM-style program logic for partial correctness, which can make statements about resource consumption alongside functional behaviour. We establish some important results for this logic, including soundness and completeness with respect to a resource-aware operational semantics for the JVML. We also present a second logic built on top of the core logic, which is used to express termination; it too is shown to be sound and complete. We then outline how high-level language type systems may be connected to these logics.The entire infrastructure has been formalized in Isabelle/HOL, both to enhance the confidence in our meta-theoretical results, and to provide a prototype implementation for PCC. We give examples to show the usefulness of this approach, including proofs of resource bounds on code resulting from compiling high-level functional programs.

The concept of distributed communication bit complexity was introduced by Dinitz, Rajsbaum, and Moran. They studied the bit complexity of Consensus and Leader Election, arriving at more or less exact bounds. This paper answers two questions on Leader Election, which remained there open. The first is to close the gap between the known upper and lower bounds, for electing a leader by two linked processors. The second is whether the suggested algorithm, sending 1.5n bits while electing a leader in a chain of even length n, is optimal, in the case when n is known to the processors. For both problems, absolutely exact bounds are found. Moreover, the presented lower bound proofs show that there is no optimal algorithm other than the suggested ones.

If every language in coNP has a constant-round interactive proof system, then the polynomial-time hierarchy collapses [R.B. Boppana, J. Håstad, S. Zachos, Does co-NP have short interactive proofs? Information Processing Letters 25 (2) (1987) 127–132]. On the other hand, the well-known LFKN protocol gives O(n)-round interactive proof systems for all languages in coNP [C. Lund, L. Fortnow, H. Karloff, N. Nisan, Algebraic methods for interactive proof systems, Journal of the Association for Computing Machinery 39 (4) (1992) 859–868]. We consider the question of whether it is possible for coNP to have interactive proof systems with polylogarithmic-round complexity. We show that this is unlikely by proving that if a coNP-complete set has a polylogarithmic-round interactive proof system, then the exponential-time hierarchy collapses. We also consider exponential versions of the Karp–Lipton theorem and Yap’s theorem.

We present a trace semantics for a language of parallel programs which share access to mutable data. We introduce a resource-sensitive logic for partial correctness, based on a recent proposal of O’Hearn, adapting separation logic to the concurrent setting. The logic allows proofs of parallel programs in which “ownership” of critical data, such as the right to access, update or deallocate a pointer, is transferred dynamically between concurrent processes. We prove soundness of the logic, using a novel “local” interpretation of traces which allows accurate reasoning about ownership. We show that every provable program is race-free.

We present a framework for formally proving that the composition of the behaviors of the different parts of a complex, real-time system ensures a desired global specification of the overall system. The framework is based on a simple compositional rely/guarantee circular inference rule, plus a methodology concerning the integration of the different parts into a whole system. The reference specification language is the TRIO metric linear temporal logic.The novelty of our approach with respect to existing compositional frameworks–most of which do not deal explicitly with real-time requirements–consists mainly in its generality and abstraction from any assumptions about the underlying computational model and from any semantic characterizations of the temporal logic language used in the specification. Moreover, the framework deals equally well with continuous and discrete time. It is supported by a tool, implemented on top of the proof-checker PVS, to perform deduction-based verification through theorem-proving of modular real-time axiom systems.As an example of application, we show the verification of a real-time version of the old-fashioned but still relevant “benchmark” of the dining philosophers problem.

The advent of proof-carrying code has generated significant interest in reasoning about low-level languages. It is widely believed that low-level languages with jumps must be difficult to reason about because of being inherently non-modular. We argue that this is untrue. We take it seriously that, unlike statements of a high-level language, pieces of low-level code are multiple-entry and multiple-exit. And we define a piece of code as consisting of either a single labelled instruction or a finite union of pieces of code. Thus we obtain a compositional natural semantics and a matching Hoare logic for a basic low-level language with jumps. By their simplicity and intuitiveness, these are comparable to the standard natural semantics and Hoare logic of While. The Hoare logic is sound and complete wrt the semantics and allows for compilation of proofs of the Hoare logic of While.

In the literature various notions of monotonicity for restarting automata have been studied. Here we introduce two new variants of monotonicity for restarting automata and for two-way restarting automata: left-monotonicity and right-left-monotonicity. It is shown that for the various types of deterministic and nondeterministic (two-way) restarting automata without auxiliary symbols, these notions yield infinite hierarchies, and we compare these hierarchies to each other. Further, as a tool used to simplify some of the proofs, the shrinking restarting automaton is introduced, which is a generalization of the standard (length-reducing) restarting automaton to the weight-reducing case. Some of the consequences of this generalization are also discussed.

Artemov's logic of proofs LP is a complete calculus of propositions and proofs, which is now becoming a foundation for the evidence-based approach to reasoning about knowledge. Additional atoms in LP have form t:F, read as “t is a proof of F” (or, more generally, as “t is an evidence for F”) for an appropriate system of terms t called proof polynomials. In this paper, we answer two well-known questions in this area. One of the main features of LP is its ability to realize modalities in any S4-derivation by proof polynomials thus revealing a statement about explicit evidences encoded in that derivation. We show that the original Artemov's algorithm of building such realizations can produce proof polynomials of exponential length in the size of the initial S4-derivation. We modify the realization algorithm to produce proof polynomials of at most quadratic length. We also found a modal formula, any realization of which necessarily requires self-referential constants of type c:A(c). This demonstrates that the evidence-based reasoning encoded by the modal logic S4 is inherently self-referential.

A grid graph has rectangularly arranged vertices with edges permitted only between orthogonally adjacent vertices. The st-connectivity principle states that it is not possible to have a red path of edges and a green path of edges which connect diagonally opposite corners of the grid graph unless the paths cross somewhere.We prove that the propositional tautologies which encode the st-connectivity principle have polynomial-size Frege proofs and polynomial-size TC0-Frege proofs. For bounded-width grid graphs, the st-connectivity tautologies have polynomial-size resolution proofs. A key part of the proof is to show that the group with two generators, both of order two, has word problem in alternating logtime (Alogtime) and even in TC0.Conversely, we show that constant depth Frege proofs of the st-connectivity tautologies require near-exponential size. The proof uses a reduction from the pigeonhole principle, via tautologies that express a “directed single source” principle SINK, which is related to Papadimitriou's search classes PPAD and PPADS (or, PSK).The st-connectivity principle is related to Urquhart's propositional Hex tautologies, and we establish the same upper and lower bounds on proof complexity for the Hex tautologies. In addition, the Hex tautology is shown to be equivalent to the SINK tautologies and to the one-to-one onto pigeonhole principle.