A First-Order Logic with Frames

TL;DR

Frame Logic (FL) is a new logical framework that extends first-order logic with support constructs, enabling elegant reasoning about models and programs that involve dynamic updates and local specifications.

Contribution

The paper introduces Frame Logic, a novel extension of first-order logic with support constructs, and demonstrates its expressiveness and applicability to program reasoning and separation logic.

Findings

Captures data-structures using FL.

Provides translation from separation logic fragment to FL.

Designs a program logic based on FL for heap updates.

Abstract

We propose a novel logic, called Frame Logic (FL), that extends first-order logic (with recursive definitions) using a construct Sp(.) that captures the implicit supports of formulas -- the precise subset of the universe upon which their meaning depends. Using such supports, we formulate proof rules that facilitate frame reasoning elegantly when the underlying model undergoes change. We show that the logic is expressive by capturing several data-structures and also exhibit a translation from a precise fragment of separation logic to frame logic. Finally, we design a program logic based on frame logic for reasoning with programs that dynamically update heaps that facilitates local specifications and frame reasoning. This program logic consists of both localized proof rules as well as rules that derive the weakest tightest preconditions in FL.

Equations

$$\begin{array}[]{rrcl}\text{FL formulas:}&\varphi&::=&\bot\mid\top\mid t_{\_}\tau=t_{\_}\tau\mid R(t_{\_}{\tau_{\_}1},\ldots,t_{\_}{\tau_{\_}m})\mid\varphi\land\varphi\mid\lnot\varphi\mid\mathit{ite}(\gamma:\varphi,\varphi)\mid\exists y:\gamma.~{}\varphi\\ &&&\mbox{$\tau\in S$, $R\in\mathcal{R}\cup\mathcal{I}$ of type $\tau_{\_}1\times\cdots\times\tau_{\_}m$}\\ \text{Guards:}&\gamma&::=&t_{\_}\tau=t_{\_}\tau\mid R(t_{\_}{\tau_{\_}1},\ldots,t_{\_}{\tau_{\_}m})\mid\gamma\land\gamma\mid\lnot\gamma\mid\mathit{ite}(\gamma:\gamma,\gamma)\mid\exists y:\gamma.~{}\gamma\\ &&&\mbox{$\tau\in S\setminus\{\sigma_{\textsf{S(f)}}\}$, $R\in\mathcal{R}$ of type $\tau_{\_}1\times\cdots\times\tau_{\_}m$}\\ \text{Terms:}&t_{\_}\tau&::=&c\mid x\mid f(t_{\_}{\tau_{\_}1},\ldots,t_{\_}{\tau_{\_}m})\mid\mathit{ite}(\gamma:t_{\_}\tau,t_{\_}\tau)\mid\\ &&&\textit{Sp}(\varphi)~{}~{}\text{(if $\tau=\sigma_{\textsf{S(f)}}$)}\mid\textit{Sp}(t_{\_}{\tau^{\prime}})~{}~{}\text{(if $\tau=\sigma_{\textsf{S(f)}}$)}\\ &&&\mbox{$\tau,\tau^{\prime}\in S$ with constants $c$, variables $x$ of type $\tau$,}\\ &&&\mbox{and functions $f$ of type $\tau_{\_}1\times\cdots\times t_{\_}m\rightarrow\tau$}\\ \lx@intercol\text{Recursive definitions: $R(\vec{x}):=\rho_{\_}R(\vec{x})$ with $R\in\mathcal{I}$ of type $\tau_{\_}1\times\cdots\times\tau_{\_}m$ with}\hfil\lx@intercol\\ &&&\text{$\tau_{\_}i\in S\setminus\{\sigma_{\textsf{S(f)}}\}$, FL formula $\rho_{\_}R(\vec{x})$ where all relation symbols}\\ &&&\text{ $R^{\prime}\in\mathcal{I}$ occur only positively or inside a support{} expression.}\end{array}\normalsize$$

$$tree(x):=$$

$$\alpha =$$

$$\text{Sp}(tree(\ell ))\cap \text{Sp}(tree(r))=\varnothing \wedge \neg (x\in \text{Sp}(tree(\ell ))\cup \text{Sp}(tree(r)))$$

$$\begin{array}[]{rcl}\llbracket\textit{Sp}(c)\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(x)\rrbracket_{M}(\nu)=\emptyset\mbox{ for a constant $c$ or variable $x$}\\ \llbracket\textit{Sp}(f(t_{\_}1,\ldots,t_{\_}n))\rrbracket_{M}(\nu)&=&\begin{cases}\bigcup\limits_{\_}{i\text{ with }t_{\_}i\text{ of sort }\sigma_{\textsf{f}}}\{\llbracket t_{\_}i\rrbracket_{M,\nu}\}\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)&\mbox{if }f\in F_{\textsf{m}}\\ \bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)&\mbox{if }f\not\in F_{\textsf{m}}\end{cases}\\ \llbracket\textit{Sp}(\textit{Sp}(\varphi))\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)\\ \llbracket\textit{Sp}(\textit{Sp}(t))\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(t)\rrbracket_{M}(\nu)\\ \llbracket\textit{Sp}(\top)\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\top)\rrbracket_{M}(\nu)=\emptyset\\ \llbracket\textit{Sp}(\bot)\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\top)\rrbracket_{M}(\nu)=\emptyset\\ \llbracket\textit{Sp}(t_{\_}1=t_{\_}2)\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(t_{\_}1)\rrbracket_{M}(\nu)\cup\llbracket\textit{Sp}(t_{\_}2)\rrbracket_{M}(\nu)\\ \llbracket\textit{Sp}(R(t_{\_}1,\ldots,t_{\_}n))\rrbracket_{M}(\nu)&=&\bigcup_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)\mbox{ for $R\in\mathcal{R}$}\\ \llbracket\textit{Sp}(R(\overline{t}))\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\rho_{\_}R(\overline{x}))\rrbracket_{M}(\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M,\nu}])\cup\bigcup_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)\\ &&\text{for $R\in\mathcal{I}$ with definition $R(\overline{x}):=\rho_{\_}R(\overline{x})$},\\ &&\overline{t}=(t_{\_}1,\ldots,t_{\_}n),\overline{x}=(x_{\_}1,\ldots,x_{\_}n)\\ \llbracket\textit{Sp}(\alpha\land\beta)\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\alpha)\rrbracket_{M}(\nu)\cup\llbracket\textit{Sp}(\beta)\rrbracket_{M}(\nu)\\ \llbracket\textit{Sp}(\lnot\varphi)\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)\\ \llbracket\textit{Sp}(\mathit{ite}(\gamma:\alpha,\beta))\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\gamma)\rrbracket_{M}(\nu)\cup\begin{cases}\llbracket\textit{Sp}(\alpha)\rrbracket_{M}(\nu)\mbox{ if }M,\nu\models\gamma\\ \llbracket\textit{Sp}(\beta)\rrbracket_{M}(\nu)\mbox{ if }M,\nu\not\models\gamma\end{cases}\\ \llbracket\textit{Sp}(\mathit{ite}(\gamma:t_{\_}1,t_{\_}2))\rrbracket_{M}(\nu)&=&\llbracket\textit{Sp}(\gamma)\rrbracket_{M}(\nu)\cup\begin{cases}\llbracket\textit{Sp}(t_{\_}1)\rrbracket_{M}(\nu)\mbox{ if }M,\nu\models\gamma\\ \llbracket\textit{Sp}(t_{\_}2)\rrbracket_{M}(\nu)\mbox{ if }M,\nu\not\models\gamma\end{cases}\\ \llbracket\textit{Sp}(\exists y:\gamma.\varphi)\rrbracket_{M}(\nu)&=&\bigcup\limits_{\_}{u\in D_{\_}y}\llbracket\textit{Sp}(\gamma)\rrbracket_{M}(\nu[y\leftarrow u])\cup\bigcup\limits_{\_}{u\in D_{\_}y;M,\nu[y\leftarrow u]\models\gamma}\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu[y\leftarrow u])\end{array}$$

$$[[R(\overline{x}){]]}_M=[[{\rho }_{\_}R(\overline{x}){]]}_M.$$

$$\begin{array}[]{l}\llbracket\textit{Sp}(f(t_{\_}1,\ldots,t_{\_}n))\rrbracket_{M}(\nu)\\ {}=\bigcup\limits_{\_}{i\text{ with }t_{\_}i\text{ of sort }\sigma_{\textsf{f}}}\{\llbracket t_{\_}i\rrbracket_{M,\nu}\}\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)\end{array}$$

$$\begin{array}[]{l}\llbracket\textit{Sp}(f(t_{\_}1,\ldots,t_{\_}n))\rrbracket_{\mu_{\mathrm{f}}(M_{\_}1)}(\nu)\\ =\bigcup\limits_{\_}{i\text{ with }t_{\_}i\text{ of sort }\sigma_{\textsf{f}}}\{\llbracket t_{\_}i\rrbracket_{M_{\_}1,\nu}\}\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}1}(\nu)\\ \stackrel{{\scriptstyle(1)}}{{=}}\bigcup\limits_{\_}{i\text{ with }t_{\_}i\text{ of sort }\sigma_{\textsf{f}}}\{\llbracket t_{\_}i\rrbracket_{M_{\_}2,\nu}\}\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}1}(\nu)\\ \stackrel{{\scriptstyle(2)}}{{\subseteq}}\bigcup\limits_{\_}{i\text{ with }t_{\_}i\text{ of sort }\sigma_{\textsf{f}}}\{\llbracket t_{\_}i\rrbracket_{M_{\_}2,\nu}\}\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}2}(\nu)\\ =\llbracket\textit{Sp}(f(t_{\_}1,\ldots,t_{\_}n))\rrbracket_{\mu_{\mathrm{f}}(M_{\_}2)}(\nu)\end{array}$$

$$\begin{array}[]{l}\llbracket\textit{Sp}(R(\overline{t}))\rrbracket_{\mu_{\mathrm{f}}(M_{\_}1)}(\nu)\\ =\llbracket\textit{Sp}(\rho_{\_}R(\overline{x})\rrbracket_{M_{\_}1}(\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M_{\_}1,\nu}])\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}1}(\nu)\\ \stackrel{{\scriptstyle(*)}}{{\subseteq}}\llbracket\textit{Sp}(\rho_{\_}R(\overline{x})\rrbracket_{M_{\_}2}(\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M_{\_}2,\nu}])\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}2}(\nu)\\ =\llbracket\textit{Sp}(R(\overline{t}))\rrbracket_{\mu_{\mathrm{f}}(M_{\_}2)}(\nu)\end{array}$$

$$\begin{array}[]{ll}&M_{\_}\eta,\nu\models\exists y:\gamma.\varphi\\ \Leftrightarrow&\mbox{exists }u\in D_{\_}y:M_{\_}\eta,\nu[y\leftarrow u]\models\gamma\\ &\mbox{ and }M_{\_}\eta,\nu[y\leftarrow u]\models\varphi\\ \stackrel{{\scriptstyle(*)}}{{\Leftrightarrow}}&\mbox{exists }u\in D_{\_}y:M_{\_}\eta^{\prime},\nu[y\leftarrow u]\models\gamma\\ &\mbox{ and }M_{\_}\eta^{\prime},\nu[y\leftarrow u]\models\varphi\\ \Leftrightarrow&M_{\_}\eta^{\prime},\nu\models\exists y:\gamma.\varphi\end{array}$$

$$\begin{array}[]{rcl}M_{\_}{\eta+1},\nu\models R(\overline{t})&\Leftrightarrow&M_{\_}\eta,\nu\models\rho_{\_}R(\overline{t})\\ &\Leftrightarrow&M_{\_}\eta,\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M_{\_}\eta,\nu}]\models\rho_{\_}R(\overline{x})\\ &\stackrel{{\scriptstyle(*)}}{{\Leftrightarrow}}&M_{\_}\eta^{\prime},\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M_{\_}\eta^{\prime},\nu}]\models\rho_{\_}R(\overline{x})\\ &\Leftrightarrow&M_{\_}{\eta+1}^{\prime},\nu\models R(\overline{t})\end{array}$$

$$\begin{array}[]{rcl}\llbracket\textit{Sp}(\varphi)\rrbracket_{M_{\_}\eta}(\nu)&=&\llbracket\textit{Sp}(\gamma)\rrbracket_{M_{\_}\eta}(\nu)\cup\llbracket\textit{Sp}(\varphi_{\_}1)\rrbracket_{M_{\_}\eta}(\nu)\\ &\stackrel{{\scriptstyle(*)}}{{=}}&\llbracket\textit{Sp}(\gamma)\rrbracket_{M_{\_}\eta^{\prime}}(\nu)\cup\llbracket\textit{Sp}(\varphi_{\_}1)\rrbracket_{M_{\_}\eta^{\prime}}(\nu)\\ &=&\llbracket\textit{Sp}(\varphi)\rrbracket_{M_{\_}\eta^{\prime}}(\nu)\end{array}$$

$$\begin{array}[]{l}\llbracket\textit{Sp}(R(\overline{t}))\rrbracket_{M_{\_}{\eta+1}}(\nu)\\ =\llbracket\textit{Sp}(\rho_{\_}R(\overline{x}))\rrbracket_{M_{\_}{\eta}}(\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M_{\_}\eta,\nu}])\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}\eta}(\nu)\\ \stackrel{{\scriptstyle(*)}}{{=}}\llbracket\textit{Sp}(\rho_{\_}R(\overline{x}))\rrbracket_{M_{\_}{\eta}^{\prime}}(\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M_{\_}\eta^{\prime},\nu}])\cup\bigcup\limits_{\_}{i=1}^{n}\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M_{\_}\eta^{\prime}}(\nu)\\ =\llbracket\textit{Sp}(R(\overline{t}))\rrbracket_{M_{\_}{\eta+1}^{\prime}}(\nu)\end{array}$$

$$\begin{array}[]{rcl}\textit{Sp}_{\_}c(\overline{y},z)&:=&\bot~{}~{}~{}~{}\mbox{ for a constant $c$}\\[3.0pt] \textit{Sp}_{\_}x(\overline{y},z)&:=&\bot~{}~{}~{}~{}\mbox{ for a variable $x$}\\[3.0pt] \textit{Sp}_{\_}{f(t_{\_}1,\ldots,t_{\_}n)}(\overline{y},z)&:=&\begin{cases}\left(\bigvee\limits_{\_}{t_{\_}i\text{ of sort }\sigma_{\textsf{f}}}z=t_{\_}i\right)\lor\bigvee\limits_{\_}{i=1}^{n}\textit{Sp}_{\_}{t_{\_}i}(\overline{y},z)&\mbox{if }f\in F_{\textsf{m}}\\[3.0pt] \bigvee\limits_{\_}{i=1}^{n}\textit{Sp}_{\_}{t_{\_}i}(\overline{y},z)&\mbox{if }f\not\in F_{\textsf{m}}\end{cases}\\[3.0pt] \textit{Sp}_{\_}{\textit{Sp}(\beta)}(\overline{y},z)&:=&\textit{Sp}_{\_}{\beta}(\overline{y},z)\\[3.0pt] \textit{Sp}_{\_}{R(t_{\_}1,\ldots,t_{\_}n)}(\overline{y},z)&:=&\bigvee_{\_}{i=1}^{n}\textit{Sp}_{\_}{t_{\_}i}(\overline{y},z)\mbox{ for $R\in\mathcal{R}$}\\[3.0pt] \textit{Sp}_{\_}{(\top)}(\overline{y},z)&:=&\bot\\[3.0pt] \textit{Sp}_{\_}{(\bot)}(\overline{y},z)&:=&\bot\\[3.0pt] \textit{Sp}_{\_}{(t_{\_}1=t_{\_}2)}(\overline{y},z)&:=&\textit{Sp}_{\_}{t_{\_}1}(\overline{y},z)\lor\textit{Sp}_{\_}{t_{\_}2}(\overline{y},z)\\[3.0pt] \textit{Sp}_{\_}{R(\overline{t})}(\overline{y},z)&:=&\textit{Sp}_{\_}{\rho_{\_}{R(\overline{x})}}(\overline{y},z)[\overline{t}/\overline{x}]\lor\bigvee_{\_}{i=1}^{n}\textit{Sp}_{\_}{t_{\_}i}(\overline{y},z)\\[3.0pt] &&\mbox{for $R\in\mathcal{I}$ with definition $R(\overline{x}):=\rho_{\_}R(\overline{x})$}\\[3.0pt] \textit{Sp}_{\_}{\beta_{\_}1\land\beta_{\_}2}(\overline{y},z)&:=&\textit{Sp}_{\_}{\beta_{\_}1}(\overline{y},z)\lor\textit{Sp}_{\_}{\beta_{\_}2}(\overline{y},z)\\[3.0pt] \textit{Sp}_{\_}{\lnot\beta}(\overline{y},z)&:=&\textit{Sp}_{\_}{\beta}(\overline{y},z)\\[3.0pt] \textit{Sp}_{\_}{\mathit{ite}(\gamma:\beta_{\_}1,\beta_{\_}2)}(\overline{y},z)&:=&\textit{Sp}_{\_}{\gamma}(\overline{y},z)\lor\mathit{ite}(\gamma:\textit{Sp}_{\_}{\beta_{\_}1}(\overline{y},z),\textit{Sp}_{\_}{\beta_{\_}2}(\overline{y},z))\\[3.0pt] \textit{Sp}_{\_}{\mathit{ite}(\gamma:t_{\_}1,t_{\_}2)}(\overline{y},z)&:=&\textit{Sp}_{\_}{\gamma}(\overline{y},z)\lor\mathit{ite}(\gamma:\textit{Sp}_{\_}{t_{\_}1}(\overline{y},z),\textit{Sp}_{\_}{t_{\_}2}(\overline{y},z))\\[3.0pt] \textit{Sp}_{\_}{\exists x:\gamma.\beta}(\overline{y},z)&:=&\exists x.(\textit{Sp}_{\_}{\gamma}(\overline{y},z)\lor(\gamma\land\textit{Sp}_{\_}{\beta}(\overline{y},z)))\end{array}$$

$$list(x):=$$

$$dll(x):=$$

$$prev(z)=x\wedge dll(z)\wedge x\notin \text{Sp}(dll(z))))$$

$$lseg(x,y):=$$

$$length(x,n):=$$

$$slist(x):=$$

$$key(x)\le key(z)\wedge slist(z)\wedge x\notin \text{Sp}(slist(z))))$$

$$mkeys(x,M):=$$

$$M=M_{\_}1{\cup }_{\_}m\{key(x)\}\wedge mkeys(z,M_{\_}1))\wedge x\notin \text{Sp}(mkeys(z,M_{\_}1))$$

$$btree(x):=$$

$$btree(\ell )\wedge btree(r)\wedge x\notin \text{Sp}(btree(\ell ))\wedge x\notin \text{Sp}(btree(r))\wedge$$

$$\text{Sp}(btree(\ell ))\cap \text{Sp}(btree(r))=\varnothing )$$

$$minkey(x,n):=$$

$$n_{\_}1=minkey(l)\wedge n_{\_}2=minkey(r).n=min(n_{\_}1,key(x),n_{\_}2))$$

$$maxkey(x,n):=$$

$$n_{\_}1=maxkey(l)\wedge n_{\_}2=maxkey(r).n=max(n_{\_}1,key(x),n_{\_}2))$$

$$bst(x):=$$

$$maxkey(l,maxl)\wedge minkey(r,minr).$$

$$maxl\le key(x)\wedge key(x)\le minr\wedge$$

$$bst(\ell )\wedge bst(r)\wedge x\notin \text{Sp}(bst(\ell ))\wedge x\notin \text{Sp}(bst(r))\wedge$$

$$\text{Sp}(bst(\ell ))\cap \text{Sp}(bst(r))=\varnothing ))))$$

$$0pt(x,n):=$$

$$0pt(\ell ,n_{\_}1)\wedge 0pt(r,n_{\_}2)\wedge ite(n_{\_}1>n_{\_}2:n=n_{\_}1+1,n=n_{\_}2+1))$$

$$bfac(x,b):=$$

