Lagrange multipliers used to be viewed as auxiliary variables introduced in a problem of constrained minimization in order to write first-order optimality conditions formally as a system of equations. Modern applications, with their emphasis on numerical methods and more complicated side conditions than equations, have demanded deeper understanding of the concept and how it fits into a larger theoretical picture. A major line of research has been the nonsmooth geometry of one-sided tangent and normal vectors to the set of points satisfying the given constraints. Another has been the game-theoretic role of multiplier vectors as solutions to a dual problem. Interpretations as generalized derivatives of the optimal value with respect to problem parameters have also been explored. Lagrange multipliers are now being seen as arising from a general rule for the subdifferentiation of a nonsmooth objective function which allows black-and-white constraints to be replaced by penalty expressions. This paper traces such themes in the current theory of Lagrange multipliers, providing along the way a freestanding exposition of basic nonsmooth analysis as motivated by and applied to this subject.

This paper introduces and studies the question of balancing the load on processors participating in a given quorum system. Our proposed measure for the degree of balancing is the ratio between the load on the least frequently referenced element and on the most frequently used one. We give some simple sufficient and necessary conditions for perfect balancing. We then look at the balancing properties of the common class of voting systems and prove that every voting system with odd total weight is perfectly balanced. (This holds, in fact, for the more general class of ordered systems.) We also give some characterizations for the balancing ratio in the worst case. It is shown that for any quorum system with a universe of size n, the balancing ratio is no smaller than 1/(n - 1), and this bound is the best possible. When restricting attention to nondominated coteries (NDCs), the bound becomes 2/ n-log 2 n+o(log n) , and there exists an NDC with ratio 2/ n-log 2 n-o(log n) . Next, ...

Abstract. New theorems of the alternative for polynomial constraints (based on the Positivstellensatz from real algebraic geometry) and for linear constraints (generalizing the transposition theorems of Motzkin and Tucker) are proved. Based on these, two Karush-John optimality conditions – holding without any constraint qualification – are proved for single- or multi-objective constrained optimization problems. The first condition applies to polynomial optimization problems only, and gives for the first time necessary and sufficient global optimality conditions for polynomial problems. The second condition applies to smooth local optimization problems and strengthens known local conditions. If some linear or concave constraints are present, the new version reduces the number of constraints for which a constraint qualification is needed to get the Kuhn-Tucker conditions.

We describe a new algorithm for proving temporal properties expressed in LTL of infinite-state programs. Our approach takes advantage of the fact that LTL properties can often be proved more efficiently using techniques usually associated with the branchingtime logic CTL than they can with native LTL tools. The caveat is that, in certain instances, nondeterminism in the system’s transition relation can cause CTL methods to report counterexamples that are spurious with respect to the original LTL formula. To address this problem we describe an algorithm that, as it attempts to apply CTL proof methods, finds and then removes problematic nondeterminism via an analysis on the potentially spurious counterexamples. Problematic nondeterminism is characterized using decision predicates, and removed using a partial and symbolic determinization procedure that introduces new prophecy variables to predict the future outcome of these decisions. We demonstrate—using examples taken from the PostgreSQL database server, Apache web server, and Windows OS kernel—that our method can yield enormous performance improvements in comparison to known tools, allowing us to automatically prove properties of programs where we could not prove them before. 1.

this paper we have given an alternative proof of Farkas's lemma, a proof that is based on a theorem, the main theorem, that relates to the eigenvectors of certain orthogonal matrices. This theorem is believed to be new, and the author is not aware of any similar theorem concerning orthogonal matrices although he recently proved the weak form of the theorem using Tucker's theorem (see [5]). His proof of the theorem is "completely elementary" (a referee) and requires little more than a knowledge of matrix algebra for its understanding. Once the theorem is established, Tucker's theorem (via the Cayley transform), Farkas's lemma and many other theorems of the alternative follow trivially. Thus the paper establishes a connection between the eigenvectors of orthogonal matrices, duality in linear programming and theorems of the alternative that is not generally appreciated, and this may be of some theoretical interest.

Abstract not found

> satisfying P () :Q (: denotes negation), in words: either P or Q but never both. Relations between (a){(f). (a) and (b) are equivalent representations. Indeed, (a) and (b) can be written as (A; A; I) 0 @ x + x s 1 A = b ; 0 @ x + x s 1 A 0 and 0 @ A A I 1 A x 0 @ b b 0 1 A ; respectively: The remaining systems involve strict inequalities or nontrivial solutions. For example, (d) and (e) concern the existence of nontrivial solutions and positive solutions, respectively, for the system Ax = 0 ;

Abstract—Dynamically allocated and manipulated data structures cannot be translated into hardware unless there is an upper bound on the amount of memory the program uses during all executions. This bound can depend on the generic parameters to the program, i.e., program inputs that are instantiated at synthesis time. We propose a constraint based method for the discovery of memory usage bounds, which leads to the firstknown C-to-gates hardware synthesis supporting programs with non-trivial use of dynamically allocated memory, e.g., linked lists maintained with malloc and free. We illustrate the practicality of our tool on a range of examples. I.

The core of a game is defined as the set of outcomes acceptable for all coalitions. This is probably the simplest and most natural concept of cooperative game theory. However, the core can be empty because there are too many coalitions. Yet, some players may not like or know each other, so they cannot form a coalition. The following generalization seems natural. Let K be a fixed family of coalitions. The K-core is defined as the set of outcomes acceptable for all the coalitions from K. Let us call a family K g-stable if the K-core is not empty for any finite normal form game, and similarly, let K be called V -stable if the K-core is not empty for for any compact superadditive NTU-game. We prove that both V - and g-stability of a family K are equivalent with the normality of K. Normal hypergraphs can be characterized by several equivalent properties, e.g. they are dual to clique hypergraphs of perfect graphs. Key words: cooperative game theory, TU-games, NTU-games, co...

Program reasoning consists of the tasks of automatically and statically verifying correctness and inferring properties of programs. Program synthesis is the task of automatically generating programs. Both program reasoning and synthesis are theoretically undecidable, but the results in this dissertation show that they are practically tractable. We show that there is enough structure in programs written by human developers to make program reasoning feasible, and additionally we can leverage program reasoning technology for automatic program synthesis. This dissertation describes expressive and efficient techniques for program reasoning and program synthesis. Our techniques work by encoding the underlying inference tasks as solutions to satisfiability instances. A core ingredient in the reduction of these problems to finite satisfiability instances is the assumption of templates. Templates are user-provided hints about the structural form of the desired artifact, e.g., invariant, pre- and postcondition templates for reasoning; or program templates for synthesis. We propose novel algorithms, parameterized by suitable templates, that reduce the inference of these artifacts to satisfiability. We show that fixed-point computation—the key technical challenge in program reasoning— is encodable as SAT instances. We also show that program synthesis can be viewed as generalized