Universal discrete-time reservoir computers with stochastic inputs and linear readouts using non-homogeneous state-affine systems

A new class of non-homogeneous state-affine systems is introduced for use in reservoir computing. Sufficient conditions are identified that guarantee first, that the associated reservoir computers with linear readouts are causal, time-invariant, and satisfy the fading memory property and second, that a subset of this class is universal in the category of fading memory filters with stochastic almost surely uniformly bounded inputs. This means that any discrete-time filter that satisfies the fading memory property with random inputs of that type can be uniformly approximated by elements in the non-homogeneous state-affine family.Comment: 41 page

Schema Independent Relational Learning

Learning novel concepts and relations from relational databases is an important problem with many applications in database systems and machine learning. Relational learning algorithms learn the definition of a new relation in terms of existing relations in the database. Nevertheless, the same data set may be represented under different schemas for various reasons, such as efficiency, data quality, and usability. Unfortunately, the output of current relational learning algorithms tends to vary quite substantially over the choice of schema, both in terms of learning accuracy and efficiency. This variation complicates their off-the-shelf application. In this paper, we introduce and formalize the property of schema independence of relational learning algorithms, and study both the theoretical and empirical dependence of existing algorithms on the common class of (de) composition schema transformations. We study both sample-based learning algorithms, which learn from sets of labeled examples, and query-based algorithms, which learn by asking queries to an oracle. We prove that current relational learning algorithms are generally not schema independent. For query-based learning algorithms we show that the (de) composition transformations influence their query complexity. We propose Castor, a sample-based relational learning algorithm that achieves schema independence by leveraging data dependencies. We support the theoretical results with an empirical study that demonstrates the schema dependence/independence of several algorithms on existing benchmark and real-world datasets under (de) compositions

THE IMPLICATURE AND VIOLATION OF MAXIMS IN INDONESIAN ADVERTISEMENTS

We all know that advertising is a business in which language is used to persuade people to do things (e.g., buy some product) and / or believe things (believing that the value of the product is trustworthy or a good one). The phenomenon, however, is that we tend to doubtthe truth conditions of the advertisements. In other words, we do not take those ads seriously. We are not very affected emotionally yet we are just amused and regard them as entertaining fallacies (e.g. the “AXE” male perfume). Some reasons might verify this fact. However, this paper is just concerned with the language phenomenon existing in theadvertisement world. A common shared perspective on the advertisement language within Indonesian ads is, among others, bombastic, hyperbolic, and many times, irrational. Not the least, most of the ads have a similar tendency to “violate” the language as long as theproduct sells. Apparently, Indonesian ads are apt to employ indirect language(‘implicature’) in their emulating their own product and devaluing their competitor’s product (e.g. the then Yahama’s “Yang Lain Makin Ketinggalan”). Upon these intriguing facts, this paper attempts to highlight general features of Indonesian advertisements in termsof (1) the violation of Grice’s conversational maxims (rules and norms) and (2) implicature(extended meaning). Alternating a more ‘acceptable’ model of ads could be a by-product ofthis paper

Size-Change Termination as a Contract

Termination is an important but undecidable program property, which has led to a large body of work on static methods for conservatively predicting or enforcing termination. One such method is the size-change termination approach of Lee, Jones, and Ben-Amram, which operates in two phases: (1) abstract programs into "size-change graphs," and (2) check these graphs for the size-change property: the existence of paths that lead to infinite decreasing sequences. We transpose these two phases with an operational semantics that accounts for the run-time enforcement of the size-change property, postponing (or entirely avoiding) program abstraction. This choice has two key consequences: (1) size-change termination can be checked at run-time and (2) termination can be rephrased as a safety property analyzed using existing methods for systematic abstraction. We formulate run-time size-change checks as contracts in the style of Findler and Felleisen. The result compliments existing contracts that enforce partial correctness specifications to obtain contracts for total correctness. Our approach combines the robustness of the size-change principle for termination with the precise information available at run-time. It has tunable overhead and can check for nontermination without the conservativeness necessary in static checking. To obtain a sound and computable termination analysis, we apply existing abstract interpretation techniques directly to the operational semantics, avoiding the need for custom abstractions for termination. The resulting analyzer is competitive with with existing, purpose-built analyzers