$$0pt(\ell ,n_{\_}1)\wedge 0pt(r,n_{\_}2)\wedge b=n_{\_}2-n_{\_}1)$$

$$avl(x):=$$

$$avl(\ell )\wedge avl(r)\wedge bfac(x)\in \{-1,0,1\}\wedge$$

$$x\notin \text{Sp}(avl(\ell ))\cup \text{Sp}(avl(r))\wedge \text{Sp}(avl(\ell ))\cap \text{Sp}(avl(r))=\varnothing )$$

$$ttree(x):=$$

$$pttree(x,p):=$$

$$((r=nil\wedge tnext(x)=p)\vee (r\ne nil\wedge tnext(x)=r))\wedge$$

$$pttree(\ell ,x)\wedge pttree(r,p)\wedge x\notin \text{Sp}(pttree(\ell ,x))\cup \text{Sp}(pttree(r,p))\wedge$$

$$\text{Sp}(pttree(\ell ,x))\cap \text{Sp}(pttree(r,p))=\varnothing )$$

Full text

Program Verification, Program Logics, Heap Verification, First-Order Logic, First-Order Logic with Recursive Definitions

††copyright: acmcopyright††journalyear: 2018††doi: XXXXXXX.XXXXXXX††conference: Make sure to enter the correct conference title from your rights confirmation emai; June 03–05, 2018; Woodstock, NY††price: 15.00††isbn: 978-1-4503-XXXX-X/18/06††ccs: Computer systems organization Embedded systems††ccs: Computer systems organization Redundancy††ccs: Computer systems organization Robotics††ccs: Networks Network reliability

1. Introduction

Program logics for expressing and reasoning with programs that dynamically manipulate heaps is an active area of research. The research on separation logic has argued convincingly that it is highly desirable to have localized logics that talk about small states (heaplets rather than the global heap), and the ability to do frame reasoning. Separation logic achieves this objective by having a tight heaplet semantics and using special operators, primarily a separating conjunction operator $*$ and a separating implication operator (the magic wand $-*$).

In this paper, we ask a fundamental question: can logics such as FOL and FOL with recursive definitions be extended to support localized specifications and frame reasoning? Can we utilize such logics for reasoning effectively with programs that dynamically manipulate heaps, with the aid of local specifications and frame reasoning?

The primary contribution of this paper is to endow the first-order logic with recursive definitions (with least fixpoint semantics) with frames and frame reasoning.

A formula in first-order logic with recursive definitions (FO-RD) can be naturally associated with a support— the subset of the universe that determines its truth. By using a more careful syntax such as guarded quantification (which continue to have a classical interpretation), we can in fact write specifications in FO-RD that have very precise supports. For example, we can write the property that $x$ points to a linked list using a formula $list(x)$ written purely in FO-RD so that its support is precisely the locations constituting the linked list.

In this paper, we define an extension of FO-RD, called Frame Logic (FL) where we allow a new operator $\textit{Sp}(\alpha)$ which, for an FO-RD formula $\alpha$, evaluates to the support of $\alpha$. Logical formulas thus have access to supports and can use it to separate supports and do frame reasoning. For instance, the logic can now express that two lists are disjoint by asserting that $\textit{Sp}(list(x))\cap\textit{Sp}(list(y))=\emptyset$. It can then reason that in such a program heap configuration, if the program manipulates only the locations in $\textit{Sp}(list(y))$, then $list(x)$ would continue to be true, using simple frame reasoning. We can also avoid blowup while doing this by defining macros, such as $\textit{Star}(\alpha,\beta)=\alpha\wedge\beta\wedge\textit{Sp}(\alpha)\cap\textit{Sp}(\beta)=\emptyset$. In addition, FL allows for us to omit this subformula expressing disjoint supports. We can simply write the formula $\mathit{list}(x)\land\mathit{list}(y)$ to represent lists that may or may not be overlapping. Such formulas are very difficult to write in Separation Logic.

The addition of the support operator to FO-RD yields a very natural logic for expressing specifications. First, formulas in FO-RD have the same meaning when viewed as FL formulas. For example, $f(x)=y$ (written in FO-RD as well as in FL) is true in any model that has $x$ mapped by $f$ to $y$, instead of a specialized “tight heaplet semantics” that demands that $f$ be a partial function with the domain only consisting of the location $x$. The fact that the support of this formula contains only the location $x$ is important, of course, but is made accessible using the support operator, i.e., $\textit{Sp}(f(x)=y)$ gives the singleton set containing the element interpreted for $x$111For a pointer $f$ we denote by $f(x)=y$ that $x$ points to $y$ on $f$ i.e., $x\overset{f}{\mapsto}y$, whose “footprint” is $\{x\}$ in many heap logics. Second, properties of supports can be naturally expressed using set operations. To state that the lists pointed to by $x$ and $y$ are disjoint, we don’t need special operators (such as the $*$ operator in separation logic) but can express this as $\textit{Sp}(list(x))\cap\textit{Sp}(list(y))=\emptyset$. Third, when used to annotate programs, pre/post specifications for programs written in FL can be made implicitly local by interpreting their supports to be the localized heaplets accessed and modified by programs, yielding frame reasoning akin to program logics that use separation logic. Finally, as we show in this paper, the weakest precondition of specifications across basic loop-free paths can be expressed in FL, making it an expressive logic for reasoning with programs. Separation logic, on the other hand, introduces the magic wand operator $-*$ (which is inherently higher-order) in order to add enough expressiveness to be closed under weakest preconditions (Reynolds, 2002).

We define frame logic (FL) as an extension of FO with recursive definitions (FO-RD) that operates over a multi-sorted universe, with a particular foreground sort (used to model locations on the heap on which pointers can mutate) and several background sorts that are defined using separate theories. Supports for formulas are defined with respect to the foreground sort only. A special background sort of sets of elements of the foreground sort is assumed and is used to model the supports for formulas. For any formula $\varphi$ in the logic, we have a special construct $\textit{Sp}(\varphi)$ that captures its support, a set of locations in the foreground sort, that intuitively corresponds to the precise subdomain of functions the value of $\varphi$ depends on. We then prove a frame theorem (Theorem 3.7) that says that changing a model $M$ by changing the interpretation of functions that are not in the support of $\varphi$ will not affect the truth of the formula $\varphi$. This theorem then directly supports frame reasoning; if a model satisfies $\varphi$ and the model is changed so that the changes made are disjoint from the support of $\varphi$, then $\varphi$ will continue to hold. We also show that FL formulas can be translated to vanilla FO-RD logic (without support operators); in other words, the semantics for the support of a formula can be captured in FO-RD itself222The blowup of translation from FL to FO-RD is only linear; this can be seen from Figure 2.. Consequently, we can use any FO-RD reasoning mechanism (proof systems (Kovács and Voronkov, 2013; Kovács et al., 2017) or heuristic algorithms such as the natural proof techniques (Madhusudan et al., 2012; Pek et al., 2014; Qiu et al., 2013; Suter et al., 2010)) to reason with FL formulas.

We illustrate our logic using several examples drawn from program verification; we show how to express various data-structure definitions and the elements they contain and various measures for them using FL formulas (e.g., linked lists, sorted lists, list segments, binary search trees, AVL trees, lengths of lists, heights of trees, set of keys stored in the data-structure, etc.)

While the sensibilities of our logic are definitely inspired by separation logic, there are some fundamental differences beyond the fact that our logic extends the syntax and semantics of first-order logic with recursive definitions with a special support operator and avoids operators such as $*$ and $-*$. In separation logic, there can be many supports of a formula (also called heaplets)— a heaplet for a formula is one that supports its truth. For example, a formula of the form $\alpha\vee\beta$ can have a heaplet that supports the truth of $\alpha$ or one that supports the truth of $\beta$. However, the philosophy that we follow in our design is to have a single support that supports the truth value of a formula, whether it be true or false. Consequently, the support of the formula $\alpha\vee\beta$ is the union of the supports of the formulas $\alpha$ and $\beta$.

The above design choice of the support being determined by the formula has several consequences that lead to a deviation from separation logic. For instance, the support of the negation of a formula $\varphi$ is the same as the support of $\varphi$. And the support of the formula $f(x)=y$ and its negation are the same, namely the singleton location interpreted for $x$. In separation logic, the corresponding formula will have the same heaplet but its negation will include all other heaplets. The choice of having determined supports or heaplets is not new, and there have been several variants and sublogics of separation logics that have been explored. For example, the logic Dryad (Qiu et al., 2013; Pek et al., 2014) is a separation logic that insists on determined heaplets to support automated reasoning, and the precise fragment of separation logic studied in the literature (O’Hearn et al., 2004) defines a sublogic that has (essentially) determined heaplets. The second main contribution in this paper is to show that this fragment of separation logic (with slight changes for technical reasons) can be translated to frame logic, such that the unique heaplet that satisfies a precise separation logic formula is its support of the corresponding formula in frame logic.

The third main contribution of this paper is a program logic based on frame logic for a simple while-programming language destructively updating heaps. We present two kinds of proof rules for reasoning with such programs annotated with pre- and post-conditions written in frame logic. The first set of rules are local rules that axiomatically define the semantics of the program, using the smallest supports for each command. We also give a frame rule that allows arguing preservation of properties whose supports are disjoint from the heaplet modified by a program. These rules are similar to analogous rules in separation logic. The second class of rules work to give a weakest tightest precondition for any postcondition with respect to non-recursive programs. In separation logic, the corresponding rules for weakest preconditions are often expressed using separating implication (the magic wand operator). Given a small change made to the heap and a postcondition $\beta$, the formula $\alpha$ $-*$ $\beta$ captures all heaplets $H$ where if a heaplet that satisfies $\alpha$ is joined with $H$, then $\beta$ holds. When $\alpha$ describes the change effected by the program, $\alpha$ $-*$ $\beta$ captures, essentially, the weakest precondition. However, the magic wand is a very powerful operator that calls for quantifications over heaplets and submodels, and hence involves second-order quantification (Brochenin et al., 2008). In our logic, we show that we can capture the weakest precondition with only first-order quantification, and hence first-order frame logic is closed under weakest preconditions across non-recursive programs blocks. This means that when inductive loop invariants are given also in FL, reasoning with programs reduces to reasoning with FL. By translating FL to pure FO-RD formulas, we can use FO-RD reasoning techniques to reason with FL, and hence programs.

Our work is in large part inspired by our previous work on reasoning with Dryad (Qiu et al., 2013; Pek et al., 2014; Löding et al., 2018) using FO-reasoning engines, in particular SMT solvers. Dryad is a separation logic that has, essentially, unique heaplets, and this is crucial in translation to FO without quantifiers over sets (for example, quantifying over two heaplets to reason with $\alpha*\beta$). Dryad does not have the magic wand and is therefore not closed under weakest preconditions. We imbibe this philosophy fundamentally in the design of Frame Logic— the support for formulas is uniquely defined. When converting Dryad formulas to FO-RD, the translation has separate components for capturing truth and heaplets (especially heaplets for inductively defined datastructures), and the correctness of the heaplet definition is not derived or verified to be correct in the works in (Qiu et al., 2013; Pek et al., 2014; Löding et al., 2018). Frame Logic addresses this disadvantage by ensuring that the support of formulas are systematically captured using first-order logic (by the Frame Logic to FO-RD translation). Frame Logic is also closed under weakest preconditions. Reasoning with Dryad also proceeds using a verification condition technique based on strongest post, which avoids introducing unnecessary quantification. From our experience in working with both Dryad and Frame Logic, we believe that logical engines to reason with FO-RD formulas derived from Frame Logic will be as successfully amenable to automation as Dryad is, especially when adapted to verification conditions derived using the strongest-post. Such an extension is considerable effort, however, and we leave this to future work. We provide further discussion in Section 6.2.

In summary, the contributions of this paper are:

• •

A logic, called frame logic (FL) that extends FO-RD with a support operator and supports frame reasoning. We illustrate FL with specifications of various data-structures. We show a translation to equivalent formulas in FO-RD.

• •

A program logic and proof system based on FL including local rules and rules for computing the weakest tightest precondition. FL reasoning required for proving programs is hence reducible to reasoning with FO-RD.

• •

A separation logic fragment that can generate only precise formulas, and a translation from this logic to equivalent FL formulas.

The paper is organized as follows. Section 2 sets up first-order logics with recursive definitions (FO-RD), with a special uninterpreted foreground sort of locations and several background sorts/theories. Section 3 introduces Frame Logic (FL), its syntax, its semantics which includes a discussion of design choices for supports, proves the frame theorem for FL, shows a reduction of FL to FO-RD, and illustrates the logic by defining several data-structures and their properties using FL. Section 4 develops a program logic based on FL, illustrating them with proofs of verification of programs. Section 5 introduces a precise fragment of separation logic and shows its translation to FL. Section 6 discusses comparisons of FL to separation logic, and some existing first-order techniques that can be used to reason with FL. Section 7 compares our work with the research literature and Section 8 has concluding remarks.

This paper is an extension of our work at ESOP 2020 (Murali et al., 2020a). In this work we present a cleaner operational semantics, a simpler program logic, and give detailed proofs of all our results. We also present detailed comparisons in the discussion section (Sec. 6) and the section on related work (Sec. 7).

2. Background: First-Order Logic with Recursive Definitions

and Uninterpreted Combinations of Theories

The base logic upon which we build frame logic is a first order logic with recursive definitions (FO-RD), where we allow a foreground sort and several background sorts, each with their individual theories (like arithmetic, sets, arrays, etc.). The logic FO-RD is essentially the same as the classical first-order logic with least fixpoints (FO+lfp) studied in finite model theory and databases from the 1980s (Libkin, 2004; Vardi, 1982; Immerman, 1982; Aho and Ullman, 1979; Chandra and Harel, 1980). The only difference is that we give names to recursive definitions that have least fixpoint semantics. (Logics with inductive definitions over non-mononotonic bodies are also studied in the literature; see Section 7) on related work.

The foreground sort and functions involving the foreground sort are uninterpreted (not constrained by theories). This hence can be seen as an uninterpreted combination of theories over disjoint domains. This logic has been defined and used to model heap verification before (Löding et al., 2018).

We will build frame logic over such a framework where supports are modeled as subsets of elements of the foreground sort. When modeling heaps in program verification using logic, the foreground sort will be used to model locations of the heap, uninterpreted functions from the foreground sort to foreground sort will be used to model pointers, and uninterpreted functions from the foreground sort to the background sort will model data fields. Consequently, supports will be subsets of locations of the heap, which is appropriate as these are the domains of pointers that change when a program updates a heap.

We define a signature as $\Sigma=(S;C;F;\mathcal{R};\mathcal{I})$, where $S$ is a finite non-empty set of sorts. $C$ is a set of constant symbols, where each $c\in C$ has some sort $\tau\in S$. $F$ is a set of function symbols, where each function $f\in F$ has a type of the form $\tau_{\_}1\times\ldots\times\tau_{\_}m\rightarrow\tau$ for some $m$, with $\tau_{\_}i,\tau\in S$. The sets $\mathcal{R}$ and $\mathcal{I}$ are (disjoint) sets of relation symbols, where each relation $R\in\mathcal{R}\cup\mathcal{I}$ has a type of the form $\tau_{\_}1\times\ldots\times\tau_{\_}m$. The set $\mathcal{I}$ contains those relation symbols for which the corresponding relations are inductively defined using formulas (details are given below), while those in $\mathcal{R}$ are given by the model.

We assume that the set of sorts contains a designated “foreground sort” denoted by $\sigma_{\textsf{f}}$. All the other sorts in $S$ are called background sorts, and for each such background sort $\tau$ we allow the constant symbols of type $\tau$, function symbols that have type $\tau^{n}\rightarrow\tau$ for some $n$, and relation symbols have type $\tau^{m}$ for some $m$, to be constrained using an arbitrary theory $T_{\_}\tau$.

A formula in first-order logic with recursive definitions (FO-RD) over such a signature is of the form $(\mathcal{D},\alpha)$, where $\mathcal{D}$ is a set of recursive definitions of the form $R(\vec{x}):=\rho_{\_}R(\vec{x})$, where $R\in\mathcal{I}$ and $\rho_{\_}R(\vec{x})$ is a first-order logic formula, in which the relation symbols from $\mathcal{I}$ occur only positively, where each symbol from $\mathcal{I}$ is under an even number of negations. $\alpha$ is also a first-order logic formula over the signature. We assume $\mathcal{D}$ has at most one definition for any inductively defined relation, and that the formulas $\rho_{\_}R$ and $\alpha$ use only inductive relations defined in $\mathcal{D}$.

The semantics of a formula is standard; the semantics of inductively defined relations are defined to be the least fixpoint that satisfies the relational equations, and the semantics of $\alpha$ is the standard one defined using these semantics for relations. We do not formally define the semantics, but we will formally define the semantics of frame logic which is an extension of FO-RD.

3. Frame Logic

We now define Frame Logic (FL), the central contribution of this paper.

We consider a universe with a foreground sort and several background sorts, each restricted by individual theories, as described in Section 2. We consider the elements of the foreground sort to be locations and consider supports as sets of locations, i.e., sets of elements of the foreground sort. We hence introduce a background sort $\sigma_{\textsf{S(f)}}$; the elements of sort $\sigma_{\textsf{S(f)}}$ model sets of elements of sort $\sigma_{\textsf{f}}$. Among the relation symbols in $\mathcal{R}$ there is the relation $\in$ of type $\sigma_{\textsf{f}}\times\sigma_{\textsf{S(f)}}$ that is interpreted as the usual element relation. The signature includes the standard operations on sets $\cup$, $\cap$ with the usual meaning, the unary function $\widetilde{\cdot}$ that is interpreted as the complement on sets (with respect to the set of foreground elements), and the constant $\emptyset$. For these functions and relations we assume a background theory $B_{\_}{\sigma_{\textsf{S(f)}}}$ that is an axiomatization of the theory of sets. We further assume that the signature does not contain any other function or relation symbols involving the sort $\sigma_{\textsf{S(f)}}$.

For reasoning about changes of the structure over the locations, we assume that there is a nonempty subset $F_{\textsf{m}}\subseteq F$ of function symbols that are declared mutable. These functions can be used to model mutable pointer fields in the heap that can be manipulated by a program and thus change. Formally, we require that each $f\in F_{\textsf{m}}$ has at least one argument of sort $\sigma_{\textsf{f}}$.

For variables, let $\mathit{Var}_{\_}\tau$ denote the set of variables of sort $\tau$, where $\tau\in S$. We let $\overline{x}$ abbreviate tuples $x_{\_}1,\ldots,x_{\_}n$ of variables.

Our frame logic over uninterpreted combinations of theories is a variant of first-order logic with recursive definitions that has an additional operator $\textit{Sp}(\varphi)$ that assigns to each formula $\varphi$ a set of elements (its support or “heaplet” in the context of heaps) in the foreground universe. So $\textit{Sp}(\varphi)$ is a term of sort $\sigma_{\textsf{S(f)}}$.

The intended semantics of $\textit{Sp}(\varphi)$ (and of the inductive relations) is defined formally as a least fixpoint of a set of equations. This semantics is presented in Section 3.3. In the following, we first define the syntax of the logic, then discuss informally the various design decisions for the semantics of supports, before proceeding to a formal definition of the semantics

3.1. Syntax of Frame Logic (FL)

The syntax of our logic is given in the grammar in Figure 1. This extends FO-RD with the rule for building support expressions, which are terms of sort $\sigma_{\textsf{S(f)}}$ of the form $\textit{Sp}(\alpha)$ for a formula $\alpha$, or $\textit{Sp}(t)$ for a term $t$.

