Infinite Derivations Research Articles

Metaphorical Interpretation of Early Works of Art Using Symbolization Methods

Abstract The unique style of early works of fine art depends on the infinite derivation of the image factor symbols metaphorically behind them, so the symbolic interpretation of early works of fine art is a search for the missing beauty of contemporary art. In this paper, we start from multi-scale association rules, use Gaussian pyramid and cubic convolution methods to extract image metaphor features in fine art works, and weight the features. Based on Putschke’s emotion classification, a multimodal metaphor dataset is constructed. The symbolization method is used to represent the symbolic emotions in the art works, and then the bidirectional Bi-LSTM model is used for recognition. On this basis, using the model constructed in this paper, the symbolic and imagery features of art works are analyzed, and the symbolic techniques of art works are interpreted from three perspectives: brushstroke, color, and spatial metaphor. Structural metaphors in fine art works contain 40% neutral emotions, followed by 36.4% positive emotions. Stroke A has a higher mean score at 3 and 4 line sample points, respectively, of -1.1646 and -1.1106, and the emotions triggered by these two line samples are more significant. Interpreting early art works can help enhance the aesthetics of contemporary art for modern audiences.

Variants of P systems with activation and blocking of rules

We introduce new possibilities to control the application of rules based on the preceding applications, which can be defined in a general way for (hierarchical) P systems and the main known derivation modes. Computational completeness can be obtained even with non-cooperative rules and using both activation and blocking of rules, especially for the set modes of derivation, when allowing derivation steps with no rules being applied. When we allow the application of rules to influence the application of rules in previous derivation steps, applying a non-conservative semantics for what we consider to be a valid infinite derivation, we can even “go beyond Turing”.

Unobservable Potentials to Explain Single Photon and Electron Interference

We show single photon and electron interferences can be calculated without quantum-superposition states by using tensor form (covariant quantization). From the analysis results, the scalar potential which correspond to an indefinite metric vector forms an oscillatory field and causes the interferences. The results clarify the concept of quantum-superposition states is not required for the description of the interference, which leads to an improved understanding of the uncertainty principle and resolution of paradox of reduction of the wave packet, elimination of infinite zero-point energy and derivation of spontaneous symmetry breaking. The results conclude Quantum theory is a kind of deterministic physics without "probabilistic interpretation".

Soundness and Completeness Proofs by Coinductive Methods

We show how codatatypes can be employed to produce compact, high-level proofs of key results in logic: the soundness and completeness of proof systems for variations of first-order logic. For the classical completeness result, we first establish an abstract property of possibly infinite derivation trees. The abstract proof can be instantiated for a wide range of Gentzen and tableau systems for various flavors of first-order logic. Soundness becomes interesting as soon as one allows infinite proofs of first-order formulas. This forms the subject of several cyclic proof systems for first-order logic augmented with inductive predicate definitions studied in the literature. All the discussed results are formalized using Isabelle/HOL's recently introduced support for codatatypes and corecursion. The development illustrates some unique features of Isabelle/HOL's new coinductive specification language such as nesting through non-free types and mixed recursion---corecursion.

Model checking for process rewrite systems and a class of action-based regular properties

We consider the model checking problem for Process Rewrite Systems ( PRS), an infinite-state formalism (non Turing-powerful) which subsumes many common models such as Pushdown Processes and Petri Nets. PRS can be adopted as a formal model for programs with dynamic creation and synchronization of concurrent processes, and with recursive procedures. The model-checking problem of PRS against action-based linear temporal logic ( ALTL) is undecidable. However, decidability for some interesting fragment of ALTL remains an open question. In this paper, we state decidability results concerning generalized acceptance properties about infinite derivations (infinite term rewriting) in PRS. As a consequence, we obtain decidability of the model-checking problem (restricted to infinite runs) of PRS against a meaningful fragment of ALTL.

Representation of a class of nondeterministic semiautomata by canonical words

