32 research outputs found
Term Graph Representations for Cyclic Lambda-Terms
We study various representations for cyclic lambda-terms as higher-order or
as first-order term graphs. We focus on the relation between
`lambda-higher-order term graphs' (lambda-ho-term-graphs), which are
first-order term graphs endowed with a well-behaved scope function, and their
representations as `lambda-term-graphs', which are plain first-order term
graphs with scope-delimiter vertices that meet certain scoping requirements.
Specifically we tackle the question: Which class of first-order term graphs
admits a faithful embedding of lambda-ho-term-graphs in the sense that: (i) the
homomorphism-based sharing-order on lambda-ho-term-graphs is preserved and
reflected, and (ii) the image of the embedding corresponds closely to a natural
class (of lambda-term-graphs) that is closed under homomorphism?
We systematically examine whether a number of classes of lambda-term-graphs
have this property, and we find a particular class of lambda-term-graphs that
satisfies this criterion. Term graphs of this class are built from application,
abstraction, variable, and scope-delimiter vertices, and have the
characteristic feature that the latter two kinds of vertices have back-links to
the corresponding abstraction.
This result puts a handle on the concept of subterm sharing for higher-order
term graphs, both theoretically and algorithmically: We obtain an easily
implementable method for obtaining the maximally shared form of
lambda-ho-term-graphs. Also, we open up the possibility to pull back properties
from first-order term graphs to lambda-ho-term-graphs. In fact we prove this
for the property of the sharing-order successors of a given term graph to be a
complete lattice with respect to the sharing order.
This report extends the paper with the same title
(http://arxiv.org/abs/1302.6338v1) in the proceedings of the workshop TERMGRAPH
2013.Comment: 35 pages. report extending proceedings article on arXiv:1302.6338
(changes with respect to version v2: added section 8, modified Proposition
2.4, added Remark 2.5, added Corollary 7.11, modified figures in the
conclusion
Nested Term Graphs (Work In Progress)
We report on work in progress on 'nested term graphs' for formalizing
higher-order terms (e.g. finite or infinite lambda-terms), including those
expressing recursion (e.g. terms in the lambda-calculus with letrec). The idea
is to represent the nested scope structure of a higher-order term by a nested
structure of term graphs.
Based on a signature that is partitioned into atomic and nested function
symbols, we define nested term graphs both in a functional representation, as
tree-like recursive graph specifications that associate nested symbols with
usual term graphs, and in a structural representation, as enriched term graph
structures. These definitions induce corresponding notions of bisimulation
between nested term graphs. Our main result states that nested term graphs can
be implemented faithfully by first-order term graphs.
keywords: higher-order term graphs, context-free grammars, cyclic
lambda-terms, higher-order rewrite systemsComment: In Proceedings TERMGRAPH 2014, arXiv:1505.0681
The Image of the Process Interpretation of Regular Expressions is Not Closed under Bisimulation Collapse
Axiomatization and expressibility problems for Milner's process semantics
(1984) of regular expressions modulo bisimilarity have turned out to be
difficult for the full class of expressions with deadlock 0 and empty step~1.
We report on a phenomenon that arises from the added presence of 1 when 0 is
available, and that brings a crucial reason for this difficulty into focus. To
wit, while interpretations of 1-free regular expressions are closed under
bisimulation collapse, this is not the case for the interpretations of
arbitrary regular expressions.
Process graph interpretations of 1-free regular expressions satisfy the loop
existence and elimination property LEE, which is preserved under bisimulation
collapse. These features of LEE were applied for showing that an equational
proof system for 1-free regular expressions modulo bisimilarity is complete,
and that it is decidable in polynomial time whether a process graph is
bisimilar to the interpretation of a 1-free regular expression.
While interpretations of regular expressions do not satisfy the property LEE
in general, we show that LEE can be recovered by refined interpretations as
graphs with 1-transitions refined interpretations with 1-transitions (which are
similar to silent steps for automata). This suggests that LEE can be expedient
also for the general axiomatization and expressibility problems. But a new
phenomenon emerges that needs to be addressed: the property of a process graph
`to can be refined into a process graph with 1-transitions and with LEE' is not
preserved under bisimulation collapse. We provide a 10-vertex graph with two
1-transitions that satisfies LEE, and in which a pair of bisimilar vertices
cannot be collapsed on to each other while preserving the refinement property.
This implies that the image of the process interpretation of regular
expressions is not closed under bisimulation collapse.Comment: Report (14 p. + 10 p. app) written for a submission in Jan 2021 (now
with added explanation of relation with subsequent work that was published
earlier) concerning the crucial observation underlying the crystallization
process in arXiv:2209.12188 version 2: extension of Prop. 2.12 to "under star
1-free" expressions, and correction in its proof (added termination subterm
to extraction function
Milner's Proof System for Regular Expressions Modulo Bisimilarity is Complete (Crystallization: Near-Collapsing Process Graph Interpretations of Regular Expressions)
Milner (1984) defined a process semantics for regular expressions. He
formulated a sound proof system for bisimilarity of process interpretations of
regular expressions, and asked whether this system is complete.
We report conceptually on a proof that shows that Milner's system is
complete, by motivating, illustrating, and describing all of its main steps. We
substantially refine the completeness proof by Grabmayer and Fokkink (2020) for
the restriction of Milner's system to `1-free' regular expressions. As a
crucial complication we recognize that process graphs with empty-step
transitions that satisfy the layered loop-existence/elimination property LLEE
are not closed under bisimulation collapse (unlike process graphs with LLEE
that only have proper-step transitions). We circumnavigate this obstacle by
defining a LLEE-preserving `crystallization procedure' for such process graphs.
By that we obtain `near-collapsed' process graphs with LLEE whose strongly
connected components are either collapsed or of `twin-crystal' shape. Such
near-collapsed process graphs guarantee provable solutions for bisimulation
collapses of process interpretations of regular expressions.Comment: Version article submitted to LICS 2022 (with some corrections
performed already during the review process, a few afterwards, 14 pages, 2
pages of the appendix
Regularity Preserving but not Reflecting Encodings
Encodings, that is, injective functions from words to words, have been
studied extensively in several settings. In computability theory the notion of
encoding is crucial for defining computability on arbitrary domains, as well as
for comparing the power of models of computation. In language theory much
attention has been devoted to regularity preserving functions.
A natural question arising in these contexts is: Is there a bijective
encoding such that its image function preserves regularity of languages, but
its pre-image function does not? Our main result answers this question in the
affirmative: For every countable class C of languages there exists a bijective
encoding f such that for every language L in C its image f[L] is regular.
Our construction of such encodings has several noteworthy consequences.
Firstly, anomalies arise when models of computation are compared with respect
to a known concept of implementation that is based on encodings which are not
required to be computable: Every countable decision model can be implemented,
in this sense, by finite-state automata, even via bijective encodings. Hence
deterministic finite-state automata would be equally powerful as Turing machine
deciders.
A second consequence concerns the recognizability of sets of natural numbers
via number representations and finite automata. A set of numbers is said to be
recognizable with respect to a representation if an automaton accepts the
language of representations. Our result entails that there is one number
representation with respect to which every recursive set is recognizable
Expressibility in the Lambda Calculus with Letrec
We investigate the relationship between finite terms in lambda-letrec, the
lambda calculus with letrec, and the infinite lambda terms they express. As
there are easy examples of lambda-terms that, intuitively, are not unfoldings
of terms in lambda-letrec, we consider the question: How can those infinite
lambda terms be characterised that are lamda-letrec-expressible in the sense
that they can be obtained as infinite unfoldings of terms in lambda-letrec?
For 'observing' infinite lambda-terms through repeated 'experiments' carried
out at the head of the term we introduce two rewrite systems (with rewrite
relations) -reg-> and -reg+-> that decompose the term, and produce 'generated
subterms' in two notions. Thereby the sort of the step can be observed as well
as its target, a generated subterm. In both systems there are four sorts of
decomposition steps: -lambda-> steps (decomposing a lambda-abstraction), -@0>
and -@1> steps (decomposing an application into its function and argument), and
respectively, -del-> steps (delimiting the scope of an abstraction, for
-reg->), and -S-> (delimiting of scopes, for -reg+->). These steps take place
on infinite lambda-terms furnished with a leading prefix of abstractions for
gathering previously encountered lambda-abstractions and keeping the generated
subterms closed. We call an infinite lambda-term 'regular'/'strongly regular'
if its set of -reg-> -reachable / -reg-> -reachable generated subterms is
finite. Furthermore, we analyse the binding structure of lambda-terms with the
concept of 'binding-capturing chain'.
Using these concepts, we answer the question above by providing two
characterisations of lambda-letrec-expressibility. For all infinite
lambda-terms M, the following statements are equivalent: (i) M is
lambda-letrec-expressible; (ii) M is strongly regular; (iii) M is regular, and
it only has finite binding-capturing chains.Comment: 79 pages, 25 figure