The formulas defined by $\gamma$ are used as guards in existential quantification and in the if-then-else-operator, which is denoted by $\mathit{ite}$. The restriction compared to general formulas is that guards cannot use inductively defined relations ($R$ ranges only over $\mathcal{R}$ in the rule for $\gamma$, and over $\mathcal{R}\cup\mathcal{I}$ in the rule for $\varphi$), nor terms of sort $\sigma_{\textsf{S(f)}}$ and thus no support expressions ($\tau$ ranges over $S\setminus\{\sigma_{\textsf{S(f)}}\}$ in the rules for $\gamma$ and over $S$ in the rule for $\varphi$). The requirement that the guard does not use the inductive relations and support expressions is used later to ensure the existence of least fixpoints for defining semantics of inductive definitions. The semantics of an $\mathit{ite}$-formula $\mathit{ite}(\gamma:\alpha,\beta)$ is the same as the one of $(\gamma\land\alpha)\lor(\lnot\gamma\land\beta)$; however, the supports of the two formulas will turn out to be different (i.e., $\textit{Sp}(\mathit{ite}(\gamma:\alpha,\beta))$ and $\textit{Sp}((\gamma\land\alpha)\lor(\lnot\gamma\land\beta))$ are different), as explained in Section 3.2. The same is true for existential formulas, i.e., $\exists y:\gamma.\varphi$ has the same semantics as $\exists y.\gamma\land\varphi$ but, in general, has a different support.

As a brief example to help understand these syntactic constraints, consider the expression $\exists y:\mathit{lseg}(x,y).\;\mathit{list}(y)$. This is not syntactically valid in Frame Logic as the guard contains the recursive definition $\mathit{lseg}$. However, we could instead write the formula $\exists y:y=\mathit{next}(x).\;\mathit{list}(y)$, which is syntactically valid as the guard only references variables and the mutable function $\mathit{next}(x)$.

Universal formulas of the kind $\forall x:\gamma.\,\alpha$ are shorthands for the formula $\neg(\exists x:\gamma.\,\neg\alpha)$ as expected, and their supports are hence defined as well.

For recursive definitions (throughout the paper, we use the terms recursive definitions and inductive definitions with the same meaning), we require that the relation $R$ that is defined does not have arguments of sort $\sigma_{\textsf{S(f)}}$. This is another restriction in order to ensure the existence of a least fixpoint model in the definition of the semantics.333It would be sufficient to restrict formulas of the form $R(t_{\_}1,\ldots,t_{\_}n)$ for inductive relations $R$ to not contain support expressions as subterms.

3.2. Semantics of Support Expressions: Design Decisions

We discuss the design decisions that go behind the semantics of the support operator Sp in our logic, and then give an example for the support of an inductive definition. The formal conditions that the supports should satisfy are stated in the equations in Figure 2, and are explained in Section 3.3. Here, we start by an informal discussion.

The first decision is to have every formula uniquely define a support, which roughly captures the subdomain of mutable functions that a formula $\varphi$’s truthhood depends on, and have $\textit{Sp}(\varphi)$ evaluate to it.

The choice for supports of atomic formulas are relatively clear. An atomic formula of the kind $f(x)\!\!=\!\!y$, where $x$ is of the foreground sort and $f$ is a mutable function, has as its support the singleton set containing the location interpreted for $x$. And atomic formulas that do not involve mutable functions over the foreground have an empty support. Supports for terms can also be similarly defined. The support of a conjunction $\alpha\wedge\beta$ should clearly be the union of the supports of the two formulas.

Remark 1.

In traditional separation logic, each pointer field is stored in a separate location, using integer offsets. However, in our work, we view pointers as references and disallow pointer arithmetic. A more accurate heaplet for such references can be obtained by taking heaplet to be the pair $(x,f)$ (see (Parkinson and Bierman, 2005)), capturing the fact that the formula depends only on the field $f$ of $x$. Such accurate heaplets can be captured in FL as well— we can introduce a non-mutable field lookup pointer $L_{\_}f$ and use $x.L_{\_}f.f$ in programs instead of $x.f$.

What should the support of a formula $\alpha\vee\beta$ be? The choice we make here is that its support is the union of the supports of $\alpha$ and $\beta$. Note that in a model where $\alpha$ is true and $\beta$ is false, we still include the heaplet of $\beta$ in $\textit{Sp}(\alpha\vee\beta)$. In a sense, this is an overapproximation of the support as far as frame reasoning goes, as surely preserving the model’s definitions on the support of $\alpha$ will preserve the truth of $\alpha$, and hence of $\alpha\vee\beta$.

However, we prefer the support to be the union of the supports of $\alpha$ and $\beta$. We think of the support as the subdomain of the universe that determines the meaning of the formula, whether it be true or false. Consequently, we would like the support of a formula and its negation to be the same. Given that the support of the negation of a disjunction, being a conjunction, is the union of the frames of $\alpha$ and $\beta$, we would like this to be the support.

Separation logic makes a different design decision. Logical formulas are not associated with tight supports, but rather, the semantics of the formula is defined for models with given supports/heaplets, where the idea of a heaplet is whether it supports the truthhood of a formula (and not its falsehood). For example, for a model, the various heaplets that satisfy $\neg(f(x)=y)$ in separation logic would include all heaplets where the location of $x$ is not present, which does not coincide with the notion we have chosen for supports. However, for positive formulas, separation logic handles supports more accurately, as it can associate several supports for a formula, yielding two heaplets for formulas of the form $\alpha\vee\beta$ when they are both true in a model. The decision to have a single support for a formula compels us to take the union of the supports to be the support of a disjunction.

There are situations, however, where there are disjunctions $\alpha\vee\beta$, where only one of the disjuncts can possibly be true, and hence we would like the support of the formula to be the support of the disjunct that happens to be true. We therefore introduce a new syntactical form $ite(\gamma:\alpha,\beta)$ in frame logic, whose heaplet is the union of the supports of $\gamma$ and $\alpha$, if $\gamma$ is true, and the supports of $\gamma$ and $\beta$ if $\gamma$ is false. While the truthhood of $ite(\gamma:\alpha,\beta)$ is the same as that of $(\gamma\wedge\alpha)\vee(\neg\gamma\wedge\beta)$, its supports are potentially smaller, allowing us to write formulas with tighter supports to support better frame reasoning. Note that the support of $ite(\gamma:\alpha,\beta)$ and its negation $ite(\gamma:\neg\alpha,\neg\beta)$ are the same, as we desired.

Turning to quantification, the support for a formula of the form $\exists x.\alpha$ is hard to define, as its truthhood could depend on the entire universe. We hence provide a mechanism for guarded quantification, in the form $\exists x:\gamma.~{}~{}\alpha$. The semantics of this formula is that there exists some location that satisfies the guard $\gamma$, for which $\alpha$ holds. The support for such a formula includes the support of the guard, and the supports of $\alpha$ when $x$ is interpreted to be a location that satisfies $\gamma$. For example, $\exists x:(x=f(y)).~{}~{}g(x)=z$ has as its support the locations interpreted for $y$ and $f(y)$ only, since we only consider the support of $g(x)$ when $x$ is interpreted to be $f(y)$.

For a formula $R(\overline{t})$ with an inductive relation $R$ defined by $R(\overline{x}):=\rho_{\_}R(\overline{x})$, the support descends into the definition, changing the variable assignment of the variables in $\overline{x}$ from the inductive definition to the terms in $\overline{t}$. Furthermore, it contains the elements to which mutable functions are applied in the terms in $\overline{t}$.

Recursive definitions are designed such that the evaluation of the equations for the support expressions is independent of the interpretation of the inductive relations. The equations mainly depend on the syntactic structure of formulas and terms. Only the semantics of guards, and the semantics of subterms under a mutable function symbol play a role. For this reason, we disallow guards to contain recursively defined relations or support expressions. We also require that the only functions involving the sort $\sigma_{\textsf{S(f)}}$ are the standard functions involving sets. Thus, subterms of mutable functions cannot contain support expressions (which are of sort $\sigma_{\textsf{S(f)}}$) as subterms.

These restrictions ensure that there indeed exists a unique simultaneous least solution of the equations for the inductive relations and the support expressions. We now provide an example.

Example 3.1.

Consider the definition of a predicate $\mathit{tree}(x)$ w.r.t. two unary mutable functions $\mathit{left}$ and $\mathit{right}$:

[TABLE]

This inductive definition defines binary trees with pointer fields $\mathit{left}$ and $\mathit{right}$ for left- and right-pointers, by stating that $x$ points to a tree if either $x$ is equal to $nil$ (in this case its support is empty), or $\mathit{left}(x)$ and $\mathit{right}(x)$ are trees with disjoint supports. The last conjunct says that $x$ does not belong to the support of the left and right subtrees; this condition is, strictly speaking, not required to define trees (under least fixpoint semantics). Note that the access to the support of formulas eases defining disjointness of heaplets, like in separation logic. The support of $tree(x)$ turns out to be precisely the nodes that are reachable from $x$ using $\mathit{left}$ and $\mathit{right}$ pointers, as one would desire. Consequently, if a pointer outside this support changes, we would be able to conclude using frame reasoning that the truth value of $tree(x)$ does not change. ∎

3.3. Formal Semantics of Frame Logic

Before we explain the semantics of the support expressions and inductive definitions, we introduce a semantics that treats support expressions and the symbols from $\mathcal{I}$ as uninterpreted symbols. We refer to this semantics as uninterpreted semantics. For the formal definition we need to introduce some terminology first.

An occurrence of a variable $x$ in a formula is free if it does not occur under the scope of a quantifier for $x$. By renaming variables we can assume that each variable only occurs freely in a formula or is quantified by exactly one quantifier in the formula. We write $\varphi(x_{\_}1,\ldots,x_{\_}k)$ to indicate that the free variables of $\varphi$ are among $x_{\_}1,\ldots,x_{\_}k$. Substitution of a term $t$ for all free occurrences of variable $x$ in a formula $\varphi$ is denoted $\varphi[t/x]$. Multiple variables are substituted simultaneously as $\varphi[t_{\_}1/x_{\_}1,\ldots,t_{\_}n/x_{\_}n]$. We abbreviate this by $\varphi[\overline{t}/\overline{x}]$.

A model is of the form $M=(U;\llbracket\cdot\rrbracket_{M})$ where $U=(U_{\_}{\tau})_{\_}{\tau\in S}$ contains a universe for each sort, and an interpretation function $\llbracket\cdot\rrbracket_{M}$. The universe for the sort $\sigma_{\textsf{S(f)}}$ is the powerset of the universe for $\sigma_{\textsf{f}}$.

A variable assignment is a function $\nu$ that assigns to each variable a concrete element from the universe for the sort of the variable. For a variable $x$, we write $D_{\_}x$ for the universe of the sort of $x$ (the domain of $x$). For a variable $x$ and an element $u\in D_{\_}x$ we write $\nu[x\leftarrow u]$ for the variable assignment that is obtained from $\nu$ by changing the value assigned for $x$ to $u$.

The interpretation function $\llbracket\cdot\rrbracket_{M}$ maps each constant $c$ of sort $\tau$ to an element $\llbracket c\rrbracket_{M}\in U_{\_}{\tau}$, each function symbol $f:\tau_{\_}1\times\ldots\times\tau_{\_}m\rightarrow\tau$ to a concrete function $\llbracket f\rrbracket_{M}:U_{\_}{\tau_{\_}1}\times\ldots\times U_{\_}{\tau_{\_}m}\rightarrow U_{\_}\tau$, and each relation symbol $R\in\mathcal{R}\cup\mathcal{I}$ of type $\tau_{\_}1\times\ldots\times\tau_{\_}m$ to a concrete relation $\llbracket R\rrbracket_{M}\subseteq U_{\_}{\tau_{\_}1}\times\ldots\times U_{\_}{\tau_{\_}m}$. These interpretations are assumed to satisfy the background theories (see Section 2). Furthermore, the interpretation function maps each expression of the form $\textit{Sp}(\varphi)$ to a function $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}$ that assigns to each variable assignment $\nu$ a set $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)$ of foreground elements. The set $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)$ corresponds to the support of the formula when the free variables are interpreted by $\nu$. Similarly, $\llbracket\textit{Sp}(t)\rrbracket_{M}$ is a function from variable assignments to sets of foreground elements.

Based on such models, we can define the semantics of terms and formulas in the standard way. The only construct that is non-standard in our logic are terms of the form $\textit{Sp}(\varphi)$, for which the semantics is directly given by the interpretation function in Figure 2. We write $\llbracket t\rrbracket_{M,\nu}$ for the interpretation of a term $t$ in $M$ with variable assignment $\nu$. With this convention, $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)$ denotes the same thing as $\llbracket\textit{Sp}(\varphi)\rrbracket_{M,\nu}$. As usual, we write $M,\nu\models\varphi$ to indicate that the formula $\varphi$ is true in $M$ with the free variables interpreted by $\nu$, and $\llbracket\varphi\rrbracket_{M}$ denotes the relation defined by the formula $\varphi$ with free variables $\overline{x}$. Note that the support of $\forall y:\gamma.\,\varphi$ is the same as the support of $\exists y:\gamma.\,\varphi$ since $\forall y:\gamma.\,\varphi$ is a shorthand for $\neg(\exists y:\gamma.\,\neg\varphi)$.

We refer to the above semantics as the uninterpreted semantics of $\varphi$ because we do not give a specific meaning to inductive definitions and support expressions.

Now let us define the true semantics for FL. The relation symbols $R\in\mathcal{I}$ represent inductively defined relations, which are defined by equations of the form $R(\overline{x}):=\rho_{\_}R(\overline{x})$ (see Figure 1). In the intended meaning, $R$ is interpreted as the least relation that satisfies the equation

[TABLE]

The usual requirement for the existence of a unique least fixpoint of the equation is that the definition of $R$ does not negatively depend on $R$. For this reason, we require that in $\rho_{\_}R(\overline{x})$ each occurrence of an inductive predicate $R^{\prime}\in\mathcal{I}$ is either inside a support expression, or it occurs under an even number of negations.444As usual, it would be sufficient to forbid negative occurrences of inductive predicates in mutual recursion.

Every support expression is evaluated on a model to a set of foreground elements (under a given variable assignment $\nu$). Formally, we are interested in models in which the support expressions are interpreted to be the sets that correspond to the smallest solution of the equations given in Figure 2. The intuition behind these definitions was explained in Section 3.2

Example 3.2.

Consider the inductive definition $tree(x)$ defined in Example 3.1. To check whether the equations from Figure 2 indeed yield the desired support, note that the supports of $\textit{Sp}(x=nil)=\textit{Sp}(x)=\textit{Sp}(\top)=\emptyset$. Below, we write $[u]$ for a variable assignment that assigns $u$ to the free variable of the formula that we are considering. Then we obtain that $\textit{Sp}(\mathit{tree}(x))[u]=\emptyset$ if $u=\mathit{nil}$, and $\textit{Sp}(\mathit{tree}(x))[u]=\textit{Sp}(\alpha)[u]$ if $x\not=nil$. The formula $\alpha$ is existentially quantified with guard $\ell=\mathit{left}(x)\land r=\mathit{right}(x)$. The support of this guard is $\{u\}$ because mutable functions are applied to $x$. The support of the remaining part of $\alpha$ is the union of the supports of $\mathit{tree}(\ell)[\mathit{left}(u)]$ and $\mathit{tree}(r)[\mathit{right}(u)]$ (the assignments for $\ell$ and $r$ that make the guard true). So we obtain for the case that $u\not=\mathit{nil}$ that the element $u$ enters the support, and the recursion further descends into the subtrees of $u$, as desired.∎

A frame model is a model in which the interpretation of the inductive relations and of the support expressions corresponds to the least solution of the respective equations. We formalize this idea and prove the following proposition in Section 3.4.

Proposition 3.3.

For each model $M$, there is a unique frame model over the same universe and the same interpretation of the constants, functions, and non-inductive relations.

3.4. Frame Models

In this section we present a formal construction of frame models over which FL formulae are interpreted. We first introduce some useful terminology.

A pre-model $\hat{M}$ is defined like a model with the difference that a pre-model does not interpret the inductive relation symbols and the support expressions $\textit{Sp}(\varphi)$ and $\textit{Sp}(t)$. A pre-model $\hat{M}$ spans a class of models $\textsf{Mod}(\hat{M})$, namely those that simply extend $\hat{M}$ by an interpretation of the inductive relations and the support expressions.

The inductive definitions of relations from $\mathcal{I}$ can have negative references to support expressions. For example, the tree definition from Example 3.1 uses support expressions in the subformula $\textit{Sp}(\mathit{tree}(\ell(x)))\cap\textit{Sp}(\mathit{tree}(r(x)))=\emptyset$. This formula is true if there does not exist an element in the intersection $\textit{Sp}(\mathit{tree}(\ell(x)))\cap\textit{Sp}(\mathit{tree}(r(x)))$, and hence negatively refers to these support expressions. For this reason, we need to define two partial orders that correspond to first taking the least fixpoint for the support expression, and then the least fixpoint for the inductive predicates.

In the following, we refer to the equations for the support expressions from Figure 2 as support equations, and to the equations $\llbracket R(\overline{x})\rrbracket_{M}=\llbracket\rho_{\_}R(\overline{x})\rrbracket_{M}$ for the inductive definitions as the inductive equations.

For $M_{\_}1,M_{\_}2\in\textsf{Mod}(\hat{M})$ we let $M_{\_}1\leq_{\mathrm{f}}M_{\_}2$ if

• •

$\llbracket\textit{Sp}(\varphi)\rrbracket_{M_{\_}1}(\nu)\subseteq\llbracket\textit{Sp}(\varphi)\rrbracket_{M_{\_}2}(\nu)$ as well as $\llbracket\textit{Sp}(t)\rrbracket_{M_{\_}1}(\nu)\subseteq\llbracket\textit{Sp}(t)\rrbracket_{M_{\_}2}(\nu)$ for all support expressions and all variable assignments $\nu$.

Note that $\leq_{\mathrm{f}}$ is not a partial order but only a preorder: for two models $M_{\_}1,M_{\_}2$ that differ only in their interpretations of the inductive relations, we have $M_{\_}1\leq_{\mathrm{f}}M_{\_}2$ and $M_{\_}2\leq_{\mathrm{f}}M_{\_}1$. We write $M_{\_}1<_{\mathrm{f}}M_{\_}2$ if $M_{\_}1\leq_{\mathrm{f}}M_{\_}2$ and not $M_{\_}2\leq_{\mathrm{f}}M_{\_}1$.

We further define $M_{\_}1\leq_{\mathrm{i}}M_{\_}2$ if

• •

$\llbracket\textit{Sp}(\varphi)\rrbracket_{M_{\_}1}=\llbracket\textit{Sp}(\varphi)\rrbracket_{M_{\_}2}$ as well as $\llbracket\textit{Sp}(t)\rrbracket_{M_{\_}1}=\llbracket\textit{Sp}(t)\rrbracket_{M_{\_}2}$ for all support expressions, and

• •

$\llbracket I\rrbracket_{M_{\_}1}\subseteq\llbracket I\rrbracket_{M_{\_}2}$ for all inductive relations $I\in\mathcal{I}$.

The relation $\leq_{\mathrm{i}}$ is a partial order.

We say that $M\in\textsf{Mod}(\hat{M})$ is a frame model if its interpretation function $\llbracket\cdot\rrbracket_{M}$ satisfies the inductive equations and the support equations, and furthermore

1. (1)

each $M^{\prime}\in\textsf{Mod}(\hat{M})$ with $M^{\prime}<_{\mathrm{f}}M$ does not satisfy the support equations, and 2. (2)

each $M^{\prime}\in\textsf{Mod}(\hat{M})$ with $M^{\prime}<_{\mathrm{i}}M$ does not satisfy the inductive equations.

For proving the existence of a unique frame model, we use the following lemma for dealing with guards and terms with mutable functions.

Lemma 3.4.

Let $\hat{M}$ be a pre-model, $M_{\_}1,M_{\_}2\in\textsf{Mod}(\hat{M})$, and $\nu$ be a variable assignment.

1. (1)

If $\varphi$ is formula that does not use inductive relations and support expressions, then $M_{\_}1,\nu\models\varphi$ iff $M_{\_}2,\nu\models\varphi$. 2. (2)

If $t$ is a term that has no support expressions as subterms, then $\llbracket t\rrbracket_{M_{\_}1,\nu}=\llbracket t\rrbracket_{M_{\_}2,\nu}$. 3. (3)