It has been shown recently that deterministic semiautomata can be represented by canonical words and equivalences; that work was motivated by the trace-assertion method for specifying software modules. Here, we generalize these ideas to a class of nondeterministic semiautomata. A semiautomaton is settable if, for every state q , there exists a word w q such that q , and no other state, can be reached from some initial state by a path spelling w q . We extend many results from the deterministic case to settable nondeterministic semiautomata. Now each word has a number of canonical representatives. We show that a prefix-rewriting system exists for transforming any word to any of its representatives. If the set of canonical words is prefix-continuous (meaning that, if w and a prefix u of w are in the set, then all prefixes of w longer than u are also in the set), the rewriting system has no infinite derivations. Examples of specifications of nondeterministic modules are given.

REPRESENTATION OF SEMIAUTOMATA BY CANONICAL WORDS AND EQUIVALENCES

We study a novel representation of semiautomata, which is motivated by the method of trace-assertion specifications of software modules. Each state of the semiautomaton is represented by an arbitrary word leading to that state, the canonical word. The transitions of the semiautomaton give rise to a right congruence, the state-equivalence, on the set of input words of the semiautomaton: two words are state-equivalent if and only if they lead to the same state. We present a simple algorithm for finding a set of generators for state-equivalence. Directly from this set of generators, we construct a confluent prefix-rewriting system which permits us to transform any word to its canonical representative. In general, the rewriting system may allow infinite derivations. To address this issue, we impose the condition of prefix-continuity on the set of canonical words. A set is prefix-continuous if, whenever a word w and a prefix u of w are in the set, then all the prefixes of w longer than u are also in the set. Prefix-continuous sets include prefix-free and prefix-closed sets as special cases. We prove that the rewriting system is Noetherian if and only if the set of canonical words is prefix-continuous. Furthermore, if the set of canonical words is prefix-continuous, then the set of rewriting rules is irredundant. We show that each prefix-continuous canonical set corresponds to a spanning forest of the semiautomaton.

Normalisation for higher-order calculi with explicit substitutions

Explicit substitutions (ES) were introduced as a bridge between the theory of rewrite systems with binders and substitution, such as the λ -calculus, and their implementation. In a seminal paper Melliès observed that the dynamical properties of a rewrite system and its ES-based implementation may not coincide: he showed that a strongly normalising term (i.e. one which does not admit infinite derivations) in the λ -calculus may lose this status in its ES-based implementation. This paper studies normalisation for the latter systems in the general setting of higher-order rewriting: Based on recent work extending the theory of needed strategies to non-orthogonal rewrite systems we show that needed strategies normalise in the ES-based implementation of any orthogonal pattern higher-order rewrite system.

On Greatest Fixpoint Semantics of Logic Programming

The study of fixpoints has long been at the heart of logic programming. However, whereas least fixpoint semantics works well for SLD‐refutations (i.e. is sound and complete), there is no satisfactory (i.e. complete) fixpoint semantics for infinite derivations. In this paper, we focus on this problem. Standard approaches in this area consist in concentrating on infinite derivations that can be seen as computing, in the limit, some infinite object. This is usually done by extending the domain of computation with infinite elements and then defining the meaning of programs in terms of greatest fixpoints. The main drawback of these approaches is that the semantics defined is not complete. Hence, since defining a greatest fixpoint semantics for logic programs amounts to consider a program as a set of co‐inductive definitions, we focus on this identification at a deeper level by considering infinite derivations as proof‐terms in a co‐inductive set. This reading leads into considering derivations as proofs rather than computations and allows one to show that for the subclass of infinite derivations over the domain of finite terms, a complete greatest fixpoint semantics can be obtained. Our main result is that the greatest fixpoint of the one‐step‐inference operator for the C‐semantics corresponds to atoms that have a non‐failing fair derivation with the additional property that complete information over a variable is obtained after finitely many steps.

Parameter Estimation in Stochastic Logic Programs

Stochastic logic programs (SLPs) are logic programs with parameterised clauses which define a log-linear distribution over refutations of goals. The log-linear distribution provides, by marginalisation, a distribution over variable bindings, allowing SLPs to compactly represent quite complex distributions. We analyse the fundamental statistical properties of SLPs addressing issues concerning infinite derivations, ‘unnormalised’ SLPs and impure SLPs. After detailing existing approaches to parameter estimation for log-linear models and their application to SLPs, we present a new algorithm called failure-adjusted maximisation (FAM). FAM is an instance of the EM algorithm that applies specifically to normalised SLPs and provides a closed-form for computing parameter updates within an iterative maximisation approach. We empirically show that FAM works on some small examples and discuss methods for applying it to bigger problems.

