SOME EXAMPLES WE CANNOT HANDLE.

To demonstrate the kind of problems Ctrl cannot yet handle, we compare a recursive definition sum of the function n 7→Pn

i=1i with three iterative implementations.

int sum(n) { if (n < 0) return 0; return n + sum(n-1); } int sum1(n) { int i = 0, j = 0, sum = 0;

for (; i <= n; i++,j++) sum += j; return len; } int sum2(int n){ int i,sum=0; for (i=n;i>=0;i--) sum=sum+i; return sum; } int sum3(n) { int ret = 0;

for (int i = 0; i <= n; i++)

for (int j = 0; j < i; j++) ret++; return ret;

}

Equivalence between sum and each of sum1, sum2 and sum3 fails for the three main reasons discussed in§ 6.2. For sum1, generalizing the initialization variables loses the information that always i = j. For sum2, our main generalization method (§ 5.1) does not apply because we do not recognize i = n as an initialization. For sum3, our strategy fails because the two loop counters are generalized together.

References

ALBERT, E., ARENAS, P., GENAIM, S., PUEBLA, G.,ANDZANARDINI, D. 2008. Removing useless variables in cost analysis of Java bytecode. In SAC ’08. 368–375.

ALBERT, E., G ´OMEZ-ZAMALLOA, M., HUBERT, L., AND PUEBLA, G. 2007. Verification of Java bytecode using analysis and transformation of logic programs. In PADL ’07. 124–139.

ALIAS, C.ANDBARTHOU, D. 2003. Algorithm recognition based on demand-driven data-flow analysis. In WCRE ’03. 296–305.

ALPUENTE, M., ESCOBAR, S.,ANDLUCAS, S. 2007. Removing redundant arguments automatically. Theory and Practice of Logic Programming 7, 1-2, 3–35.

AUBIN, R. 1979. Mechanizing structural induction part I: formal system. Theor. Comp. Sci. 9, 3, 329–345. BAADER, F.ANDNIPKOW, T. 1998. Term Rewriting and All That. Cambridge University Press.

BARTHE, G., D’ARGENIO, P. R.,ANDREZK, T. 2011. Secure information flow by self-composition. Mathe- matical Structures in Computer Science 21, 6, 1207–1252.

BASIN, D. A.ANDWALSH, T. 1992. Difference matching. In CADE ’92. 295–309.

BEYER, D., CIMATTI, A., GRIGGIO, A., KEREMOGLU, M. E.,ANDSEBASTIANI, R. 2009. Software model checking via large-block encoding. In FMCAD ’09. 25–32.

BOUHOULA, A. 1997. Automated theorem proving by test set induction. J. Symb. Comput. 23, 1, 47–77. BOUHOULA, A.ANDJACQUEMARD, F. 2008a. Automated induction for complex data structures. Tech. Rep.

arXiv:0811.4720 [cs.LO], CoRR. Available on http://arxiv.org/abs/0811.4720.

BOUHOULA, A.AND JACQUEMARD, F. 2008b. Automated induction with constrained tree automata. In IJCAR ’08. 539–554.

BROCKSCHMIDT, M., COOK, B., ISHTIAQ, S., KHLAAF, H.,ANDPITERMAN, N. 2016. T2: Temporal property verification. In TACAS ’16. 387–393.

BUNDY, A. 2001. The automation of proof by mathematical induction. In Handbook of Automated Reasoning. Elsevier, 845–911.

BUNDY, A., BASIN, D., HUTTER, D.,ANDIRELAND, A. 2005. Rippling: Meta-Level Guidance for Mathemat- ical Reasoning. Cambridge University Press.

BUNDY, A., STEVENS, A.,VANHARMELEN, F., IRELAND, A.,ANDSMAILL, A. 1993. Rippling: a heuristic for guiding inductive proofs. Artificial Intelligence 62, 2, 185–253.

CALCAGNO, C., DISTEFANO, D., DUBREIL, J., GABI, D., HOOIMEIJER, P., LUCA, M., O’HEARN, P. W., PA-

PAKONSTANTINOU, I., PURBRICK, J.,ANDRODRIGUEZ, D. 2015. Moving fast with software verification. In NFM ’15. 3–11.