If $t=f(t_{\_}1,\ldots,t_{\_}n)$ is a term with a mutable function symbol $f\in F_{\textsf{m}}$, then $\llbracket t_{\_}i\rrbracket_{M_{\_}1,\nu}=\llbracket t_{\_}i\rrbracket_{M_{\_}2,\nu}$ for all $i$.

Proof.

Parts 1 and 2 are immediate from the fact that $M_{\_}1$ and $M_{\_}2$ only differ in the interpretation of the inductive relations and support expressions. For the third claim, note that we assumed that the only functions involving arguments of sort $\sigma_{\textsf{S(f)}}$ are the standard functions for set manipulation. Hence, a term build from a mutable function symbol cannot have support expressions as subterms. Therefore, the third claim follows from the second one. ∎

We now prove Proposition 3.3 (see Section 3.3). We first restate the proposition formally using the terminology developed above.

Proposition 3.5.

For each pre-model $\hat{M}$, there is a unique frame model in $\textsf{Mod}(\hat{M})$.

Proof.

The support equations define an operator $\mu_{\mathrm{f}}$ on $\textsf{Mod}(\hat{M})$. This operator $\mu_{\mathrm{f}}$ is defined in a standard way, as explained in the following. Let $M\in\textsf{Mod}(\hat{M})$. Then $\mu_{\mathrm{f}}(M)$ is a model in $\textsf{Mod}(\hat{M})$ where $\llbracket\textit{Sp}(\varphi)\rrbracket_{\mu_{\mathrm{f}}(M)}$, resp. $\llbracket\textit{Sp}(t)\rrbracket_{\mu_{\mathrm{f}}(M)}$, is obtained by taking the right-hand side of the corresponding equation. For example, $\llbracket\textit{Sp}(\varphi_{\_}1\land\varphi_{\_}2)\rrbracket_{\mu_{\mathrm{f}}(M)}(\nu)=\llbracket\textit{Sp}(\varphi_{\_}1)\rrbracket_{M}(\nu)\cup\llbracket\textit{Sp}(\varphi_{\_}2)\rrbracket_{M}(\nu)$. The interpretation of the inductive predicates is left unchanged by $\mu_{\mathrm{f}}$.

We can show that $\mu_{\mathrm{f}}$ is a monotonic operator on $(\textsf{Mod}(\hat{M}),\leq_{\mathrm{f}})$, that is, for all $M_{\_}1,M_{\_}2\in\textsf{Mod}(\hat{M})$ with $M_{\_}1\leq_{\mathrm{f}}M_{\_}2$ we have that $\mu_{\mathrm{f}}(M_{\_}1)\leq\mu_{\mathrm{f}}(M_{\_}2)$. It is routine to check monotonicity of $\mu_{\mathrm{f}}$ by induction on the structure of the support expressions. We use Lemma 3.4 for the only cases in which the semantics of formulas and terms is used in the support equations, namely $\mathit{ite}$-formulas, existential formulas, and terms $f(t_{\_}1,\ldots,t_{\_}n)$ with mutable function $f$. Consider, for example, the support equation

[TABLE]

for $f\in F_{\textsf{m}}$, and let $M_{\_}1\leq_{\mathrm{f}}M_{\_}2$ be in $\textsf{Mod}(\hat{M})$ and $\nu$ be a variable assignment. Then

[TABLE]

where (1) holds because of Lemma 3.4, and (2) holds because $M_{\_}1\leq_{\mathrm{f}}M_{\_}2$.

As a further case, consider the support equation for $R(\overline{t})$ where $R$ is an inductively defined relation and $t=(t_{\_}1,\ldots,t_{\_}n)$.

[TABLE]

For the inclusion $(*)$ we use the fact that the $t_{\_}i$ do not contain support expressions as subterms by our restriction of the type of inductively defined relations. Hence, by Lemma 3.4, $\llbracket t_{\_}i\rrbracket_{M_{\_}1,\nu}=\llbracket t_{\_}i\rrbracket_{M_{\_}2,\nu}$.

Similarly, one can show the inclusion for the other support equations.

We also obtain an operator $\mu_{\mathrm{i}}$ from the inductive equations, which leaves the interpretation of the support expressions unchanged. The operator $\mu_{\mathrm{i}}$ is monotonic on $(\textsf{Mod}(\hat{M}),\leq_{\mathrm{i}})$ because inductive predicates can only be used positively in the inductive definitions, and furthermore $\leq_{\mathrm{i}}$ only compares models with the same interpretation of the support expressions.

In order to obtain the unique frame model, we first consider the subset of $\textsf{Mod}(\hat{M})$ in which all inductive predicates are interpreted as empty set. On this set of models, $\leq_{\mathrm{f}}$ is a partial order and forms a complete lattice (the join and meet for the lattice are obtained by taking the pointwise union, respectively intersection, of the interpretations of the support expression). By the Knaster-Tarski theorem, there is a unique least fixpoint of $\mu_{\mathrm{f}}$. This fixpoint can be obtained by iterating $\mu_{\mathrm{f}}$ starting from the model in $\textsf{Mod}(\hat{M})$ that interprets all inductive relations and the support expression by the empty set (in general, this iteration is over the ordinal numbers, not just the natural numbers). Let $M_{\_}f$ be this least fixpoint.

The subset of $\textsf{Mod}(\hat{M})$ in which the support expressions are interpreted as in $M_{\_}f$ forms a complete lattice with the partial order $\leq_{\mathrm{i}}$. Again by the Knaster-Tarski Theorem, there is a unique least fixpoint. This least fixpoint can be obtained by iterating the operator $\mu_{\mathrm{i}}$ starting from $M_{\_}f$ (again, the iteration is over the ordinals).

Denote the resulting model by $M_{\_}{f,i}$. It interprets the support expressions in the same way as $M_{\_}f$, and thus $M_{\_}f\leq_{\mathrm{f}}M_{\_}{f,i}$ and $M_{\_}{f,i}\leq_{\mathrm{f}}M_{\_}i$. By monotonicity of $\mu_{\mathrm{f}}$, $M_{\_}{f,i}$ is also a fixpoint of $\mu_{\mathrm{f}}$ and thus satisfies the support equations. Hence $M_{\_}{f,i}$ satisfies the inductive equations and the support equations. It can easily be checked that $M_{\_}{f,i}$ also satisfies the other conditions of a frame model: Let $M\in\textsf{Mod}(\hat{M})$ with $M<_{\mathrm{f}}M_{\_}{f,i}$. Then also $M\leq_{\mathrm{f}}M_{\_}f$ and assuming that $M$ satisfies the support equations yields a smaller fixpoint of $\mu_{\mathrm{f}}$, and thus a contradiction. Similarly, a model $M<_{\mathrm{i}}M_{\_}{f,i}$ cannot satisfy the inductive equations.

It follows that $M_{\_}{f,i}$ is a frame model in $\textsf{Mod}(\hat{M})$. Uniqueness follows from the uniqueness of the least fixpoints of $\mu_{\mathrm{f}}$ and $\mu_{\mathrm{i}}$ as used in the construction of $M_{\_}{f,i}$. ∎

Consequences of Frame Logic Semantics

We now highlight some consequences of the semantics of FL and highlight differences with other logics.

Global Heap Semantics vs Local Heap Semantics: Our semantics is global in the sense that formulas are interpreted on the entire model. Supports of formulas define a subset of the model that capture the part on which their depends on, and roughly correspond to heaplets in separation logic. Separation logic semantics is however defined not on the global heap but with respect to local heaplets (i.e., captured using rules of the form $s,h\models\varphi$), where $h$ is a heaplet (Reynolds, 2002), and hence corresponding to a local heap semantics.

Consider the FL formula $\exists y:y=f(x).\,\top$. This formula is valid in FL but the corresponding SL formula $\exists y.\,x\overset{f}{\mapsto}y$ is not valid; it holds on the heaplet $h$ where $h$ is a singleton location containing the valuation of $x$, but not on other heaplets. Note that $Sp(\exists y:y=f(x).\,\top)$ will be this heaplet $h$.

Substitutions: Another interesting consequence of FL semantics is that substituting a formula with another equivalent formula (in terms of truthhood) may not result in equivalent formulas.

Consider the formulas $\top$ and $f(x)=f(x)$ for a mutable function $f$. These are equivalent in FL in terms of truthhood (they are both valid, holding in all models). Consider the valid formula $\textit{Sp}(f(x)=f(x))=\{x\}$. Substituting $f(x)=f(x)$ with $\top$ will result in an invalid formula $\textit{Sp}(\top)=\{x\}$.

More precisely, there can be formulas that are equivalent in terms of truthhood (in the global heap) but have different supports, and hence one may not be substituted by another in every context. However, it is true that if $\alpha$ and $\beta$ are equivalent in terms of truthhood and have the same supports in every model, then they can be substituted for each other. This motivates a stronger definition of equivalence for FL formulas:

Definition 3.6 (Equivalence of FL formulas).

FL formula $\varphi_{\_}1$ and $\varphi_{\_}2$ are said to be equivalent, denoted $\varphi_{\_}1\equiv\varphi_{\_}2$ if for every frame model $M$ and interpretation of free variables $\nu$, $M,\nu\vDash\varphi_{\_}1$ iff $M,\nu\vDash\varphi_{\_}2$ and $\llbracket\textit{Sp}(\varphi_{\_}1)\rrbracket_{M,\nu}=\llbracket\textit{Sp}(\varphi_{\_}2)\rrbracket_{M,\nu}$.

Formulas are not equivalent if they merely imply each other; it must also be the case that their supports are equal. Reasoning directly in FL requires care in order to cater the above notion. However, as we point out in Section 6.2, we can convert FL to FO-RD and then use standard reasoning for FO-RD (including normal substitution that FO-RD allows).

Supports and Heaplets: In FL, our design decision is to have precisely one support for any formula. In separation logic, there can several heaplets under which a formula can hold true. For example, the formula $\top$ holds in any heaplet in separation logic, while we have chosen the support of $\top$ (and that of $\bot$) to be $\emptyset$.

Note that $\alpha\implies(\alpha\wedge\top)$ and $\alpha\implies(\alpha\vee\bot)$ are both valid in FL. And further, $\textit{Sp}(\alpha)=\textit{Sp}(\alpha\wedge\top)=\textit{Sp}(\alpha\vee\bot)$, by our semantics.

Notice that $\alpha\wedge\neg(\alpha)\implies\bot$ is valid in FL, despite the fact that the support of the antecedent and that of the consequent may be different (unlike separation logic). Similarly, $\alpha\vee\neg\alpha\implies\top$ is also valid.

3.5. A Frame Theorem

The support of a formula can be used for frame reasoning in the following sense: if we modify a model $M$ by changing the interpretation of the mutable functions (e.g., a program modifying pointers), then truth values of formulas do not change if the change happens outside the support of the formula. This is formalized and proven below.

Given two models $M,M^{\prime}$ over the same universe, we say that $M^{\prime}$ is a mutation of $M$ if $\llbracket R\rrbracket_{M}=\llbracket R\rrbracket_{M^{\prime}}$, $\llbracket c\rrbracket_{M}=\llbracket c\rrbracket_{M^{\prime}}$, and $\llbracket f\rrbracket_{M}=\llbracket f\rrbracket_{M^{\prime}}$, for all constants $c$, relations $R\in\mathcal{R}$, and functions $f\in F\setminus F_{\textsf{m}}$. In other words, $M$ can only be different from $M^{\prime}$ on the interpretations of the mutable functions, the inductive relations, and the support expressions.

Given a subset $X\subseteq U_{\_}{\sigma_{\textsf{f}}}$ of the elements from the foreground universe, we say that the mutation is stable on $X$ if the values of the mutable functions did not change on arguments from $X$, that is, $\llbracket f\rrbracket_{M}(u_{\_}1,\ldots,u_{\_}n)=\llbracket f\rrbracket_{M^{\prime}}(u_{\_}1,\ldots,u_{\_}n)$ for all mutable functions $f\in F_{\textsf{m}}$ and all appropriate tuples $u_{\_}1,\ldots,u_{\_}n$ of arguments with $\{u_{\_}1,\ldots,u_{\_}n\}\cap X\not=\emptyset$.

Theorem 3.7 (Frame Theorem).

Let $M,M^{\prime}$ be frame models such that $M^{\prime}$ is a mutation of $M$ that is stable on $X\subseteq U_{\_}{\sigma_{\textsf{f}}}$, and let $\nu$ be a variable assignment. Then $M,\nu\models\alpha$ iff $M^{\prime},\nu\models\alpha$ for all formulas $\alpha$ with $\llbracket\textit{Sp}(\alpha)\rrbracket_{M}(\nu)\subseteq X$, and $\llbracket t\rrbracket_{M,\nu}=\llbracket t\rrbracket_{M^{\prime},\nu}$ for all terms $t$ with $\llbracket\textit{Sp}(t)\rrbracket_{M}(\nu)\subseteq X$.

We dedicate the rest of this subsection to the proof of the Frame Theorem.

Proof.

The intuition behind the statement of the theorem should be clear. The support of a formula/term contains the elements on which mutable functions are dereferenced in order to evaluate the formula/term. If the mutable functions do not change on this set, then the evaluation does not change.

For a formal proof of the Frame Theorem, we refer to the terminology and definitions introduced in Section 3.4, and to the proof of Proposition 3.5 in Section 3.4, in which the unique frame model is obtained by iterating the operators $\mu_{\mathrm{f}}$ and $\mu_{\mathrm{i}}$, which are defined by the support equations and the inductive equations.

In general, this iteration of the operators ranges over ordinals (not just natural numbers). For an ordinal $\eta$, let $M_{\_}\eta$ and $M^{\prime}_{\_}\eta$ be the models at step $\eta$ of the fixpoint iteration for obtaining the frame models $M$ and $M^{\prime}$. So the sequence of the $M_{\_}\eta$ have monotonically increasing interpretations of the inductive relations and support expressions, and are equal to $M$ on the interpretation of the other relations and functions. The frame model $M$ is obtained at some stage $\xi$ of the fixpoint iteration, so $M=M_{\_}\xi$. More precisely, the frame model is contructed by first iterating the operator $\mu_{\mathrm{f}}$ until the fixpoint of the support expressions is reached. During this iteration, the inductive relations are interpreted as empty. Then the operator $\mu_{\mathrm{i}}$ is iterated until also the inductive relations reach their fixpoint. Below, we do an induction on $\eta$. In that induction, we do not explicitly distinguish these two phases because it does not play any role for the arguments (only in one place and we mention it explicitly there).

By induction on $\eta$, we can show that $M_{\_}\eta,\nu\models\varphi\Leftrightarrow M^{\prime}_{\_}\eta,\nu\models\varphi$, and $\llbracket t\rrbracket_{M_{\_}\eta,\nu}=\llbracket t\rrbracket_{M^{\prime}_{\_}\eta,\nu}$ for all variable assignments $\nu$ and all formulas $\varphi$ with $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)\subseteq X$, respectively terms $t$ with $\llbracket\textit{Sp}(t)\rrbracket_{M}(\nu)\subseteq X$. For each $\eta$, we furthermore do an induction on the structure of the formulas, respectively terms.

Note that the assumption that the support is contained in $X$ refers to the support in $M$. So when applying the induction, we have to verify that the condition on the support of a formula/term is satisfied in $M$ (and not in $M_{\_}\eta$).

For the formulas, the induction is straight forward, using Lemma 3.4 in the cases of existential formulas and $ite$-formulas. Consider, for example, the case of an existential formula $\psi=\exists y:\gamma.\varphi$ with $\llbracket\textit{Sp}(\psi)\rrbracket_{M}\subseteq X$.

[TABLE]

where $(*)$ holds by induction on the structure of the formula. We only have to verify that $\llbracket\textit{Sp}(\gamma)\rrbracket_{M}(\nu[y\leftarrow u])\subseteq X$ and $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu[y\leftarrow u])\subseteq X$ in order to use the induction hypothesis.

Since $\gamma$ is a guard of an existential formula, it satisfies the condition of Lemma 3.4, and therefore its truth value is the same in $(M_{\_}\eta,\nu[y\leftarrow u])$ for all ordinals $\eta$ (Lemma 3.4 applies because all the models $M_{\_}\eta$ differ only in the interpretations of the support expressions and inductive relations, and thus have the same pre-model). In particular, $M,\nu[y\leftarrow u]\models\gamma$ since $M=M_{\_}\xi$ for some ordinal $\xi$. From the equations for the supports we obtain $\llbracket\textit{Sp}(\gamma)\rrbracket_{M}(\nu[y\leftarrow u])\subseteq\llbracket\textit{Sp}(\psi)\rrbracket_{M}(\nu)$ and $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu[y\leftarrow u])\subseteq\llbracket\textit{Sp}(\psi)\rrbracket_{M}(\nu)$. The desired claim now follows from the fact that $\llbracket\textit{Sp}(\psi)\rrbracket_{M}(\nu)\subseteq X$.

For inductive relations $R$ with definition $R(\overline{x}):=\rho_{\_}R(\overline{x})$, we have to use the induction on the ordinal $\eta$. Assume that $\varphi=R(\overline{t})$ for $\overline{t}=(t_{\_}1,\ldots,t_{\_}n)$, and that $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)\subseteq X$. Then $\llbracket\textit{Sp}(\rho_{\_}R(\overline{x})\rrbracket_{M}(\nu[\overline{x}\leftarrow\overline{t}])\subseteq X$ and $\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)\subseteq X$ for all $i$ by the support equations.

For the case of a limit ordinal $\eta$, the inductive relations of $M_{\_}\eta$, resp. $M^{\prime}_{\_}\eta$, are obtained by taking the union of the interpretations of the inductive relations for all $M_{\_}\zeta$, resp. $M^{\prime}_{\_}\zeta$, for all $\zeta<\eta$. So the claim follows directly by induction.

For a successor ordnial $\eta+1$, we can assume that we are in the second phase of the construction of the frame model (the iteration of the operator $\mu_{\mathrm{i}}$). For the first phase the claim trivially holds because all the inductive relations are interpreted as empty. Thus, we have

[TABLE]

where $(*)$ holds by induction on $\eta$.

The other cases for formulas are similar (or simpler).

Concerning the terms, we also present some cases only, the other cases being similar or simpler.

We start with the case $t=f(t_{\_}1,\ldots,t_{\_}n)$ for a mutable function $f$. Let $\nu$ be a variable assignment with $\llbracket t\rrbracket_{M,\nu}\subseteq X$. By the support equations, $\llbracket t_{\_}i\rrbracket_{M,\nu}\subseteq X$ for all $i$. We have $\llbracket t\rrbracket_{M_{\_}\eta,\nu}=\llbracket f\rrbracket_{M}(\llbracket t_{\_}1\rrbracket_{M_{\_}\eta,\nu},\ldots,\llbracket t_{\_}n\rrbracket_{M_{\_}\eta,\nu})$. By induction on the structure of terms, we have $\llbracket t_{\_}i\rrbracket_{M_{\_}\eta,\nu}=\llbracket t_{\_}i\rrbracket_{M_{\_}\eta^{\prime},\nu}=:u_{\_}i$. By Lemma 3.4, we conclude that $\llbracket t_{\_}i\rrbracket_{M_{\_}\eta,\nu}=\llbracket t_{\_}i\rrbracket_{M,\nu}$. Since $f$ is mutable, it contains at least one argument of sort $\sigma_{\textsf{f}}$, say $t_{\_}j$. Then $\llbracket t_{\_}j\rrbracket_{M,\nu}\in\llbracket\textit{Sp}(t)\rrbracket_{M}(\nu)\subseteq X$, and the mutation did not change the function value of $f$ on the tuple $(u_{\_}1,\ldots,u_{\_}n)$. So we obtain in summary that $\llbracket t\rrbracket_{M^{\prime},\nu}=\llbracket f\rrbracket_{M^{\prime}}(u_{\_}1,\ldots,u_{\_}n)=\llbracket f\rrbracket_{M}(u_{\_}1,\ldots,u_{\_}n)=\llbracket t\rrbracket_{M,\nu}$.