Reduction of finite and infinite derivations

We present a general schema of easy normalization proofs for finite systems S like first-order arithmetic or subsystems of analysis, which have good infinitary counterparts S ∞ . We consider a new system S ∞ + with essentially the same rules as S ∞ but different derivable objects: a derivation d∈S ∞ + of a sequent Γ contains a (finite) derivation Φ(d)∈S of Γ. Three simple conditions on Φ(d) including a normal form theorem for S ∞ + easily imply a weak normalization theorem for S. We give three examples of application of this schema. First, we take S≡PA but restrict the attention to derivations of Σ 1 0 -sentences. In this case it is possible to take S ∞ + to be essentially standard formulation of PA ∞ . Next, we illustrate extension to subsystems of analysis and consider the system BI 1 ∗ of W. Buchholz having the strength of ID 1 , again for derivations of Σ 1 0 -sentences. Finally, we return to the first-order arithmetic to illustrate changes needed to treat derivations of arbitrary formulas.

Loop checking in SLD-derivations by well-quasi-ordering of goals

Loop checking mechanisms are used to detect and prune infinite SLD derivations, through run time checks which are introduced in logic program interpreters. Simple loop checks, i.e. checks which do not depend on the specific logic program, have been widely studied in literature. Since no sound and complete loop check exists even in the case of function-free programs, several subclasses have been characterized for which sound and complete loop checks can be determined. In this paper a theoretical framework for analysing properties of loop check mechanisms for logic programs is proposed, which exploits general mathematical results about well-quasi-ordered ( wqo) sets. In a way, the method can be viewed as a counterpart of well known techniques based on well-founded partial-ordering, used in termination proofs for rewriting systems and for logic programs. The main results are obtained on the basis of a combinatorial analysis of properties of wqo sets of goals. As shown in the paper, subclasses of programs, for which sound and complete simple loop checks exist, can be easily framed in the wqo approach. Reasons for the different behaviours of subsumption loop checks based on list and multiset goal comparisons are also plainly highlighted.

Finite notations for infinite terms

Buchholz (1991) presented a method to build notation systems for infinite sequent-style derivations, analogous to well-known systems of notation for ordinals. The essential feature is that from a notation one can read off by a primitive (not ε 0-) recursive function its nth predecessor and, e.g. the last rule applied. Here we extend the method to the more general setting of infinite (typed) terms, in order to make it applicable in other proof-theoretic contexts as well as in recursion theory. As examples, we use the method to 1. (1) give a new proof of a well-known trade-off theorem (Schwichtenberg, 1975), which says that detours through higher types can be eliminated by the use of transfinite recursion along higher ordinals, and 2. (2) construct a continuous normalization operator with an explicit modulus of continuity.

An Operational Semantics Framework Supporting the Incremental Construction of Derivation Trees

We describe the current state of the design and implementation of Dops, a framework for Deterministic OPerational Semantics that will support the incremental construction of derivation trees, starting from term/input pairs. This process of derivation tree expansion may terminate with either a complete derivation tree, explaining why a term/input pair evaluates to a particular output, or with a blocked incomplete derivation tree, explaining why a term/input pair fails to evaluate to an output; or the process may go on forever, yielding, in the limit, an infinite incomplete derivation tree, explaining why a term/input pair fails to evaluate to an output.The Dops metalanguage is a typed lambda calculus in which all expressions converge. Semantic rules are specified by lambda terms involving resumptions, which are used by a rule to consume the outputs of sub-evaluations and then resume the rule's work. A rule's type describes the number and kinds of sub-evaluations that the rule can initiate, and indicates whether the rule can block. The semantics of Dops is defined in an object language-independent manner as a small-step semantics on concrete derivation trees: trees involving resumptions. These concrete derivation trees can then be abstracted into ordinary derivation trees by forgetting the resumptions.

Deciding observational congruence of finite-state CCS expressions by rewriting