DEMOURA, L.ANDBJØRNER, N. 2008. Z3: An efficient SMT solver. In TACAS ’08. 337–340.

FALKE, S. 2009. Term rewriting with built-in numbers and collection data structures. Ph.D. thesis, Univer- sity of New Mexico.

FALKE, S. AND KAPUR, D. 2009. A term rewriting approach to the automated termination analysis of imperative programs. In CADE ’09. 277–293.

FALKE, S.ANDKAPUR, D. 2012. Rewriting induction + linear arithmetic = decision procedure. In IJCAR ’12. 241–255.

FALKE, S., KAPUR, D.,ANDSINZ, C. 2011. Termination analysis of C programs using compiler intermediate languages. In RTA ’11. 41–50.

FELSING, D., GREBING, S., KLEBANOV, V., R ¨UMMER, P.,ANDULBRICH, M. 2014. Automating regression verification. In ASE ’14. 349–360.

FUHS, C., GIESL, J., PLUCKER¨ , M., SCHNEIDER-KAMP, P.,ANDFALKE, S. 2009. Proving termination of integer term rewriting. In RTA ’09. 32–47.

FURUICHI, Y., NISHIDA, N., SAKAI, M., KUSAKARI, K.,ANDSAKABE, T. 2008. Approach to procedural- program verification based on implicit induction of constrained term rewriting systems. IPSJ Trans. Prog. 1, 2, 100–121. In Japanese; translated summary at http://www.trs.css.i.nagoya-u.ac.jp/crisys/. GIESL, J., ASCHERMANN, C., BROCKSCHMIDT, M., EMMES, F., FROHN, F., FUHS, C., HENSEL, J., OTTO,

C., PLUCKER¨ , M., SCHNEIDER-KAMP, P., STRODER¨ , T., SWIDERSKI, S.,AND THIEMANN, R. 2017. Analyzing program termination and complexity automatically with AProVE. J. Aut. Reasoning 58, 1, 3–31.

GIESL, J., K ¨UHNEMANN, A.,ANDVOIGTLANDER¨ , J. 2007. Deaccumulation techniques for improving prov- ability. J. Log. Algebr. Program. 71, 2, 79–113.

GODLIN, B.ANDSTRICHMAN, O. 2008. Inference rules for proving the equivalence of recursive procedures. Acta Inf. 45, 6, 403–439.

GODLIN, B.ANDSTRICHMAN, O. 2013. Regression verification: proving the equivalence of similar programs. Softw. Test., Verif. Reliab. 23, 3, 241–258.

GUPTA, A., POPEEA, C.,ANDRYBALCHENKO, A. 2011. Predicate abstraction and refinement for verifying multi-threaded programs. In POPL ’11. 331–344.

HAWBLITZEL, C., KAWAGUCHI, M., LAHIRI, S. K.,ANDREBELOˆ , H. 2013. Towards modularly comparing programs using automated theorem provers. In CADE ’13. 282–299.

HUET, G. P.ANDHULLOT, J.-M. 1982. Proofs by induction in equational theories with constructors. Journal of Computer and System Sciences 25, 2, 239–266.

HUTH, M.ANDRYAN, M. 2000. Logic in Computer Science: Modelling and Reasoning about Systems. Cam- bridge University Press.

KAPUR, D.AND SAKHANENKO, N. A. 2003. Automatic generation of generalization lemmas for proving properties of tail-recursive definitions. In TPHOLs ’03. 136–154.

KAPUR, D.ANDSUBRAMANIAM, M. 1996. Lemma discovery in automated induction. In CADE ’96. 538–552. KOIKE, H.ANDTOYAMA, Y. 2000. Comparison between inductionless induction and rewriting induction.

Comp. Soft. 17, 6, 1–12. In Japanese.

KOP, C. 2013. Termination of LCTRSs. In WST ’13. 59–63.

KOP, C. 2017. Quasi-reductivity of Logically Constrained Term Rewriting Systems. Tech. Rep. arXiv:1702.02397 [cs.LO], CoRR. Available on https://arxiv.org/abs/1702.02397.