Now consider terms of the form $\textit{Sp}(\varphi)$. We need to proceed by induction on the structure of $\varphi$. We present the case of $\varphi=\mathit{ite}(\gamma:\varphi_{\_}1,\varphi_{\_}2)$. Let $\nu$ be a variable assignment with $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)\subseteq X$. Assume that $M_{\_}\eta,\nu\models\gamma$. By the condition on guards, Lemma 3.4 yields that $M,\nu\models\gamma$ and thus $\llbracket\textit{Sp}(\gamma)\rrbracket_{M}(\nu)\subseteq X$ and $\llbracket\textit{Sp}(\varphi_{\_}1)\rrbracket_{M}(\nu)\subseteq X$. We obtain

[TABLE]

where $(*)$ follows by induction on the structure of the formula inside the support expression. The case $M_{\_}\eta,\nu\not\models\gamma$ is analogous.

Now consider $\textit{Sp}(\varphi)$ with $\varphi=R(\overline{t})$ for an inductively defined relation $R$ with definition $R(\overline{x})=\rho_{\_}R(\overline{x})$ and $\overline{t}=(t_{\_}1,\ldots,t_{\_}n)$. Let $\nu$ be a variable assignment with $\llbracket\textit{Sp}(\varphi)\rrbracket_{M}(\nu)\subseteq X$. By the support equations, $\llbracket\textit{Sp}(\rho_{\_}R(\overline{x}))\rrbracket_{M}(\nu[\overline{x}\leftarrow\llbracket\overline{t}\rrbracket_{M,\nu}])\subseteq X$ and $\llbracket\textit{Sp}(t_{\_}i)\rrbracket_{M}(\nu)\subseteq X$.

Let $\eta+1$ be a successor ordinal. Then

[TABLE]

where $(*)$ holds by induction on $\eta$. We can apply the induction hypothesis because the terms $t_{\_}i$ do not contain support expressions by the restriction on the type of inductive relations, and thus $\llbracket\overline{t}\rrbracket_{M_{\_}\eta^{\prime},\nu}=\llbracket\overline{t}\rrbracket_{M_{\_}\eta,\nu}=\llbracket\overline{t}\rrbracket_{M,\nu}$ by Lemma 3.4.

The proof of the other cases works in a similar fashion. ∎

3.6. Reduction from Frame Logic to FO-RD

The only extension of frame logic compared to FO-RD is the operator Sp, which defines a function from interpretations of free variables to sets of foreground elements. The semantics of this operator can be captured within FO-RD itself, so reasoning within frame logic can be reduced to reasoning within FO-RD.

A formula $\alpha(\overline{y})$ with $\overline{y}=y_{\_}1,\ldots,y_{\_}m$ has one support for each interpretation of the free variables. We capture these supports by an inductively defined relation $\textit{Sp}_{\_}\alpha(\overline{y},z)$ of arity $m+1$ such that for each frame model $M$, we have $(u_{\_}1,\ldots,u_{\_}m,u)\in\llbracket\textit{Sp}_{\_}\alpha\rrbracket_{M}$ if $u\in\llbracket\textit{Sp}(\alpha)\rrbracket_{M}(\nu)$ for the interpretation $\nu$ that interprets $y_{\_}i$ as $u_{\_}i$.

Since the semantics of $\textit{Sp}(\alpha)$ is defined over the structure of $\alpha$, we introduce corresponding inductively defined relations $\textit{Sp}_{\_}\beta$ and $\textit{Sp}_{\_}t$ for all subformulas $\beta$ and subterms $t$ of either $\alpha$ or of a formula $\rho_{\_}R$ for $R\in\mathcal{I}$.

The equations for supports from Figure 2 can be expressed by inductive definitions for the relations $\textit{Sp}_{\_}\beta$. The translations are shown in Figure 3. For the definitions, we assume that $\overline{y}$ contains all variables that are used in $\alpha$ and in the formulas $\rho_{\_}R$ of the inductive definitions. We further assume that each variable either is used in at most one of the formulas $\alpha$ or $\rho_{\_}R$, and either only occurs freely in it, or is quantified at most once. The relations $\textit{Sp}_{\_}\beta$ are all of arity $m+1$, even if the subformulas do not use some of the variables. In practice, one would rather use relations of arities as small as possible, referring only to the relevant variables. In a general definition, this is, however, rather cumbersome to write, so we use this simpler version in which we do not have to rearrange and adapt the variables according to their use in subformulas.

For the definition of $\textit{Sp}_{\_}{R(\overline{t})}$ where $R$ is an inductively defined relation, note that the variables $\overline{x}$ from the definition of $R$ are contained in $\overline{y}$ by the above assumptions, and are substituted by the terms in $\overline{t}$ in the first part of the formula. Similiarly, the quantified variable $x$ in an existential formula is contained in $\overline{y}$.

It is not hard to see that general frame logic formulas can be translated to FO-RD formulas that make use of these new inductively defined relations.

Proposition 3.8.

For every frame logic formula there is an equisatisfiable FO-RD formula with the signature extended by auxiliary predicates for recursive definitions of supports.

3.7. Expressing Data-Structures Properties in FL

We now present the formulation of several data-structures and properties about them in FL. Figure 4 depicts formulations of singly- and doubly-linked lists, list segments, lengths of lists, sorted lists, the multiset of keys stored in a list (assuming a background sort of multisets), binary trees, their heights, and AVL trees. In all these definitions, the support operator plays a crucial role. We also present a formulation of single threaded binary trees (adapted from (Brinck and Foo, 1981)), which are binary trees where, apart from tree-edges, there is a pointer $tnext$ that connects every tree node to the inorder successor in the tree; these pointers go from leaves to ancestors arbitrarily far away in the tree, making it a nontrivial definition.

We believe that FL formulas naturally and succinctly express these data-structures and their properties, making it an attractive logic for annotating programs.

4. Programs and Proofs

In this section, we develop a program logic for a while-programming language that can destructively update heaps. We assume that location variables are denoted by variables of the form $x$ and $y$, whereas variables that denote other data (which would correspond to the background sorts in our logic) are denoted by $v$. We omit the grammar to construct background terms and formulas, and simply denote such ‘background expressions’ with $be$ and clarify the sort when it is needed. Finally, we assume that our programs are written in Single Static Assignment (SSA) form, which means that every variable is assigned to at most once in the program text. The grammar for our programming language is in Figure 5.

4.1. Operational Semantics

In this Section we will discuss the operational semantics of our programs. First, we extend the signature of our logic by an infinite set $\textit{KF}=\{\textit{kf}_{\_}i\mid i\in\mathbb{N}\}$ of constants of the type of the foreground sort, i.e. heap locations. We also add constants $\{\mathit{def}_{\_}f\}_{\_}{f\in F}$ to denote ‘default’ values.

A configuration in our operational semantics is of the form $(M,H,U)$ where $M$ is a model that contains interpretations for the store and the heap. The store is a partial map that interprets variables, constants, and non-mutable functions over universes of the appropriate sorts. The heap is a total map on the domain of locations that interprets mutable functions. $H$ is a subset of (the universe of) locations denoting the set of allocated locations, and $U$ is a subset of locations denoting unallocated locations that can be allocated in the future. Lastly, we introduce a special configuration $\bot$ to denote an error state.

A configuration $(M,H,U)$ is valid if:

• •

all program variables of the location sort (including $nil$) map only to locations not in $U$.

• •

$U$ does not intersect with $H$,

• •

$U$ is infinite.

• •

the constants $\textit{kf}_{\_}i$ are interpreted to distinct locations (i.e., no two constants in KF are interpreted to the same location) that are neither in $H$ nor in $U$. We will later use these constants to design our program logic rule for allocation.

• •

it is not possible to reach any location in $U$ or KF from any location in $H$. Simply, locations in $H$ do not point to locations in $U$ or KF.

• •

locations in $U$ as well as those interpreted by KF have default values under functions, defined by the interpretation of the constants $\{\mathit{def}_{\_}f\}_{\_}{f\in F}$.

We denote this by $\mathit{valid}(M,H,U)$. We will demand that initial configurations of programs are valid, and maintain this by constructing our operational semantics rules to ensure that reachable configurations of programs are valid. Observe that validity of a configuration is expressible in First-Order Logic.

The full operational semantics are in Figure 6. We abuse notation by using $M(x)$ to mean the value of $x$ as interpreted by the model $M$, as well as using the expression $M[x\mapsto y]$ to denote that the model is updated with the variable $x$ now storing the value stored by the variable/expression $y$ in the original model.

$\bot$ is a sink state, and every statement on $\bot$ transitions to $\bot$. The pointer lookup rule changes the store where the variable $x$ now maps to $f(y)$, provided $y$ is a location that is allocated. The pointer modification rule modifies the heap on the function $f$, where the store’s interpretation for $x$ now maps to the store’s interpretation for $y$ (again, provided $x$ is a location that is allocated). The allocation rule is the only nondeterministic rule in the operational semantics, as there is a transition for each $a\in U$. For each such $a$, the store is modified where $x$ now points to $a$. Additionally, the heap is modified for each function $f$ where the newly allocated $a$ maps to the default value under each $f$. Further, note since freed elements are not added back to $U$, freed locations cannot be reallocated. However, since $U$ is infinite, and dereferenced pointers must be in $H$, this does not pose a problem. All other rules are straightforward.

Note that when side conditions are violated as in the lookup rule or pointer modification rule, the configuration transitions to $\bot$, which denotes an abort or fault configuration. These faulting transitions are crucial for the soundness of the frame rule. The allocation rule, however, will always succeed for valid configurations because we demand that $U$ is infinite for valid configurations.

4.2. Triples and Validity

We express specifications of programs using triples of the form $\{\alpha\}S\{\beta\}$ where $\alpha$ and $\beta$ are FL formulas in our extended signature and $S$ is a program in our while-language. However, we restrict the formulas that can appear in the specifications. First, we disallow atomic relations between locations. Second, we disallow functions from a background sort to the foreground sort (see Section 3). Finally, quantified formulas can have supports as large as the entire heap but we want our program logic to cover a more practical fragment without compromising expressive power. Thus, we require guards in quantification to be of the form $f(z^{\prime})=z$ where $z$ is the quantified variable. We will maintain this as an invariant in the formulas that we generate for, say, weakest preconditions. Apart from these restrictions, we will also assume that formulas only feature unary functions for ease of presentation.

We define a triple to be valid if every valid configuration with heaplet being precisely the support of $\alpha$, when acted on by the program, yields a configuration with heaplet being the support of $\beta$. More formally, a triple is valid if for every valid configuration $(M,H,U)$ such that $M\models\alpha$, $H=\llbracket\textit{Sp}(\alpha)\rrbracket_{M}$:

(1) it is never the case that the abort state $\bot$ is encountered in the execution on $S$

(2) if $(M,H,U)$ transitions to $(M^{\prime},H^{\prime},U^{\prime})$ on $S$, then $M^{\prime}\models\beta$ and $H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$

Note that the post-configuration $(M^{\prime},H^{\prime},U^{\prime})$ will also be valid as a consequence of our transition rules, using the fact that $(M,H,U)$ is valid.

4.3. Program Logic

First, we define a set of local rules and rules for conditionals, while, sequence, consequence, and framing. Recall we assume there is at least one mutable function $f\in F_{\textsf{m}}$ (see Section 3) in our signature.

[TABLE]

The above rules are intuitively clear and are similar to the local rules in separation logic (Reynolds, 2002). The rules for statements capture their semantics using minimal/tight heaplets, and the frame rule allows proving triples with larger heaplets. Some seemingly trivial preconditions as in the lookup, mutation, and allocation rules are added to ensure tight heaplets, i.e. that the support of the precondition is equal to the support of the postcondition, modulo any alloc/free statements. In the rule for $\mathsf{alloc}$, the postcondition says that the newly allocated location has default values for all pointer fields and datafields (denoted as $\textit{def}_{\_}f$). The soundness of the frame rule relies crucially on the frame theorem for FL (Theorem 3.7). The full soundness proof can be found in Section 4.7.

Theorem 4.1.

The above rules are sound with respect to the operational semantics.

4.4. Weakest-Precondition Proof Rules

We now turn to the much more complex problem of designing rules that give weakest preconditions for arbitrary postconditions, for loop-free programs. In separation logic, such rules resort to using the magic wand operator $-*$ (Demri and Deters, 2015; O’Hearn, 2012; O’Hearn et al., 2001; Reynolds, 2002). The magic wand is a complex operator whose semantics calls for second-order quantification (Brochenin et al., 2008) over arbitrarily large submodels. In our setting, our main goal is to show that FL is itself capable of expressing weakest preconditions of postconditions written in FL.

First, we define a notion of Weakest Tightest Precondition (WTP) of a formula $\beta$ with respect to each command that can figure in a basic block: assignment, lookup, mutation, allocation, and deallocation. To define this notion, we first define the notion of a preconfiguration:

Definition 4.2.

The preconfigurations corresponding to a valid configuration $(M,H,U)$ with respect to a program $S$ are a set of valid configurations of the form $(M_{\_}p,H_{\_}p,U_{\_}p)$ such that when $S$ is executed on $M_{\_}p$ with unallocated set $U_{\_}p$ it dereferences only locations in $H_{\_}p$ and results (using the operational semantics rules) in $(M,H,U)$. That is:

[TABLE]

Definition 4.3.

We say that $\alpha$ is a Weakest Tightest Precondition (WTP) of a formula $\beta$ with respect to a program $S$ if the set of all valid configurations that satisfy $\alpha$ is the same as the set of all preconfigurations of all valid configurations that satisfy $\beta$, with the addition of similar conditions on the allocated locations. More formally:

[TABLE]

With the notion of weakest tightest preconditions, we define global program logic rules for each command of our language. In contrast to local rules, global specifications contain heaplets that may be larger than the smallest heap on which one can execute the command.

Intuitively, a WTP of $\beta$ for lookup states that $\beta$ must hold in the precondition when $x$ is interpreted as $x^{\prime}$, where $x^{\prime}=f(y)$, and further that the location $y$ must belong to the support of $\beta$. The rules for mutation and allocation are more complex. For mutation, we define a transformation $\mathit{MW}^{x.f:=y}(\beta)$ that evaluates a formula $\beta$ in the pre-state as though it were evaluated in the post-state. We similarly define such a transformation $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ for allocation. We will define these in detail later. Finally, the deallocation rule ensures $x$ is not in the support of the postcondition. The conjunct $f(x)=f(x)$ is provided to satisfy the tightness condition, ensuring that the support of the precondition is the support of the postcondition with the addition of $\{x\}$. The rules can be seen below, and the proof of soundness for these global rules can be found in Section 4.7.

[TABLE]

Theorem 4.4.

The rules above suffixed with -G are sound w.r.t the operational semantics. And, each precondition corresponds to the weakest tightest precondition of $\beta$.

4.5. Definitions of $MW$ Primitives: Mutation

Recall that the $MW$555The acronym MW is a shout-out to the Magic Wand operator, as these serve a similar function, except that they are definable in FL itself. primitives $\mathit{MW}^{x.f:=y}$ and $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ need to evaluate a formula $\beta$ in the pre-state as it would evaluate in the post-state after mutation and allocation statements. The definition of $\mathit{MW}^{x.f:=y}$ is as follows:

[TABLE]

The $\beta[\lambda z.\rho(z)/f]$ notation is shorthand for saying that each occurrence of a term of the form $f(t)$, where $t$ is a term, is substituted (recursively, from inside out) by the term $\rho(t)$. The precondition essentially evaluates $\beta$ taking into account $f$’s transformation, but we use the $ite$ expression with a tautological guard $f(x)=f(x)$ (which has the support containing the singleton $x$) in order to preserve the support (see Section 4.7: Lemma 4.7). The definition of $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ is similar, but involves a few subtleties.

4.6. Definitions of $MW$ Primitives: Allocation

We have already seen the definition of $\mathit{MW}^{x.f:=y}$ in Section 4.5. Observe that the inner guard contains the expression $f(x)=f(x)$, which is a tautology that only serves to include $x$ in the support of the transformed formula (as is required by the weakest tightest precondition definition). This is similar to the Separation Logic syntax $x\mapsto\text{\textunderscore}$. Of course, one can use syntax sugars such as $\mathit{acc}(x)$ available in tools like Viper (Müller et al., 2016) to make the intent clearer.

We will detail the construction of $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ in this section.

$\mathit{MW}_{v}^{\mathsf{alloc}(x)}$, like $\mathit{MW}^{x.f:=y}$, is also meant to evaluate a formula in the pre-state as though it were evaluated in the post-state. However, note that the support of this formula must not contain the allocated location (say $x$). Since we know from the operational semantics of allocation that the allocated location is going to point to default values, we can proceed similarly as we did for the previous definition, identify terms evaluating to $f(x)$ and replace them with the default value (under $f$). This has the intended effect of evaluating to the same value as in the post-state while removing $x$ from the support.

However, this approach fails when we apply it to support expressions (since removing $x$ from the support guarantees that we would no longer compute the ‘same’ value as of that in the post-state). In particular, a subformula of the form $t\in\textit{Sp}(\gamma)$ may be falsified by that transformation. To handle this, we identify when $x$ might be in the support of a given expression and replace it with $v$ (which is given as a parameter) such that neither $x$ nor $v$ is dereferenced, and will not be in the support of the resulting transformation. We do this syntactic replacement of $x$ with $v$ for formulas not within support expressions as well. This has the effect of eliminating $x$ altogether from the formula.

We define $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ inductively. We first consider the case where $\beta$ does not contain any subformulas involving support expressions or inductive definitions. Then, we have $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ defined as follows:

[TABLE]

where this means for each instance of a (mutable or immutable) function $f$ in $\beta$, we replace $f(x)$ with a default value. We also replace all free instances of $x$ in $\beta$ with $v$.

If $\textit{Sp}(\gamma)$ is a subterm of $\beta$, we translate it to a formula $\textit{Sp}^{x;v}_{\_}\gamma$ inductively as in Figure 7. This definition is very similar to the translation of FL formulas to FO-RD in Figure 3 where we replace free instances of $x$ with $v$. Since this is a relation, we must transform membership to evaluation, i.e, transform expressions of the form $t\in\textit{Sp}(\gamma)$ to $\textit{Sp}^{x;v}_{\_}\gamma(\overline{y},\mathit{MW}_{v}^{\mathsf{alloc}(x)}(t))$ where $\overline{y}$ are the free variables (we transform inductively— at the highest level free variables will be program/ghost variables). We also transform union of support expressions to disjunction of the corresponding relations, equality to (quantified) double implication, etc.

For a subterm of $\beta$ of the form $I(\overline{t})$ where $I$ is an inductive definition with body $\rho_{\_}I$, we translate it to $I^{\prime}(\mathit{MW}_{v}^{\mathsf{alloc}(x)}(\overline{t}))$ where the body of $I^{\prime}$ is defined as $\mathit{MW}_{v}^{\mathsf{alloc}(x)}(\rho_{\_}{I^{\prime}})$.

The above cases can be combined with boolean operators and if-then-else, which $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ distributes over.

Lastly, to design the program logic rule we have to decide the value of the parameter $v$. The idea is that $v$ (which is essentially $x$) will hold the location that is going to be allocated. Since we do not know which one of the locations in the unallocated set will be actually allocated next, and $v$ will not feature in the support of the $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ formula by construction, it is enough to choose an element that simply mirrors the behaviour of the location to be allocated, in that it will evaluate the same way under any function and is different from any location that has ever been allocated. This is where we use our ‘dummy’ location constants $\textit{kf}_{\_}i$ with which we extended our signature (see Section 4.1). We also maintain the invariant that these dummy locations will not feature in the support of any preconditions that we generate. Note that we ensure that these dummy locations are indeed different by first demanding that the constants bear distinct values (see Section 4.1) and ensuring that we use a constant that does not appear in the given postcondition (see Section 4.4).

4.7. Program Logic Proofs

In this section we present soundness proofs for the global rules developed in Section 4.4. We often drop $U$ when referring to a configuration $(M,H,U)$ for ease of presentation since $U$ is only modified by the allocation rule.

Theorem 4.5 (Lookup Soundness).

Let $M$ be a model and $H$ a sub-universe of locations such that

[TABLE]