We propose a term rewriting approach to verify observational congruence between guarded recursive (finite-state) CCS expressions. Starting from the complete axiomatization of observational congruence for this subset of CCS, a non-terminating rewriting relation has been defined. This rewriting relation is ω-canonical over a subclass of infinite derivations, structured fair derivations, which compute all the ω-normal forms. The rewriting relation is shown to be complete with respect to the axiomatization by proving that every structured fair derivation computes a term that denotes an rτ-normal process graph. The existence of a finite representation for ω-normal forms allows the definition of a rewriting strategy that, in a finite number of rewriting steps, decides observational congruence of guarded recursive (finite-state) CCS expressions.

A Completeness Result for SLDNF-Resolution

Because of the possibility of floundering and infinite derivations, SLDNFresolution is, in general, not complete. The classical approach [17] to get a completeness result is to restrict the attention to normal programs P and normal goals G , such that P ∪ {G} is allowed and P is hierarchical. Unfortunately, the class of all normal programs and all normal goals meeting these requirements is not powerful enough to be of great practical importance. But after refining the concept of allowedness by taking modes [12] into account, we can broaden the notion of a hierarchical program, and thereby define a subclass of the class of normal programs and normal goals which is powerful enough to compute all primitive recursive functions without losing the completeness of SLDNF-resolution.

Nonterminating rewritings with head boundedness

We define here the concept of head boundedness, head normal form and head confluence of term rewriting systems that allow infinite derivations. Head confluence is weaker than confluence, but sufficient to guarantee the correctness of lazy implementations of equational logic programming languages. Then we prove several results. First, if a left-linear system is locally confluent and head-bounded, then it is head-confluent. Second, head-confluent and head-bounded systems have the head Church-Rosser property. Last, if an orthogonal system is head-terminating, then it is head-bounded. These results can be applied to generalize equational logic programming languages.

Levationis Laus

We present an expression-directed and renaming-invariant approach to linear resolution. eliminating the ‘usual’ annoyances involving the handling of variables and substitutions and culminating in strengthened forms of mgu- and lifting-lemmas. Subsequently, we give a twist to lifting ground derivations, obtaining three basic theorems on the tree of all ground derivations represented by an SLD tree. These provide fast proofs for standard theorems, results on infinite derivations, greatest fixed points, and answer the question of when these are reached after ω steps in the downward fixed-point hierarchy.

Extension table built-ins for prolog

The ET* algorithm is a complete evaluation strategy for Datalog programs, which are logic programs without function symbols. The ET* algorithm uses extension tables and depth-first iterative deepening to provide the evaluation of pure function-free logic programs as declarative specifications. Extension tables are a memo facility that the algorithm uses both to cut infinite derivation paths for complete evaluation and to optimise the evaluation of logic programs. The original implementation of the ET* algorithm incorporated extension tables as part of the Prolog database using the built-in predicates assert and retract. The advantage of implementing the extension table using the Prolog database is the portability of the ET* algorithm. There are several disadvantages, however, with this approach. One disadvantage is the cost associated with the built-in predicates assert and retract, which are known to be expensive operations in most current Prolog systems. Another disadvantage is the differences across implementations in the semantics that these built-ins provide for dynamic predicates. This paper presents an efficient implementation of extension tables as a global data structure in Prolog, which includes a set of built-in primitives for manipulating the extension table. The ET* algorithm is updated to reflect the utilisation of the global extension table data structure. The implementations of the ET* algorithm are compared using time and space performance on a variety of benchmark programs.

Short note: procedural semantics and negative information of elementary formal system

We discuss procedural semantics and inference of negated ground atoms in elementary formal system (EFS). EFS is now a logic programming with associative unification. There are two problems on the SLD-resolution when we infer negated atoms. One is existence of infinitely many unifiers for two atoms, even maximally general. This prevents us finding a proper completed definitions of EFS's corresponding to the negation as failure rule. The other problem is existence of infinite derivations. They make it difficult to reject atoms not in the least Herbrand model. In the note, we give solutions for these problems. When we use the SLD-resolution to accept formal languages defined by EFS's, we assume that every refutation begins from a ground goal. Under the assumption we solve the first problem by introducing the variable-bounded EFS, which is powerful enough to define languages. The solution for the second problem is to bound the length of every SLD-derivation. We present it as an algorithm to decide whether a ground atom is in the least Herbrand model or not. We introduce the weakly reducing EFS as a class of EFS's where our algorithm is a complete realization of the closed world assumption.