KOP, C.ANDNISHIDA, N. 2013. Term rewriting with logical constraints. In FroCoS ’13. 343–358.

KOP, C.AND NISHIDA, N. 2014. Automatic constrained rewriting induction towards verifying procedural programs. In APLAS ’14. 334–353.

KOP, C.ANDNISHIDA, N. 2015. ConsTrained Rewriting tooL. In LPAR ’15. 549–557.

KUNDU, S., TATLOCK, Z.,ANDLERNER, S. 2009. Proving optimizations correct using parameterized pro- gram equivalence. In PLDI ’09. 327–337.

LAHIRI, S. K., HAWBLITZEL, C., KAWAGUCHI, M.,ANDREBELOˆ , H. 2012. SYMDIFF: A language-agnostic semantic diff tool for imperative programs. In CAV ’12. 712–717.

LOPES, N. P.AND MONTEIRO, J. 2016. Automatic equivalence checking of programs with uninterpreted functions and integer arithmetic. Int. J. Softw. Tools Technol. Transfer 18, 4, 359–374.

MCCARTHY, J. 1960. Recursive functions of symbolic expressions and their computation by machine, part I. Commun. ACM 3, 4, 184–195.

NAKABAYASHI, N., NISHIDA, N., KUSAKARI, K., SAKABE, T.,AND SAKAI, M. 2010. Lemma generation method in rewriting induction for constrained term rewriting systems. Computer Software 28, 1, 173– 189. In Japanese; translation at http://www.trs.css.i.nagoya-u.ac.jp/crisys/.

NECULA, G. C. 2000. Translation validation for an optimizing compiler. In PLDI ’00. 83–94.

NIEUWENHUIS, R., OLIVERAS, A.,ANDTINELLI, C. 2006. Solving SAT and SAT modulo theories: From an abstract Davis–Putnam–Logemann–Loveland procedure to DPLL(T). J. ACM 53, 6, 937–977.

OTTO, C., BROCKSCHMIDT, M.,VONESSEN, C.,ANDGIESL, J. 2010. Automated termination analysis of Java bytecode by term rewriting. In RTA ’10. 259–276.

PNUELI, A., SIEGEL, M.,ANDSINGERMAN, E. 1998. Translation validation. In TACAS ’98. 151–166. REDDY, U. S. 1990. Term rewriting induction. In CADE ’90. 162–177.

SAKATA, T., NISHIDA, N.,ANDSAKABE, T. 2011. On proving termination of constrained term rewrite sys- tems by eliminating edges from dependency graphs. In WFLP ’11. 138–155.

SAKATA, T., NISHIDA, N., SAKABE, T., SAKAI, M.,ANDKUSAKARI, K. 2009. Rewriting induction for con- strained term rewriting systems. IPSJ Trans. Prog. 2, 2, 80–96. In Japanese; a translated summary is available at http://www.trs.css.i.nagoya-u.ac.jp/crisys/.

SPOTO, F., LU, L.,ANDMESNARD, F. 2009. Using CLP simplifications to improve Java bytecode termination analysis. Electr. Notes Theor. Comput. Sci. 253, 5, 129–144.

SV-COMP. Competition on software verification. http://sv-comp.sosy-lab.org/.

TERAUCHI, T.ANDAIKEN, A. 2005. Secure information flow as a safety problem. In SAS ’05. 352–367. URSO, P. AND KOUNALIS, E. 2004. Sound generalizations in mathematical induction. Theor. Comput.

Sci. 323, 1-3, 443–471.

VERDOOLAEGE, S., JANSSENS, G.,ANDBRUYNOOGHE, M. 2012. Equivalence checking of static affine pro- grams using widening to handle recurrences. ACM Trans. Program. Lang. Syst. 34, 3, 11.

VUJOSEVIC-JANICIC, M., NIKOLIC, M., TOSIC, D.,ANDKUNCAK, V. 2013. Software verification and graph similarity for automated evaluation of students’ assignments. Inf. & Softw. Technology 55, 6, 1004–1016. WALSH, T. 1996. A divergence critic for inductive proof. J. Artificial Intelligence Research 4, 209–235.