Then $(M,H)\xRightarrow{x:=y.f}(M^{\prime},H^{\prime})$, $M^{\prime}\models\beta\text{, and }H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$.

Proof.

Observe that $\llbracket y\rrbracket_{M}\in H$ since $y$ is in the support of the precondition. Therefore we know $(M,H)\xRightarrow{x:=y.f}(M^{\prime},H^{\prime})$ where $M^{\prime}=M[x\mapsto\llbracket f(y)\rrbracket_{M}]$ and $H^{\prime}=H$. Next, note that if there is a formula $\alpha$ (or term $t$) where $x$ is not a free variable of $\alpha$ (or $t$), then $M$ and $M^{\prime}$ have the same valuation of $\alpha$ (or $t$). This is true because the semantics of lookup only changes the valuation for $x$ on $M$. In particular, $M^{\prime}\models\exists x^{\prime}:x^{\prime}=f(y).\;(\beta\land y\in\textit{Sp}(\beta))[x^{\prime}/x]$. Thus,

[TABLE]

The heaplet condition follows from a similar argument. Specifically

[TABLE]

∎

Theorem 4.6 (WTP Lookup).

Let $M,M^{\prime}$ be models with $H,H^{\prime}$ sub-universes of locations (respectively) such that $(M,H)\xRightarrow{x:=y.f}(M^{\prime},H^{\prime})$, $M^{\prime}\models\beta$ and $H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$. Then

[TABLE]

Proof.

Both parts follow by simply retracing steps in the above proof. The weakness claim follows from the first part of the proof above, where all implications can be made bidirectional (using operational semantics rules, definition of existential quantifier, etc.). The tightness claim follows immediately from the second part of the proof above as all steps involve equalities. ∎

For soundness of the pointer modification rules, we prove the following lemma:

Lemma 4.7.

Given a formula $\beta$ (term $t$) and configurations $(M,H)$ and $(M^{\prime},H^{\prime})$ such that $(M,H)$ transforms to $(M^{\prime},H^{\prime})$ on the command $x.f:=y$, then $\llbracket\mathit{MW}^{x.f:=y}(\beta)\rrbracket_{M}=\llbracket\beta\rrbracket_{M^{\prime}}$. Additionally, $\llbracket\textit{Sp}(\mathit{MW}^{x.f:=y}(\beta))\rrbracket_{M}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$. Both equalities hold for terms $t$ as well.

Proof.

Induction on the structure of $\beta$, unfolding $\mathit{MW}^{x.f:=y}(\beta)$ accordingly. We discuss one interesting case here, namely when $\beta$ has a subterm of the form $f(t)$. Now, we have two cases, depending on whether $\llbracket\mathit{MW}^{x.f:=y}\rrbracket_{M}(t)=\llbracket x\rrbracket_{M}$. If it does, then

[TABLE]

The proof for the cases when $\llbracket\mathit{MW}^{x.f:=y}(t)\rrbracket_{M}\neq\llbracket x\rrbracket_{M}$ and the heaplet equality claims are similar, and all other cases are trivial. ∎

Theorem 4.8 (Mutation Soundness).

Let $M$ be a model and $H$ a sub-universe of locations such that

[TABLE]

Then $(M,H)\xRightarrow{x.f:=y}(M^{\prime},H^{\prime}),M^{\prime}\models\beta\text{, and }H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$

Proof.

From the definition of the transformation $\mathit{MW}^{x.f:=y}$, we have that $\mathit{MW}^{x.f:=y}(\beta\land x\in\textit{Sp}(\beta))$ will be transformed to the same formula as $\mathit{MW}^{x.f:=y}(\beta)\land x\in\textit{Sp}(\mathit{MW}^{x.f:=y}(\beta))$, the heaplet of which, since the formula holds on $M$, contains $x$. Therefore $x\in H$ and from the operational semantics we have that $(M,H)\xRightarrow{x.f:=y}(M^{\prime},H^{\prime})$ for some $(M^{\prime},H^{\prime})$ such that $H=H^{\prime}$.

From Lemma 4.7 we have that $M^{\prime}\models\beta\land x\in\textit{Sp}(\beta)$, since $M$ models the same. In particular $M^{\prime}\models\beta$. Moreover we have

[TABLE]

Therefore $M^{\prime}\models\beta$ and $H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$ which makes our pointer mutation rule sound. ∎

Theorem 4.9 (WTP Mutation).

Let $M,M^{\prime}$ be models with $H,H^{\prime}$ sub-universes of locations (respectively) such that $(M,H)\xRightarrow{x.f:=y}(M^{\prime},H^{\prime})$, $M^{\prime}\models\beta$ and $H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$. Then

[TABLE]

Proof.

From the operational semantics, we have that $(M,H)\xRightarrow{x.f:=y}(M^{\prime},H^{\prime})$ only if $x\in H$ and $H=H^{\prime}$. Therefore $x\in H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$ (given) which in turn implies that $M^{\prime}\models\beta\land x\in\textit{Sp}(\beta)$ as well as $H^{\prime}=\llbracket\textit{Sp}(\beta\land x\in\textit{Sp}(\beta))\rrbracket_{M^{\prime}}$. Applying Lemma 4.7 yields the result. ∎

Lemma 4.10.

Given a formula $\beta$ (or term $t$) and configurations $(M,H,U)$ and $(M^{\prime},H^{\prime},U^{\prime})$ such that $(M,H,U)\xRightarrow{\mathsf{alloc}(x)}(M^{\prime},H^{\prime},U^{\prime})$, it is the case that $\llbracket\textit{Sp}^{x;v}(\overline{y},\mathit{MW}_{v}^{\mathsf{alloc}(x)}(t))\rrbracket_{M[v\mapsto a]}$ iff $\llbracket t\in\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$, where $a=\llbracket x\rrbracket_{M^{\prime}}$ and $\overline{y}$ are the free variables in $\mathit{MW}_{v}^{\mathsf{alloc}(x)}(\beta)$. Additionally, $\llbracket\textit{Sp}(\textit{Sp}^{x;v}_{\_}{\beta}(\overline{y},z))\rrbracket_{M[v\mapsto a]}=\llbracket\textit{Sp}(\beta)\setminus\{x\}\rrbracket_{M^{\prime}}$ where $z$ is a free variable. Both equalities hold for terms $t$ as well.

Proof.

Induction on the structure of $\beta$ and using the construction in Figure 7. For the second claim about the support of $\textit{Sp}^{x;v}$, the fact that we only allow specific kinds of guards is crucial in the inductive case of the existential quantifier. ∎

Lemma 4.11.

Given a formula $\beta$ (or term $t$) and configurations $(M,H,U)$ and $(M^{\prime},H^{\prime},U^{\prime})$ such that $(M,H,U)\xRightarrow{\mathsf{alloc}(x)}(M^{\prime},H^{\prime},U^{\prime})$, we have that $\llbracket\mathit{MW}_{v}^{\mathsf{alloc}(x)}(\beta)\rrbracket_{M[v\mapsto a]}=\llbracket\beta\rrbracket_{M^{\prime}}$, where $a=\llbracket x\rrbracket_{M^{\prime}}$. Additionally, $\llbracket\textit{Sp}(\mathit{MW}_{v}^{\mathsf{alloc}(x)}(\beta))\rrbracket_{M[v\mapsto a]}=\llbracket\textit{Sp}(\beta)\setminus\{x\}\rrbracket_{M^{\prime}}$. Both equalities hold for terms $t$ as well.

Proof.

First, we split on the structure of $\beta$, as the definition of $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ differs depending on the form of $\beta$. For subformulas with no support expressions or inductive definitions, the proof follows from the syntactic definition of $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ and is very similar to Lemma 4.7. It is important to note that $a$ is a location different from any of the locations ever allocated, and is therefore different from any location held in any program variable or reachable by any recursive definition. This is crucial in the case of handling the atomic equality/disequality formulas.

Subformulas with support expressions follow by construction using Lemma 4.10, and formulas with inductive definitions follow by construction as well. Boolean combinations and if-then-else follow using the inductive hypothesis. ∎

We are now ready to prove the soundness and WTP property of the allocation rule. This will be slightly different from the other soundness theorems because it reasons only about configurations reachable by a program or a valid initial state. This strengthening of the premise is not an issue since we will only ever execute commands on such states. We shall first prove a lemma.

Lemma 4.12.

Let $\beta$ be any formula within our restricted fragment (Section 4.2) and $(M,H,U)$ be a valid configuration. Then, for any locations $a_{\_}1,a_{\_}2\in U\cup\textit{KF}$:

[TABLE]

Proof.

The proof follows by a simple inductive argument on the structure of $\beta$. First observe that in any model if $v$ is interpreted to a hitherto unallocated location (either from $U$ or one of the dummy constants) it is never contained in $\mathit{MW}_{v}^{\mathsf{alloc}(x)}(\beta)$ since it is never dereferenced. Therefore, all we are left to prove is that the actual value of $v$ (between choices in $U\cup\textit{KF}$) influences neither the truth value nor the support of the formula. The key case is that of $ite$ expressions where the value of $v$ can influence the truth of the guard. This case can be resolved using the observation that since $(M,H,U)$ is a valid configuration, the value of any unallocated location can never equal that of a program variable. Since we have no atomic relations either in our restricted fragment, any two values in $U\cup\textit{KF}$ are indistinguishable by a formula in this fragment.

In particular, any $ite$ expressions that depend on the value of $v$ either compare it with a term over a program variable —which is never equal, or compare it with a quantified variable — which itself only takes on values allowed by the guard of the quantification that, inductively, does not distinguish between values in $U\cup\textit{KF}$. ∎

Theorem 4.13 (Allocation Soundness).

Let $(M,H,U)$ be a valid configuration such that

[TABLE]

such that $\textit{kf}_{\_}j$ does not appear in $\beta$. Then $(M,H,U)\xRightarrow{\mathsf{alloc}(x)}(M^{\prime},H^{\prime},U\setminus\llbracket x\rrbracket_{M^{\prime}})$, $M^{\prime}\models\beta\text{ and }H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$

Proof.

It is easy to see that $(M,H,U)\xRightarrow{\mathsf{alloc}(x)}(M^{\prime},H^{\prime},U\setminus\llbracket x\rrbracket_{M^{\prime}})$ for some $M^{\prime},H^{\prime}$ since $U$ is infinite for any valid configuration.

Let $a$ be the actual location allocated, i.e., $a=\llbracket x\rrbracket_{M^{\prime}}$. Clearly $a\in U$ by the operational semantics. Then, we have:

[TABLE]

For the support claim, we have:

[TABLE]

Now $H^{\prime}=H\cup\{\llbracket x\rrbracket_{M^{\prime}}\}$ (by operational semantics) $=\llbracket\textit{Sp}(\beta)\setminus\{x\}\rrbracket_{M^{\prime}}\,\cup\,\{\llbracket x\rrbracket_{M^{\prime}}\}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$, as desired. ∎

Theorem 4.14 (WTP Allocation).

Let $(M,H,U)$ and $(M^{\prime},H^{\prime},U\setminus\llbracket x\rrbracket_{M^{\prime}})$ be valid configurations such that

[TABLE]

Then

[TABLE]

Proof.

The first claim follows easily from an application of Lemma 4.11 followed by an application of Lemma 4.12. For the second claim, observe that as done in the proof above for Theorem 4.13 we can prove that $\llbracket\textit{Sp}(\beta)\setminus\{x\}\rrbracket_{M^{\prime}}=\llbracket\textit{Sp}(\mathit{MW}_{\textit{kf}_{\_}j}^{\mathsf{alloc}(x)}(\beta))\rrbracket_{M}$. The proof concludes by observing that by the operational semantics we have $H=H^{\prime}\setminus\{\llbracket x\rrbracket_{M^{\prime}}\}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}\setminus\{\llbracket x\rrbracket_{M^{\prime}}\}=\llbracket\textit{Sp}(\beta)\setminus\{x\}\rrbracket_{M^{\prime}}$ ∎

Theorem 4.15 (Deallocation Soundness).

Let $M$ be a model and $H$ a sub-universe of locations such that

[TABLE]

Then $(M,H)\xRightarrow{\mathsf{free}(x)}(M^{\prime},H^{\prime}),M^{\prime}\models\beta\text{, and }H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$

Proof.

Observe that $x\in\textit{Sp}(\beta\land x\notin\textit{Sp}\beta)\land f(x)=f(x))$, i.e., $\llbracket x\rrbracket_{M}\in H$. Therefore we have from the operational semantics that $(M,H)\xRightarrow{\mathsf{free}(x)}(M^{\prime},H^{\prime})$ such that $M^{\prime}=M$ and $H^{\prime}=H\setminus\{\llbracket x\rrbracket_{M}\}$. Since $M\models\beta\land x\not\in\textit{Sp}(\beta)\land f(x)=f(x)$, we know $M\models\beta$, which implies $M^{\prime}\models\beta$. Similarly, we have:

[TABLE]

∎

Theorem 4.16 (WTP Deallocation).

Let $M,M^{\prime}$ be models with $H,H^{\prime}$ sub-universes of locations (respectively) such that $(M,H)\xRightarrow{\mathsf{free}(x)}(M^{\prime},H^{\prime})$, $M^{\prime}\models\beta$ and $H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$. Then

[TABLE]

Proof.

For the first part, note that the operational semantics ensures $\llbracket x\rrbracket_{M^{\prime}}\not\in H^{\prime}=\llbracket\textit{Sp}(\beta)\rrbracket_{M^{\prime}}$ and $M=M^{\prime}$. So $M^{\prime}\models x\not\in\textit{Sp}(\beta)$ which implies $M\models x\not\in\textit{Sp}(\beta)$. Similarly, $M\models\beta$, and $M\models f(x)=f(x)$ as it is a tautology. Tightness follows from similar arguments as in Theorem 4.15, again noting that $H^{\prime}=H\setminus\{\llbracket x\rrbracket_{M}\}$ as per the operational semantics. ∎

Theorem 4.1 0.

The four local rules (for assignment, lookup, mutation, allocation, and deallocation) given in Section 4 are sound given the global rules.

Proof.

The validity of assignment follows immediately setting $\beta$ to be $x=y$ (or $x=c$). Instantiating with this and the precondition becomes $y=y$ which is equivalent to $\mathit{true}$ (the heaplet of both is empty)

The validity of the next (lookup) follows since

[TABLE]

This is a tautology, so it is clearly implied by any precondition, in particular the precondition $f(y)=f(y)$. Similarly, the support of the resulting formula is the singleton $\{y\}$ which is also the support of $f(y)=f(y)$ as needed.

For the second local rule (mutation), we first notice that

[TABLE]

Then,

[TABLE]

The first conjunct is clearly true since it is equivalent to $y=y$. The second conjunct is also true because $\textit{Sp}(\mathit{ite}(x=x:\mathit{ite}(f(x)=f(x):y,y),f(x))=y)=\{x\}$. Thus, this formula is also a tautology, and it is implied by the precondition $f(x)=f(x)$. Additionally the support of the resulting formula and the support of $f(x)=f(x)$ is $\{x\}$ as needed.

For the next local rule (allocation), observe that the postcondition does not have any support expressions or inductive definitions. Therefore, we have that:

[TABLE]

Observe that the support of the above expression is $\emptyset$. The support of a conjunction of such expressions is also $\emptyset$. This and the fact that $\mathit{MW}_{v}^{\mathsf{alloc}(x)}$ distributes over $\land$ gives us:

[TABLE]

which is a tautology (as it is equivalent to $\mathit{def}_{\_}f=\mathit{def}_{\_}f$) and its support is $\emptyset$ as desired.

Finally the last local rule (deallocation) follows directly from the global rule for deallocation by setting $\beta=\top$. ∎

Theorem 4.17 (Conditional, While Soundness).

Proof.

See any classical proof of the soundness of these rules, as in (Apt, 1981). ∎

Theorem 4.18 (Sequence Soundness).

The Sequence rule is sound.

Proof.

Follows directly from the operational semantics. ∎

Theorem 4.19 (Consequence Soundness).

The Consequence rule is sound.

Proof.

First, note if we can’t execute $S$ then the triple is vacuously valid. Next, assume $M\models\alpha^{\prime}$. Then, because $\alpha^{\prime}\implies\alpha$, we know $M\models\alpha$. So, if we execute $S$ and result in $M^{\prime}$, we know $M^{\prime}\models\beta$ since $\{\alpha\}S\{\beta\}$ is a valid triple. Then, $M^{\prime}\models\beta^{\prime}$ since $\beta\implies\beta^{\prime}$. Finally, since the supports of $\alpha$ and $\alpha^{\prime}$ as well as $\beta$ and $\beta^{\prime}$ are equal, the validity of the Hoare triple holds. ∎

Theorem 4.20 (Frame Rule Soundness).

The Frame rule is sound.

Proof.

First, we establish that for any $(M,H)$ such that $M\models\alpha\land\mu$ and $H=\llbracket\textit{Sp}(\alpha\land\mu)\rrbracket_{M}$ we never reach $\bot$. Consider $(M,H)\overset{S}{\Rightarrow^{*}}$ as the sequence of configurations $P_{\_}2$. Construct the sequence of configurations $P_{\_}1$ as $(M,\llbracket\textit{Sp}(\alpha)\rrbracket_{M})\overset{S}{\Rightarrow^{*}}$, where each allocation from $S$ in $P_{\_}1$ chooses the same location to allocate as in $P_{\_}2$. We can show that for each step in $P_{\_}2$, there exists a corresponding step in $P_{\_}1$ such that:

1. (1)

at any corresponding step the allocated set on $P_{\_}2$ is a superset of the allocated set on $P_{\_}1$ 2. (2)

the executions allocate and deallocate the same locations

The claim as well as the first item is easy to show by structural induction on the program. Given that, the second is trivial since a location available to allocate on $P_{\_}2$ is also available to allocate on $P_{\_}1$. Any location that is deallocated on $P_{\_}2$ that is unavailable on $P_{\_}1$ would cause $P_{\_}1$ to reach $\bot$ which is disallowed since we are given that $\{\alpha\}S\{\beta\}$ is valid.

Thus if we abort on the former we must abort on the latter, which is a contradiction since we are given that $\{\alpha\}S\{\beta\}$ is valid. From the second item above, we can also establish that all mutations of the model are outside of $\textit{Sp}(\mu)$ since it is unavailable on $P_{\_}1$ (we start with $\textit{Sp}(\alpha)$ and allocate only outside $\textit{Sp}(\alpha\land\mu)=\textit{Sp}(\alpha)\cup\textit{Sp}(\mu)$, and we are also given that the supports of $\alpha$ and $\mu$ are disjoint in any model). Therefore, if there exists a configuration $(M^{\prime},H^{\prime})$ such that $(M,H)\overset{S}{\Rightarrow^{*}}(M^{\prime},H^{\prime})$ it must be the case that $M^{\prime}$ is a mutation of $M$ that is stable on $\textit{Sp}(\mu)$. Since $\{\alpha\}S\{\beta\}$ is valid we have that $M^{\prime}\models\beta$. Lastly, we conclude from the Frame Theorem (Theorem 3.7) that since $M\models\mu$, $M^{\prime}\models\mu$ which gives us $M^{\prime}\models\beta\land\mu$.

We must also show that $H^{\prime}=\llbracket\textit{Sp}(\beta\land\mu)\rrbracket_{M^{\prime}}$. To show this, we can strengthen the inductive invariant above with the fact that at any corresponding step the allocated set on $P_{\_}2$ is not simply a superset of that on $P_{\_}1$, but in fact differs exactly by $\textit{Sp}(\mu)$. This invariant establishes the desired claim, which concludes the proof of the frame rule. ∎

4.8. Example

In this section, we will see an example of using our program logic rules that we described earlier. This will demonstrate the utility of Frame Logic as a logic for annotating and reasoning with heap manipulating programs, as well as offer some intuition about how our program logic can be deployed in a practical setting. The following program performs in-place reversal of the linked list pointed to by $i$

[TABLE]

Although we must show that $j$ is the reverse of $i$ for full functional correctness, we illustrate our program logic using a simpler contract, namely that $j$ points to a $\mathit{list}$ and the end of the program. Full functional correctness can be proved similarly, modeling the content of the linked lists as mathematical sequences. The recursive definition of $\mathit{list}$ we use for this proof is the one from Figure 4:

[TABLE]

We need to also give an invariant for the while loop, simply stating that $i$ and $j$ point to disjoint lists: $\mathit{list}(i)\land\mathit{list}(j)\land\textit{Sp}(\mathit{list}(i))\cap\textit{Sp}(\mathit{list}(j))=\emptyset$.

We prove that this is indeed an invariant of the while loop below. Our proof uses a mix of both local and global rules from Sections 4.3 and 4.4 above to demonstrate how either type of rule can be used. We also use the consequence rule along with the program rule to be applied in several places in order to simplify presentation. As a result, some detailed analysis is omitted, such as proving supports are disjoint in order to use the frame rule.

[TABLE]

Armed with this, proving $j$ is a list after executing the full program above is a trivial application of the assignment, while, and consequence rules, which we omit for brevity.

Observe that in the above proof we were applying the frame rule because $i$ belongs neither to $\textit{Sp}(\mathit{list}(k))$ nor $\textit{Sp}(\mathit{list}(j))$. This can be dispensed with easily using reasoning about first-order formulas with least-fixpoint definitions, techniques for which are discussed in Section 6.

Also note the invariant of the loop is precisely the intended meaning of $\mathit{list}(i)*\mathit{list}(j)$ in separation logic. In fact, as we will see in Section 6, we can define a first-order macro $\mathit{Star}$ as $\mathit{Star}(\varphi,\psi)=\varphi\land\psi\land\textit{Sp}(\varphi)\cap\textit{Sp}(\psi)=\emptyset$. We can use this macro to represent disjoint supports in similar proofs.

These proofs demonstrate what proofs of actual programs look like in our program logic. They also show that frame logic and our program logic can prove many results similarly to traditional separation logic. And, by using the derived operator $\mathit{Star}$, very little even in terms of verbosity is sacrificed in gaining the flexibility of Frame Logic(please see Section 6 for a broader discussion of the ways in which Frame Logic differs from Separation Logic and in certain situations offers many advantages in stating and reasoning with specifications/invariants).

5. Expressing a Precise Separation Logic

In this section, we show that FL is expressive by capturing a fragment of separation logic in frame logic; the fragment is a syntactic fragment of separation logic that defines only precise formulas— formulas that can be satisfied in at most one heaplet for any store. The translation also shows that frame logic can naturally and compactly capture such separation logic formulas.

5.1. A Precise Separation Logic

As discussed in Section 1, a crucial difference between separation logic and frame logic is that formulas in frame logic have uniquely determined supports/heaplets, while this is not true in separation logic (the heaplet for $\alpha\lor\beta$ can be one that supports the truth of $\alpha$ or one that supports the truth of $\beta$ in Separation Logic). However, it is well known that in verification, determined heaplets are very natural (most uses of separation logic in fact are precise) and sometimes desirable. For instance, see (Brookes, 2007) where precision is used crucially in some proof rules regarding resource sharing to give sound semantics to concurrent separation logic and (O’Hearn et al., 2004) where precise formulas are proposed in verifying modular programs as imprecision causes ambiguity in function contracts in the frame rule. The work in (Gotsman et al., 2011) also relies on precise predicates in developing a Hoare logic for concurrent programs. Specifically, the conjunction rule is unsound in the context of imprecise predicates.

We define a fragment of separation logic that defines precise formulas (more accurately, we handle a slightly larger class inductively: formulas that when satisfiable have unique minimal heaplets for any given store).

Definition 5.1.

PSL Fragment:

• •

$\mathit{sf}$: formulas over the stack only (nothing dereferenced). Includes $\mathit{isatom}?()$, $m(x)=y$ for immutable $m$, $\top$, background formulas, and boolean combinations of these formulas.

• •

$x\xrightarrow{f}y$

• •

$\mathit{ite}(\mathit{sf},\varphi_{\_}1,\varphi_{\_}2)$ where $\mathit{sf}$ is from the first bullet

• •

$\varphi_{\_}1\land\varphi_{\_}2$ and $\varphi_{\_}1*\varphi_{\_}2$

• •

$\mathcal{I}$ where $\mathcal{I}$ contains all unary inductive definitions $I$ that have unique heaplets inductively ($\mathit{list},\mathit{tree}$, etc.). In particular, the body $\rho_{\_}I$ of $I$ is a formula in the PSL fragment ($\rho_{\_}I[I\mapsfrom\varphi]$ is in the PSL fragment provided $\varphi$ is in the PSL fragment). Additionally, for all $x$, if $s,h\models I(x)$ and $s,h^{\prime}\models I(x)$, then $h=h^{\prime}$.666While we only assume unary inductive definitions here, we can easily generalize this to inductive definitions with multiple parameters.

• •

$\exists y.\;(x\xrightarrow{f}y)*\varphi_{\_}1$

Note that in the fragment negation and disjunction are disallowed, but mutually exclusive disjunction using $\mathit{ite}$ is allowed. Existential quantification is only present when the topmost operator is a $*$ and where one of the formulas guards the quantified variable uniquely.

The semantics of this fragment follows the standard semantics of separation logic (Demri and Deters, 2015; O’Hearn, 2012; O’Hearn et al., 2001; Reynolds, 2002), with the heaplet of $x\xrightarrow{f}y$ taken to be $\{x\}$. See Remark 1 in Section 3.2 for a discussion of a more accurate heaplet for $x\xrightarrow{f}y$ being the set containing the pair $(x,f)$, and how this can be modeled in the above semantics by using field-lookups using non-mutable pointers.

Theorem 5.2 (Minimum Heap).

For any formula $\varphi$ in the PSL fragment, if there is an $s$ and $h$ such that $s,h\models\varphi$ then there is a $h_{\_}\varphi$ such that $s,h_{\_}\varphi\models\varphi$ and for all $h^{\prime}$ such that $s,h^{\prime}\models\varphi$, $h_{\_}\varphi\subseteq h^{\prime}$.

5.2. Translation to Frame Logic

For a separation logic store and heap $s,h$ (respectively), we define the corresponding interpretation $\mathcal{M}_{\_}{s,h}$ such that variables are interpreted according to $s$ and values of pointer functions on $\mathit{dom}(h)$ are interpreted according to $h$. For $\varphi$ in the PSL fragment, we first define a formula $P(\varphi)$, inductively, that captures whether $\varphi$ is precise. $\varphi$ is a precise formula iff, when it is satisfiable with a store $s$, there is exactly one $h$ such that $s,h\models\varphi$. The formula $P(\varphi)$ is in separation logic and will be used in the translation. To see why this formula is needed, consider the formula $\varphi_{\_}1\wedge\mathit{ite}(\mathit{sf},\varphi_{\_}2,\varphi_{\_}3)$. Assume that $\varphi_{\_}1$ is imprecise, $\varphi_{\_}2$ is precise, and $\varphi_{\_}3$ is imprecise. Under conditions where $\mathit{sf}$ is true, the heaplets for $\varphi_{\_}1$ and $\varphi_{\_}2$ must align. However, when $\mathit{sf}$ is false, the heaplets for $\varphi_{\_}1$ and $\varphi_{\_}3$ can be anything. Because we cannot initially know when $\mathit{sf}$ will be true or false, we need this separation logic formula $P(\varphi)$ that is true exactly when $\varphi$ is precise.

Definition 5.3.

Precision predicate $P$:

• •

$P(\mathit{sf})=\bot$ and $P(x\xrightarrow{f}y)=\top$

• •

$P(\mathit{ite}(\mathit{sf},\varphi_{\_}1,\varphi_{\_}2))=(\mathit{sf}\wedge P(\varphi_{\_}1))\vee(\neg\mathit{sf}\wedge P(\varphi_{\_}2))$

• •

$P(\varphi_{\_}1\wedge\varphi_{\_}2)=P(\varphi_{\_}1)\vee P(\varphi_{\_}2)$

• •

$P(\varphi_{\_}1*\varphi_{\_}2)=P(\varphi_{\_}1)\wedge P(\varphi_{\_}2)$

• •

$P(I)=\top$ where $I\in\mathcal{I}$ is an inductive predicate

• •

$P(\exists y.\;(x\xrightarrow{f}y)*\varphi_{\_}1)=P(\varphi_{\_}1)$

Note that this definition captures precision within our fragment since stack formulas are imprecise and pointer formulas are precise. The argument for the rest of the cases follows by simple structural induction. The interesting case is that of an inductive predicate $I$ whose body is assumed to be in the PSL fragment. We can show this by induction on the rank of $I(x)$777By the Knaster-Tarski theorem, we can compute the least-fixpoint by computing an increasing sequence pre-fixpoints for the kinds of definitions we assume. This yields a ‘rank’ for every $x$ such that $I(x)$ holds, namely the index in the sequence of pre-fixpoints when $I(x)$ first holds. for an argument $x$ when $I(x)$ holds.

Now we define the translation $T$ inductively:

Definition 5.4.

Translation from PSL to Frame Logic:

• •

$T(\mathit{sf})=\mathit{sf}$ and $T(x\xrightarrow{f}y)=(f(x)=y)$

• •

$\mathit{ite}(\mathit{sf},\varphi_{\_}1,\varphi_{\_}2)=\mathit{ite}(T(\mathit{sf}),T(\varphi_{\_}1),T(\varphi_{\_}2))$

• •

$T(\varphi_{\_}1\wedge\varphi_{\_}2)=$ \begin{array}[t]{rcl}T(\varphi_{\_}1)\wedge T(\varphi_{\_}2)&\wedge\;T(P(\varphi_{\_}1))\implies\textit{Sp}(T(\varphi_{\_}2))\subseteq\textit{Sp}(T(\varphi_{\_}1))\\ &\wedge\;T(P(\varphi_{\_}2))\implies\textit{Sp}(T(\varphi_{\_}1))\subseteq\textit{Sp}(T(\varphi_{\_}2))\end{array}

• •

$T(\varphi_{\_}1*\varphi_{\_}2)=T(\varphi_{\_}1)\wedge T(\varphi_{\_}2)\wedge\textit{Sp}(T(\varphi_{\_}1))\cap\textit{Sp}(T(\varphi_{\_}2))=\emptyset$

• •

$T(I)=T(\rho_{\_}I)$ where $\rho_{\_}I$ is the definition of the inductive predicate $I$ as in Section 3.

• •

$T(\exists y.\;(x\xrightarrow{f}y)*\varphi_{\_}1)=\exists y:[f(x)=y].\;[T(\varphi_{\_}1)\wedge x\not\in\textit{Sp}(T(\varphi_{\_}1))]$

Finally, recall that any formula $\varphi$ in the PSL fragment has a unique minimal heap (Theorem 5.2). With this (and a few auxiliary lemmas that can be found in Section 5.3), we have the following theorem, which captures the correctness of the translation:

Theorem 5.5.

For any formula $\varphi$ in the PSL fragment, we have the following implications:

[TABLE]

Here, $\mathcal{M}_{\_}{s,h}(\textit{Sp}(T(\varphi)))$ is the interpretation of $\textit{Sp}(T(\varphi))$ in the model $\mathcal{M}_{\_}{s,h}$. Note $h^{\prime}$ is minimal and is equal to $h_{\_}\varphi$ as in Theorem 5.2.

5.3. Frame Logic Can Capture the PSL fragment: Proofs

Lemma 5.6.

For any formula $\varphi$ in the PSL fragment, if there is an $s$ and $h$ such that $s,h\models\varphi$ and we can extend $h$ by some nonempty $h^{\prime}$ such that $s,h\cup h^{\prime}\models\varphi$, then for any $h^{\prime\prime}$, $s,h\cup h^{\prime\prime}\models\varphi$.

Proof.

If a stack formula holds then it holds on any heap. Pointer formulas and inductive definitions as defined can never have an extensible heap so this is vacuously true.

For $\mathit{ite}(\mathit{sf},\varphi_{\_}1,\varphi_{\_}2)$, assume WLOG $s,h\models\mathit{sf}$. Then for any $h^{\prime}$, $s,h^{\prime}\models\varphi_{\_}1\Leftrightarrow s,h^{\prime}\models\mathit{ite}(\mathit{sf},\varphi_{\_}1,\varphi_{\_}2)$. Then use the induction hypothesis.

For $\varphi_{\_}1\wedge\varphi_{\_}2$, for any $h^{\prime}$, $s,h^{\prime}\models\varphi_{\_}1\wedge\varphi_{\_}2\Leftrightarrow s,h^{\prime}\models\varphi_{\_}1$ and $s,h^{\prime}\models\varphi_{\_}2$. If the conjoined formula can be extended, both subformulas can be extended, and then we apply the induction hypothesis.

For separating conjunction, the nature of the proof is similar to conjunction, noting that the heap can be extended iff the heap of either subformula can be extended.

For existential formulas in our form, the proof is again similar, noting the heap is extensible iff the heap of $\varphi_{\_}1$ is extensible. ∎

Theorem 5.2 0.

For any formula $\varphi$ in the PSL fragment, if there is an $s$ and $h$ such that $s,h\models\varphi$ then there is an $h_{\_}\varphi$ such that $s,h_{\_}\varphi\models\varphi$ and for all $h^{\prime}$ such that $s,h^{\prime}\models\varphi$, $h_{\_}\varphi\subseteq h^{\prime}$.

Proof.

The minimal heaplets for stack formulas are empty. For $x\xrightarrow{f}y$ the heaplet is uniquely $\{x\}$.

For conjunction, there are three cases depending on if $\varphi_{\_}1$ or $\varphi_{\_}2$ or both have extensible heaplets. We cover the most difficult case where they both have extensible heaplets here. By definition we know $s,h\models\varphi_{\_}1$ and $s,h\models\varphi_{\_}2$. By induction, we know there are unique $h_{\_}{\varphi_{\_}1}$ and $h_{\_}{\varphi_{\_}2}$ such that $h_{\_}{\varphi_{\_}1}$ and $h_{\_}{\varphi_{\_}2}$ model $\varphi_{\_}1$ and $\varphi_{\_}2$ respectively and are minimal. Thus, $h_{\_}{\varphi_{\_}1}\subseteq h$ and $h_{\_}{\varphi_{\_}2}\subseteq h$, so $h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}\subseteq h$. By Lemma 5.6, $h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}$ is a valid heap for both $\varphi_{\_}1$ and $\varphi_{\_}2$. Thus, $s,h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}\models\varphi_{\_}1\wedge\varphi_{\_}2$ and $h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}$ is minimal.

For separating conjunction the minimal heaplet is (disjoint) union. For $\mathit{ite}$ we pick the heaplet of either case depending on the truth of the guard. By definition, inductive defintions will have minimal heaplets.

Inductive definitions have unique heaplets by the choice we made above and therefore vacuously satisfy the given statement.

For existentials, we know from the semantics of separation logic that every valid heap on a store $s$ for the original existential formula is a valid heap for $\psi\equiv(x\xrightarrow{f}y)*\varphi_{\_}1$ on a modified store $s^{\prime}\equiv s[y\mapsto v]$ for some $v$. Since the constraint $(x\xrightarrow{f}y)$ forces the value $v$ to be unique, we can then invoke the induction hypothesis to conclude that the minimal heaplets of the existential formula on $s$ and of $\psi$ on $s^{\prime}$ are the same. In particular, this means that existential formulas in our fragment also have a minimal heaplet. ∎

Lemma 5.7.

For any $s,h$ such that $s,h\models\varphi$ we have $\mathcal{M}_{\_}{s,h}(\textit{Sp}(T(\varphi)))=h_{\_}\varphi$ where $h_{\_}\varphi$ is as above.

Proof.

Structural induction on $\varphi$.

If $\varphi$ is a stack formula, $h_{\_}\varphi=\textit{Sp}(T(\varphi))=\emptyset$. If $\varphi\equiv x\xrightarrow{f}y$, $h_{\_}\varphi=\textit{Sp}(T(\varphi))=\{x\}$.

For $\varphi\equiv\mathit{ite}(\mathit{sf},\varphi_{\_}1,\varphi_{\_}2)$, because, $s,h\models\varphi$, we know either $s,h\models\varphi_{\_}1$ or $s,h\models\varphi_{\_}2$ depending on the truth of $\mathit{sf}$. WLOG assume $s,h\models\mathit{sf}$, then $h_{\_}\varphi=h_{\_}{\varphi_{\_}1}$. Similarly, $\textit{Sp}(T(\varphi))=\textit{Sp}(\mathit{sf})\cup\textit{Sp}(T(\varphi_{\_}1))=\textit{Sp}(T(\varphi_{\_}1))$ (heaplet of stack formulas is empty) and then we apply the induction hypothesis. Similarly if $s,h\not\models\mathit{sf}$.

For $\varphi\equiv\varphi_{\_}1\wedge\varphi_{\_}2$, we know from the proof of Theorem 5.2 that $h_{\_}\varphi=h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}=\mathcal{M}_{\_}{s,h}(\textit{Sp}(T(\varphi_{\_}1)))\cup\mathcal{M}_{\_}{s,h}(\textit{Sp}(T(\varphi_{\_}2)))$. The guard parts of the translation $\textit{Sp}(\varphi)$ since they are all precise formulas which have empty heaplets.

For $\varphi\equiv\varphi_{\_}1*\varphi_{\_}2$, the proof is the same to the previous case, again from the proof of Theorem 5.2.

For an inductive definition $I$, recall that $\rho_{\_}I[I\mapsfrom\varphi]$ is in the PSL fragment (and crucially does not mention $I$). Assume $\varphi$ is fresh and does not occur in $\rho_{\_}I$. Define $\rho_{\_}I^{\prime}\equiv\rho_{\_}I[I\mapsfrom\varphi]$ and note that $\rho_{\_}I=\rho_{\_}I^{\prime}[\varphi\mapsfrom I]$. This means that $h_{\_}{\rho_{\_}I}=h_{\_}{\rho_{\_}I^{\prime}}[h_{\_}{\varphi}\mapsfrom h_{\_}I]$. We also see that $\textit{Sp}(T(\rho_{\_}I))=\textit{Sp}(T(\rho_{\_}I^{\prime}))[\textit{Sp}(T(\varphi))\mapsfrom\textit{Sp}(T(\rho_{\_}I))]$. Because $h_{\_}{\rho_{\_}I^{\prime}}=\textit{Sp}(T(\rho_{\_}I^{\prime}))$ (by the other cases in this proof and since $\rho_{\_}I^{\prime}$ does not mention $I$), we see the heaplets are related by the same sets of recursive equations and we are done.

For existentials, we have from the definition of the Sp operator that the support of the translation of the existential formula is the same as that of $\{x\}\cup\textit{Sp}(T(\varphi_{\_}1))$. The claim then follows from the definition of heaplet of existentials in separation logic as well as the inductive hypothesis for $\varphi_{\_}1$. ∎

Theorem 5.5 0.

For any formula $\varphi$ in the PSL fragment, we have the following implications:

[TABLE]

Here, $\mathcal{M}_{\_}{s,h}(\textit{Sp}(T(\varphi)))$ is the interpretation of $\textit{Sp}(T(\varphi))$ in the model $\mathcal{M}_{\_}{s,h}$. Note $h^{\prime}$ is minimal and is equal to $h_{\_}\varphi$ as in Theorem 5.2.

Proof.

First implication: Structural induction on $\varphi$.

If $\varphi$ is a stack formula or a pointer formula, this is true by construction. If $\varphi$ is an if-then-else formula the claim is true by construction and the induction hypothesis.

If $\varphi=\varphi_{\_}1\land\varphi_{\_}2$, we know by the induction hypothesis that $\mathcal{M}_{\_}{s,h}\models T(\varphi_{\_}1)$ and $\mathcal{M}_{\_}{s,h}\models T(\varphi_{\_}2)$. Further, from the semantics of separation logic, we have that if $\varphi_{\_}1$ is precise, then $h_{\_}{\varphi_{\_}1}=h$. Therefore, $h_{\_}{\varphi_{\_}2}\subseteq h_{\_}{\varphi_{\_}1}$ (by Lemma 5.2). Therefore, from Lemma 5.7, we have that $\mathcal{M}_{\_}{s,h}\models\textit{Sp}(T(\varphi_{\_}2))\subseteq\textit{Sp}(T(\varphi_{\_}1))$. Similarly if $\varphi_{\_}2$ is precise. This justifies the two latter conjuncts of the translation.

If $\varphi=\varphi_{\_}1*\varphi_{\_}2$, we know there exist $h_{\_}1,h_{\_}2$ such that $h_{\_}1\cap h_{\_}2=\emptyset$ and $s,h_{\_}1\models\varphi_{\_}1$ and $s,h_{\_}2\models\varphi_{\_}2$. Then, from Lemma 5.2, we have that $h_{\_}{\varphi_{\_}1}\subseteq h_{\_}1$ and $h_{\_}{\varphi_{\_}2}\subseteq h_{\_}2$. Thus, by Lemma 5.7, we have that $\mathcal{M}_{\_}{s,h}\models\textit{Sp}(T(\varphi_{\_}1))\cap\textit{Sp}(T(\varphi_{\_}2))=\emptyset$. The other conjuncts follow from the induction hypothesis.

Similarly to the proof of Lemma 5.7, we can show that the translation of the inductive definition satisfies the same recursive equations as the original inductive definition and we are done.

If $\varphi$ is an existential, the result follows from definition and the induction hypothesis.

Second implication: Structural induction on $\varphi$.

By construction, induction hypotheses, and Lemma 5.7, all cases can be discharged besides conjunction and inductive predicates.

For conjunction, if $\varphi=\varphi_{\_}1\land\varphi_{\_}2$, we have from the induction hypothesis that $s,h_{\_}{\varphi_{\_}1}\models\varphi_{\_}1$ and $s,h_{\_}{\varphi_{\_}2}\models\varphi_{\_}2$. If $\varphi_{\_}1$ is precise, we know $\mathcal{M}_{\_}{s,h}\models\textit{Sp}(T(\varphi_{\_}2))\subseteq\textit{Sp}(T(\varphi_{\_}1))$ and therefore $h_{\_}{\varphi_{\_}2}\subseteq h_{\_}{\varphi_{\_}1}$ (from Lemma 5.7). Similarly, if $\varphi_{\_}2$ is precise, then $\mathcal{M}_{\_}{s,h}\models\textit{Sp}(T(\varphi_{\_}1))\subseteq\textit{Sp}(T(\varphi_{\_}2))$ as well as $h_{\_}{\varphi_{\_}1}\subseteq h_{\_}{\varphi_{\_}2}$. In particular, if they are both precise, their supports (and therefore minimal heaplets) are equal, and $h^{\prime}=h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}$ (from the proof of Lemma 5.2) $=h_{\_}{\varphi_{\_}1}=h_{\_}{\varphi_{\_}2}$, and we are done. If only $\varphi_{\_}1$ is precise (similarly if only $\varphi_{\_}2$ is precise), then we have as above that $h_{\_}{\varphi_{\_}2}\subseteq h_{\_}{\varphi_{\_}1}$ and $h_{\_}{\varphi_{\_}1}=h^{\prime}$. Moreover, we know by Lemma 5.6 that $s,h_{\_}{\varphi_{\_}1}\models\varphi_{\_}2$ and we are done. If neither is precise, both heaps are extensible, so we know by Lemma 5.6 that $s,h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}\models\varphi_{\_}1$ and $s,h_{\_}{\varphi_{\_}1}\cup h_{\_}{\varphi_{\_}2}\models\varphi_{\_}2$ and we are done.

For $\varphi$ an inductive predicate, we know that \mathcal{M}_{\_}{s,h}\big{|}\textit{Sp}(T(\varphi))\models T(\varphi). The remainder follows since, because we restrict the form of inductive predicates to have a unique heap at each level, the translated inductive predicate will satisfy the same recursive equations as $\varphi$.

∎

6. Discussion

6.1. Comparison with Separation Logic

The design of frame logic is, in many ways, inspired by the design choices of separation logic. Separation logic formulas implicitly hold on tight heaplets— models are defined on pairs $(s,h)$, where $s$ is a store (an interpretation of variables) and $h$ is a heaplet that defines a subset of the heap as the domain for functions/pointers. In Frame Logic, we choose to not define satisfiability with respect to heaplets but define it with respect to the entire global heap. However, we give access to the implicitly defined heaplet using the operator Sp, and give a logic over sets to talk about supports. The separating conjunction operation $*$ can then be expressed using normal conjunction of the two formulae and a constraint that says that the supports of the formulas are disjoint (e.g., $x\overset{\mathit{next}}{\mapsto}y*\mathit{list}(y)$ can be expressed in FL as $\mathit{next}(x)=y\land\mathit{list}(y)\land\textit{Sp}(\mathit{next}(x)=y)\cap\textit{Sp}(\mathit{list}(y))=\emptyset$).

We do not allow formulas to have multiple supports which is crucial (Sp is a function). Precise fragments of separation logic have been proposed and accepted in the separation logic literature a way of giving robust semantics in handling modular functions and concurrency (O’Hearn et al., 2004; Brookes, 2007). Section 5 details a translation of a precise fragment of separation logic (with $*$ but not magic wand) to frame logic that shows the natural connection between precise formulas in separation logic and frame logic. When converting arbitrary (potentially imprecise) separation logic formulas to first-order logic, there is an inherent existential quantifier over heaplets that makes reasoning difficult, due to the non-uniqueness of heaplets. Our logic however does not have this problem because supports are uniquely defined, and hence we do not need to quantify over heaplets (as in the above example).

Frame logic, through the support operator, facilitates local reasoning much in the same way as separation logic does, and the frame rule in frame logic supports frame reasoning in a similar way as the frame rule in separation logic. The key difference between frame logic and separation logic is the adherence to a first-order logic (with recursive definitions), both in terms of syntax and expressiveness. Note that there is no difference in regards to completeness, as both Separation Logic and FO-RD are incomplete (Reynolds, 2002; Calcagno et al., 2001; Löding et al., 2018). We refer the reader to page 3 where several nuances in semantic choices are explained.

There are several other key differences between separation logic and frame logic. First, in separation logic, the magic wand operator is needed to express the weakest precondition (Reynolds, 2002). Consider for example computing the weakest precondition of the formula $list(x)$ with respect to the code $y.n:=z$. The weakest precondition should essentially describe the (tight) heaplets such that changing the $n$ pointer from $y$ to $z$ results in $x$ pointing to a list. In separation logic, this is expressed typically (see (Reynolds, 2002)) using magic wand as $(y\xrightarrow{n}z)~{}-\!\!*~{}(list(x))$. However, the magic wand operator is inherently a second-order property (Brochenin et al., 2008). The formula $\alpha-\!\!*\beta$ holds on a heaplet $h$ if for any disjoint heaplet that satisfies $\alpha$, $\beta$ will hold on the conjoined heaplet. Expressing this property (for arbitrary $\alpha$, whose heaplet can be unbounded) requires quantifying over unbounded heaplets satisfying $\alpha$, which is not first order expressible.

In frame logic, we instead rewrite the recursive definition $list(\cdot)$ to a new one $list^{\prime}(\cdot)$ that captures whether $x$ points to a list, assuming that $n(y)=z$ (see Section 4.4). This property continues to be expressible in frame logic and can be converted to first-order logic with recursive definitions (see Section 3.6). Note that we are exploiting the fact that there is only a bounded amount of change to the heap in loop-free programs in order to express this in FL.

Let us turn to expressiveness and succinctness. In separation logic, separation of structures is expressed using $*$, and in frame logic, such a separation is expressed using conjunction and an additional constraint that says that the supports of the two formulas are disjoint. A precise separation logic formula of the form $\alpha_{\_}1*\alpha_{\_}2*\ldots\alpha_{\_}n$ is succinct and would get translated to a much larger formula in frame logic as it would have to state that the supports of each pair of formulas is disjoint. We believe this can be tamed using macros ($\textit{Star}(\alpha,\beta)=\alpha\wedge\beta\wedge\textit{Sp}(\alpha)\cap\textit{Sp}(\beta)=\emptyset$).

There are, however, several situations where frame logic leads to more compact and natural formulations. For instance, consider expressing the property that $x$ and $y$ point to lists, which may or may not overlap. In Frame Logic, we simply write $list(x)\land list(y)$. The support of this formula is the union of the supports of the two lists. In separation logic, we cannot use $*$ to write this compactly (while capturing the tightest heaplet). Note that the formula $(list(x)*true)\wedge(list(y)*true)$ is not equivalent, as it is true in heaplets that are larger than the set of locations of the two lists. The simplest formulation we know is to write a recursive definition $\mathit{lseg}(u,v)$ for list segments from $u$ to $v$ and use quantification: $(\exists z.~{}\mathit{lseg}(x,z)*\mathit{lseg}(y,z)*list(z))\vee(list(x)*list(y))$ where the definition of $\mathit{lseg}$ is the following: $\mathit{lseg}(u,v)\equiv(u=v\land\mathit{emp})\lor(\exists w.~{}u\rightarrow w~{}*~{}lseg(w,v))$.

If we wanted to say $x_{\_}1,\ldots,x_{\_}n$ all point to lists, that may or may not overlap, then in FL we can say $list(x_{\_}1)\land list(x_{\_}2)\land\ldots\land list(x_{\_}n)$. However, in separation logic, the simplest way seems to be to write using $\mathit{lseg}$ and a linear number of quantified variables and an exponentially-sized formula. Now consider the property saying $x_{\_}1,\ldots,x_{\_}n$ all point to binary trees, with pointers left and right, and that can overlap arbitrarily. We can write it in FL as $tree(x_{\_}1)\land\ldots\land tree(x_{\_}n)$, while a formula in separation logic that expresses this property seems very complex.

The difficulty of using separation logic to capture such overlapping datastructures (Krishna et al., 2020; Lee et al., 2011) has been noticed in the past. For example, the work in (Hobor and Villard, 2013) introduces an overlapping conjunction operator \mathbin{\vphantom{\cup}\mathchoice{\ooalign{\displaystyle\cup\cr\raisebox{1.04999pt}{}\cr}}{\ooalign{\textstyle\cup\cr\raisebox{1.04999pt}{}\cr}}{\ooalign{\scriptstyle\cup\cr\raisebox{0.75pt}{}\cr}}{\ooalign{\scriptscriptstyle\cup\cr\raisebox{0.59999pt}{}\cr}}} to separation logic, which unlike $*$ or $\land$, allows the conjunction of two properties whose heaplets may overlap but not coincide, and can express the above properties we mention succinctly. However, the ramification rules proposed in that paper to reason with overlapping datastructures seem inherently second-order, introducing the magic wand (Brochenin et al., 2008). The work in (Pagel, 2020) explores a decidable fragment of separation logic with inductive definitions including guarded magic wands to capture overlaid datastructures.

In summary, we believe that frame logic is a logic that supports frame reasoning built on similar principles as separation logic, but is still translatable to first-order logic (avoiding the magic wand) while still being closed under weakest preconditions. Furthermore, the choices it makes in syntax and semantics lead to expressing certain properties more naturally and compactly, while others more verbosely.

6.2. Reasoning with Frame Logic

A important advantage of the adherence of frame logic is that it is translatable to a first-order logic with recursive definitions, opening up the possibility of using solvers for the latter in order to reason with frame logic.

Notably, we are inspired by the reasoning using the framework on Natural Proofs (Pek et al., 2014; Qiu et al., 2013; Löding et al., 2018). In this work, recursive definitions with least fixpoint semantics are first abstracted to fixpoint definitions, lending to a formulation in pure first-order logic. Second, universal quantifiers are instantiated using terms in the formula, and recursive definitions are unfolded on terms as well. Finally, the resulting formulae, which are quantifier-free are checked using SMT solvers. A remarkable result is that for a safe fragment of the logic (which verification conditions for datastructure manipulating programs often adhere to), the above technique is complete with respect to pure FO reasoning (Löding et al., 2018). The work in (Murali et al., 2020b) also attempts to bridge the gap between the first-order reasoning of natural proofs and the least-fixpoint semantics of the inductive definitions by synthesizing inductive lemmas.

Our main hope of reasoning with frame logic resides in this technique, which has already been used in reasoning with Dryad, a precise fragment of separation logic, by converting it to first-order logic with recursive definitions (Pek et al., 2014; Qiu et al., 2013). The evaluation of Dryad on a suite of 150 heap programs has been reported in the works on Natural Proofs (see http://madhu.cs.illinois.edu/vcdryad/) providing evidence that the technique works well in practice. However, we believe that verification conditions using the weakest precondition derived in this paper introduce certain quantifications that may make it harder than necessary to reason with. We believe an approach of verification condition generation based on strongest postconditions (or symbolic execution), as done in (Qiu et al., 2013; Pek et al., 2014), and with the frame logic restricted in order to not introduce existential quantification in specifications, would lead to an efficient solver. In particular, the support of recursively defined functions can be generated automatically using our translation, while the work in (Pek et al., 2014; Qiu et al., 2013) translated heaplets for Dryad formulas using manual unverified translations. This work is however beyond the scope of this paper, and we leave it for the future. The main technical challenge is to restrict frame logic annotations to not use existential quantification and realize supports of inductively defined datastructures as FO inductive definitions over set without introducing additional quantifiers.

Another mechanism to reason with frame logic is to convert it into FO-RD, and use it in frameworks such as Dafny (Leino, 2010) or Boogie (Barnett et al., 2005; Banerjee et al., 2008a) that support rich user-annotation based reasoning. In particular, the methodology of region logics (Banerjee et al., 2013; Banerjee and Naumann, 2013; Banerjee et al., 2008b) suggests ways of encoding supports as sets in first-order logics, and carry through proofs using ghost annotations that update a ghost state and help prove theorems. This methodology typically requires help from the user in terms of ghost annotations, but much of the reasoning otherwise is delegated to automatic logic engines (mainly SMT solvers). Region logic (Banerjee et al., 2013; Banerjee and Naumann, 2013; Banerjee et al., 2008b) itself is a logic for heap manipulating programs that supports explicit heaplets and frame-based reasoning using them, rather than the implicit heaplets of frame logic.

7. Related Work

The frame problem (Hayes, 1981; Borgida et al., 1995) is an important problem in many different domains of research. In the broadest form, it concerns representing and reasoning about the effects of a local action without requiring explicit reasoning regarding static changes to the global scope. For example, in artificial intelligence one wants a logic that can seamlessly state that if a door is opened in a lit room, the lights continue to stay switched on. This issue is present in the domain of verification as well, specifically with heap-manipulating programs.

There are many solutions that have been proposed to this problem. The most prominent proposal in the verification context is separation logic (Demri and Deters, 2015; O’Hearn, 2012; O’Hearn et al., 2001; Reynolds, 2002), which we discussed in detail in the previous section.

The work on Dynamic Frames (Kassios, 2006, 2011) and similarly inspired approaches such as Region Logic (Banerjee et al., 2013; Banerjee and Naumann, 2013; Banerjee et al., 2008b) allow programs to explicitly specify parts of the heap that may be modified. The key idea is the notion of regions, which are subsets of locations that can be manipulated in code (as ghost variables) as well as used in annotations in order to perform frame reasoning. This allows a finer-grained specification of the portion of the heap modified by programs, avoiding special symbols like $*$ and $-*$. Section 6.2 discusses on verification methodologies based on these logics as well as using using these techniques to reasoning with FL. In contrast, FL itself has implicit supports given using the Sp operator.

The work on Implicit Dynamic Frames (Smans et al., 2012; Leino and Müller, 2009; Smans et al., 2009; Parkinson and Summers, 2011) bridges the worlds of separation logic and dynamic frames— it uses separation logic and fractional permissions to implicitly define frames (reducing annotation burden), allows annotations to access these frames, and translates them into set regions for first-order reasoning. Our work is similar in that frame logic also implicitly defines regions and gives annotations access to these regions, and can be easily translated to pure FO-RD for first-order reasoning. However, implicit dynamic frames do not allow a formula to access anything in a function that is not in the support of the function’s precondition. Further, all implementations of Implicit Dynamic Frames such as Chalice (Parkinson and Summers, 2011) and Viper (Müller et al., 2016) only handle restricted formulas. For example, non-separating conjunction is prohibited. In addition, a translation from the VeriFast thereom prover to Implicit Dynamic Frames (Jacobs et al., 2011; Jost and Summers, 2014) contains similarly restricted formulas.

One distinction with separation logic involves the non-unique heaplets in separation logic and the unique heaplets in frame logic. Determined heaplets have been used (Qiu et al., 2013; Pek et al., 2014; O’Hearn et al., 2004) as they are more amenable to automated reasoning. In particular a separation logic fragment with determined heaplets known as precise predicates is defined in (O’Hearn et al., 2004), which we capture using frame logic in Section 5.

There is also a rich literature on reasoning with these heap logics for program verification. Decidability is an important dimension and there is a lot of work on decidable logics for heaps with separation logic specifications (Berdine et al., 2006, 2004, 2005; Cook et al., 2011; Navarro Pérez and Rybalchenko, 2011; Pérez and Rybalchenko, 2013). The work based on EPR (Effectively Propositional Reasoning) for specifying heap properties (Itzhaky et al., 2014a, 2013, b) provides decidability, as does some of the work that translates separation logic specifications into classical logic (Piskac et al., 2013).

The work in (Bobot and Filliâtre, 2012) defines an extension of first-order logic and inductive definitions with footprints, where the design decisions on the semantics of footprints are very similar to ours. The work develops the notion of ‘separation predicates’ based on these footprint expressions as well as verification conditions for programs annotated with first-order formulas involving separation predicates. The work also realizes an implementation of this technique by generating verification conditions and using Why3 (Filliâtre and Paskevich, 2013; Bobot et al., 2011). The footprint expressions compute the same set as our Sp operator (with some minor syntactic changes), but our work handles a much larger fragment. In particular, apart from only defining supports for recursive predicates, the work in (Bobot and Filliâtre, 2012) disallows quantification, non-separating conjunction, and separation predicates in the body of recursive predicates. This makes it difficult to define many of the typical data-structures shown in Figure 4 in their logic.

Translating separation logic into other logics and reasoning with them is another solution pursued in a lot of recent efforts (Chin et al., 2007; Pek et al., 2014; Piskac et al., 2013, 2014a, 2014b; Madhusudan et al., 2012; Pek et al., 2014; Qiu et al., 2013; Suter et al., 2010; Löding et al., 2018). Other techniques including recent work on cyclic proofs (Brotherston et al., 2011; Ta et al., 2016) use heuristics for reasoning about recursive definitions.

Finally, there is also work that studies first-order logics such as FO(ID) with more general non-monotonic inductive definitions motivated by AI applications such as the frame problem and the modeling of causal processes of knowledge (Denecker, 2000; Denecker and Vennekens, 2014). FO(ID) generalizes the least-fixpoint semantics (Tarski, 1955) we use for definitions in FO-RD (which are all required to be monotonic).

8. Conclusions

Our main contribution is to propose Frame Logic, a first-order logic endowed with an explicit operator that recovers the implicit supports of formulas and supports frame reasoning. We have argued its expressiveness by capturing several properties of data-structures naturally and succinctly, and by showing that it can express a precise fragment of separation logic. The program logic built using frame logic supports local heap reasoning, frame reasoning, and weakest tightest preconditions across loop-free programs.

We believe that frame logic is an attractive alternative to separation logic, built using similar principles as separation logic while staying within the first-order logic world. The first-order nature of the logic makes it potentially amenable to easier automated reasoning.

A practical realization of a tool for verifying programs in a standard programming language with frame logic annotations by marrying it with existing automated techniques and tools for first-order logic (in particular (Madhusudan et al., 2012; Pek et al., 2014; Qiu et al., 2013; Suter et al., 2010; Kovács et al., 2017)), is the most compelling future work.

Another area for future work involves potential extensions to Frame Logic. For example, the work in (Krishnaswami et al., 2009) uses magic wand for verifying certain design patterns including iterators, and extending Frame Logic similarly is an interesting possible direction. Other potential extensions include support for function pointers and permission models.