diff options
author | Clark Barrett <clarkbarrett@google.com> | 2015-04-23 09:43:52 -0700 |
---|---|---|
committer | Clark Barrett <clarkbarrett@google.com> | 2015-04-23 09:43:52 -0700 |
commit | dea679ce032c130d210d54c2e5482f95db1ff04a (patch) | |
tree | 6c36f68150172b20717f7d504274ab0bf82791b0 | |
parent | d95fe7675e20eaee86b8e804469e6db83265a005 (diff) |
A few more minor updates to match google repository with CVC4 repository
(mostly whitespace differences).
39 files changed, 7136 insertions, 7136 deletions
diff --git a/config/ax_prog_doxygen.m4 b/config/ax_prog_doxygen.m4 index 2d50f4e6d..3a9744aa9 100644 --- a/config/ax_prog_doxygen.m4 +++ b/config/ax_prog_doxygen.m4 @@ -1,323 +1,323 @@ -# This file is part of Autoconf. -*- Autoconf -*-
-
-# Renamed doxygen.m4 from acinclude.m4 for inclusion in CVC4
-
-# Copyright (C) 2004 Oren Ben-Kiki
-# This file is distributed under the same terms as the Autoconf macro files.
-
-########## CHANGELOG ##################
-# 2009-01-14 Martin Mann
-# * DX_ARG_ABLE : new variable 'DX_FLAG_DX_CURRENT_FEATURE'
-# * DX_CLEAR_DEPEND : use of explicit variable 'DX_FLAG_DX_CURRENT_FEATURE'
-# in AC_SUBST instead of 'DX_FLAG[]DX_CURRENT_FEATURE' which is rejected by
-# newer autotools
-
-# Generate automatic documentation using Doxygen. Works in concert with the
-# aminclude.m4 file and a compatible doxygen configuration file. Defines the
-# following public macros:
-#
-# DX_???_FEATURE(ON|OFF) - control the default setting fo a Doxygen feature.
-# Supported features are 'DOXYGEN' itself, 'DOT' for generating graphics,
-# 'HTML' for plain HTML, 'CHM' for compressed HTML help (for MS users), 'CHI'
-# for generating a seperate .chi file by the .chm file, and 'MAN', 'RTF',
-# 'XML', 'PDF' and 'PS' for the appropriate output formats. The environment
-# variable DOXYGEN_PAPER_SIZE may be specified to override the default 'a4wide'
-# paper size.
-#
-# By default, HTML, PDF and PS documentation is generated as this seems to be
-# the most popular and portable combination. MAN pages created by Doxygen are
-# usually problematic, though by picking an appropriate subset and doing some
-# massaging they might be better than nothing. CHM and RTF are specific for MS
-# (note that you can't generate both HTML and CHM at the same time). The XML is
-# rather useless unless you apply specialized post-processing to it.
-#
-# The macro mainly controls the default state of the feature. The use can
-# override the default by specifying --enable or --disable. The macros ensure
-# that contradictory flags are not given (e.g., --enable-doxygen-html and
-# --enable-doxygen-chm, --enable-doxygen-anything with --disable-doxygen, etc.)
-# Finally, each feature will be automatically disabled (with a warning) if the
-# required programs are missing.
-#
-# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN with
-# the following parameters: a one-word name for the project for use as a
-# filename base etc., an optional configuration file name (the default is
-# 'Doxyfile', the same as Doxygen's default), and an optional output directory
-# name (the default is 'doxygen-doc').
-
-## ----------##
-## Defaults. ##
-## ----------##
-
-DX_ENV=""
-AC_DEFUN([DX_FEATURE_doc], ON)
-AC_DEFUN([DX_FEATURE_dot], ON)
-AC_DEFUN([DX_FEATURE_man], OFF)
-AC_DEFUN([DX_FEATURE_html], ON)
-AC_DEFUN([DX_FEATURE_chm], OFF)
-AC_DEFUN([DX_FEATURE_chi], OFF)
-AC_DEFUN([DX_FEATURE_rtf], OFF)
-AC_DEFUN([DX_FEATURE_xml], OFF)
-AC_DEFUN([DX_FEATURE_pdf], ON)
-AC_DEFUN([DX_FEATURE_ps], ON)
-
-## --------------- ##
-## Private macros. ##
-## --------------- ##
-
-# DX_ENV_APPEND(VARIABLE, VALUE)
-# ------------------------------
-# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen.
-AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])])
-
-# DX_DIRNAME_EXPR
-# ---------------
-# Expand into a shell expression prints the directory part of a path.
-AC_DEFUN([DX_DIRNAME_EXPR],
- [[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']])
-
-# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF)
-# -------------------------------------
-# Expands according to the M4 (static) status of the feature.
-AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])])
-
-# DX_REQUIRE_PROG(VARIABLE, PROGRAM)
-# ----------------------------------
-# Require the specified program to be found for the DX_CURRENT_FEATURE to work.
-AC_DEFUN([DX_REQUIRE_PROG], [
-AC_PATH_TOOL([$1], [$2])
-if test "$DX_FLAG_DX_CURRENT_FEATURE$$1" = 1; then
- AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
- AC_SUBST([DX_FLAG_DX_CURRENT_FEATURE], 0)
-fi
-])
-
-# DX_TEST_FEATURE(FEATURE)
-# ------------------------
-# Expand to a shell expression testing whether the feature is active.
-AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1])
-
-# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE)
-# -------------------------------------------------
-# Verify that a required features has the right state before trying to turn on
-# the DX_CURRENT_FEATURE.
-AC_DEFUN([DX_CHECK_DEPEND], [
-test "$DX_FLAG_$1" = "$2" \
-|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1,
- requires, contradicts) doxygen-DX_CURRENT_FEATURE])
-])
-
-# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE)
-# ----------------------------------------------------------
-# Turn off the DX_CURRENT_FEATURE if the required feature is off.
-AC_DEFUN([DX_CLEAR_DEPEND], [
-test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_DX_CURRENT_FEATURE], 0)
-])
-
-
-# DX_FEATURE_ARG(FEATURE, DESCRIPTION,
-# CHECK_DEPEND, CLEAR_DEPEND,
-# REQUIRE, DO-IF-ON, DO-IF-OFF)
-# --------------------------------------------
-# Parse the command-line option controlling a feature. CHECK_DEPEND is called
-# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND),
-# otherwise CLEAR_DEPEND is called to turn off the default state if a required
-# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional
-# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and
-# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature.
-AC_DEFUN([DX_ARG_ABLE], [
- AC_DEFUN([DX_CURRENT_FEATURE], [$1])
- AC_DEFUN([DX_FLAG_DX_CURRENT_FEATURE], [DX_FLAG_$1])
- AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2])
- AC_ARG_ENABLE(doxygen-$1,
- [AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1],
- [--enable-doxygen-$1]),
- DX_IF_FEATURE([$1], [don't $2], [$2]))],
- [
-case "$enableval" in
-#(
-y|Y|yes|Yes|YES)
- AC_SUBST([DX_FLAG_$1], 1)
- $3
-;; #(
-n|N|no|No|NO)
- AC_SUBST([DX_FLAG_$1], 0)
-;; #(
-*)
- AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1])
-;;
-esac
-], [
-AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)])
-$4
-])
-if DX_TEST_FEATURE([$1]); then
- $5
- :
-fi
-if DX_TEST_FEATURE([$1]); then
- AM_CONDITIONAL(DX_COND_$1, :)
- $6
- :
-else
- AM_CONDITIONAL(DX_COND_$1, false)
- $7
- :
-fi
-])
-
-## -------------- ##
-## Public macros. ##
-## -------------- ##
-
-# DX_XXX_FEATURE(DEFAULT_STATE)
-# -----------------------------
-AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc], [$1])])
-AC_DEFUN([DX_MAN_FEATURE], [AC_DEFUN([DX_FEATURE_man], [$1])])
-AC_DEFUN([DX_HTML_FEATURE], [AC_DEFUN([DX_FEATURE_html], [$1])])
-AC_DEFUN([DX_CHM_FEATURE], [AC_DEFUN([DX_FEATURE_chm], [$1])])
-AC_DEFUN([DX_CHI_FEATURE], [AC_DEFUN([DX_FEATURE_chi], [$1])])
-AC_DEFUN([DX_RTF_FEATURE], [AC_DEFUN([DX_FEATURE_rtf], [$1])])
-AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
-AC_DEFUN([DX_DOT_FEATURE], [AC_DEFUN([DX_FEATURE_dot], [$1])])
-AC_DEFUN([DX_PDF_FEATURE], [AC_DEFUN([DX_FEATURE_pdf], [$1])])
-AC_DEFUN([DX_PS_FEATURE], [AC_DEFUN([DX_FEATURE_ps], [$1])])
-
-# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR])
-# ---------------------------------------------------------
-# PROJECT also serves as the base name for the documentation files.
-# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc".
-AC_DEFUN([DX_INIT_DOXYGEN], [
-
-# Files:
-AC_SUBST([DX_PROJECT], [$1])
-AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])])
-AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])])
-
-# Environment variables used inside doxygen.cfg:
-DX_ENV_APPEND(SRCDIR, $srcdir)
-DX_ENV_APPEND(PROJECT, $DX_PROJECT)
-DX_ENV_APPEND(DOCDIR, $DX_DOCDIR)
-DX_ENV_APPEND(VERSION, $PACKAGE_VERSION)
-
-# Doxygen itself:
-DX_ARG_ABLE(doc, [generate any doxygen documentation],
- [],
- [],
- [DX_REQUIRE_PROG([DX_DOXYGEN], doxygen)
- DX_REQUIRE_PROG([DX_PERL], perl)],
- [DX_ENV_APPEND(PERL_PATH, $DX_PERL)])
-
-# Dot for graphics:
-DX_ARG_ABLE(dot, [generate graphics for doxygen documentation],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [DX_REQUIRE_PROG([DX_DOT], dot)],
- [DX_ENV_APPEND(HAVE_DOT, YES)
- DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])],
- [DX_ENV_APPEND(HAVE_DOT, NO)])
-
-# Man pages generation:
-DX_ARG_ABLE(man, [generate doxygen manual pages],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [],
- [DX_ENV_APPEND(GENERATE_MAN, YES)],
- [DX_ENV_APPEND(GENERATE_MAN, NO)])
-
-# RTF file generation:
-DX_ARG_ABLE(rtf, [generate doxygen RTF documentation],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [],
- [DX_ENV_APPEND(GENERATE_RTF, YES)],
- [DX_ENV_APPEND(GENERATE_RTF, NO)])
-
-# XML file generation:
-DX_ARG_ABLE(xml, [generate doxygen XML documentation],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [],
- [DX_ENV_APPEND(GENERATE_XML, YES)],
- [DX_ENV_APPEND(GENERATE_XML, NO)])
-
-# (Compressed) HTML help generation:
-DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [DX_REQUIRE_PROG([DX_HHC], hhc)],
- [DX_ENV_APPEND(HHC_PATH, $DX_HHC)
- DX_ENV_APPEND(GENERATE_HTML, YES)
- DX_ENV_APPEND(GENERATE_HTMLHELP, YES)],
- [DX_ENV_APPEND(GENERATE_HTMLHELP, NO)])
-
-# Seperate CHI file generation.
-DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file],
- [DX_CHECK_DEPEND(chm, 1)],
- [DX_CLEAR_DEPEND(chm, 1)],
- [],
- [DX_ENV_APPEND(GENERATE_CHI, YES)],
- [DX_ENV_APPEND(GENERATE_CHI, NO)])
-
-# Plain HTML pages generation:
-DX_ARG_ABLE(html, [generate doxygen plain HTML documentation],
- [DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)],
- [DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)],
- [],
- [DX_ENV_APPEND(GENERATE_HTML, YES)],
- [DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)])
-
-# PostScript file generation:
-DX_ARG_ABLE(ps, [generate doxygen PostScript documentation],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [DX_REQUIRE_PROG([DX_LATEX], latex)
- DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
- DX_REQUIRE_PROG([DX_DVIPS], dvips)
- DX_REQUIRE_PROG([DX_EGREP], egrep)])
-
-# PDF file generation:
-DX_ARG_ABLE(pdf, [generate doxygen PDF documentation],
- [DX_CHECK_DEPEND(doc, 1)],
- [DX_CLEAR_DEPEND(doc, 1)],
- [DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex)
- DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
- DX_REQUIRE_PROG([DX_EGREP], egrep)])
-
-# LaTeX generation for PS and/or PDF:
-if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then
- AM_CONDITIONAL(DX_COND_latex, :)
- DX_ENV_APPEND(GENERATE_LATEX, YES)
-else
- AM_CONDITIONAL(DX_COND_latex, false)
- DX_ENV_APPEND(GENERATE_LATEX, NO)
-fi
-
-# Paper size for PS and/or PDF:
-AC_ARG_VAR(DOXYGEN_PAPER_SIZE,
- [a4wide (default), a4, letter, legal or executive])
-case "$DOXYGEN_PAPER_SIZE" in
-#(
-"")
- AC_SUBST(DOXYGEN_PAPER_SIZE, "")
-;; #(
-a4wide|a4|letter|legal|executive)
- DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE)
-;; #(
-*)
- AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE'])
-;;
-esac
-
-#For debugging:
-#echo DX_FLAG_doc=$DX_FLAG_doc
-#echo DX_FLAG_dot=$DX_FLAG_dot
-#echo DX_FLAG_man=$DX_FLAG_man
-#echo DX_FLAG_html=$DX_FLAG_html
-#echo DX_FLAG_chm=$DX_FLAG_chm
-#echo DX_FLAG_chi=$DX_FLAG_chi
-#echo DX_FLAG_rtf=$DX_FLAG_rtf
-#echo DX_FLAG_xml=$DX_FLAG_xml
-#echo DX_FLAG_pdf=$DX_FLAG_pdf
-#echo DX_FLAG_ps=$DX_FLAG_ps
-#echo DX_ENV=$DX_ENV
-])
+# This file is part of Autoconf. -*- Autoconf -*- + +# Renamed doxygen.m4 from acinclude.m4 for inclusion in CVC4 + +# Copyright (C) 2004 Oren Ben-Kiki +# This file is distributed under the same terms as the Autoconf macro files. + +########## CHANGELOG ################## +# 2009-01-14 Martin Mann +# * DX_ARG_ABLE : new variable 'DX_FLAG_DX_CURRENT_FEATURE' +# * DX_CLEAR_DEPEND : use of explicit variable 'DX_FLAG_DX_CURRENT_FEATURE' +# in AC_SUBST instead of 'DX_FLAG[]DX_CURRENT_FEATURE' which is rejected by +# newer autotools + +# Generate automatic documentation using Doxygen. Works in concert with the +# aminclude.m4 file and a compatible doxygen configuration file. Defines the +# following public macros: +# +# DX_???_FEATURE(ON|OFF) - control the default setting fo a Doxygen feature. +# Supported features are 'DOXYGEN' itself, 'DOT' for generating graphics, +# 'HTML' for plain HTML, 'CHM' for compressed HTML help (for MS users), 'CHI' +# for generating a seperate .chi file by the .chm file, and 'MAN', 'RTF', +# 'XML', 'PDF' and 'PS' for the appropriate output formats. The environment +# variable DOXYGEN_PAPER_SIZE may be specified to override the default 'a4wide' +# paper size. +# +# By default, HTML, PDF and PS documentation is generated as this seems to be +# the most popular and portable combination. MAN pages created by Doxygen are +# usually problematic, though by picking an appropriate subset and doing some +# massaging they might be better than nothing. CHM and RTF are specific for MS +# (note that you can't generate both HTML and CHM at the same time). The XML is +# rather useless unless you apply specialized post-processing to it. +# +# The macro mainly controls the default state of the feature. The use can +# override the default by specifying --enable or --disable. The macros ensure +# that contradictory flags are not given (e.g., --enable-doxygen-html and +# --enable-doxygen-chm, --enable-doxygen-anything with --disable-doxygen, etc.) +# Finally, each feature will be automatically disabled (with a warning) if the +# required programs are missing. +# +# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN with +# the following parameters: a one-word name for the project for use as a +# filename base etc., an optional configuration file name (the default is +# 'Doxyfile', the same as Doxygen's default), and an optional output directory +# name (the default is 'doxygen-doc'). + +## ----------## +## Defaults. ## +## ----------## + +DX_ENV="" +AC_DEFUN([DX_FEATURE_doc], ON) +AC_DEFUN([DX_FEATURE_dot], ON) +AC_DEFUN([DX_FEATURE_man], OFF) +AC_DEFUN([DX_FEATURE_html], ON) +AC_DEFUN([DX_FEATURE_chm], OFF) +AC_DEFUN([DX_FEATURE_chi], OFF) +AC_DEFUN([DX_FEATURE_rtf], OFF) +AC_DEFUN([DX_FEATURE_xml], OFF) +AC_DEFUN([DX_FEATURE_pdf], ON) +AC_DEFUN([DX_FEATURE_ps], ON) + +## --------------- ## +## Private macros. ## +## --------------- ## + +# DX_ENV_APPEND(VARIABLE, VALUE) +# ------------------------------ +# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen. +AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])]) + +# DX_DIRNAME_EXPR +# --------------- +# Expand into a shell expression prints the directory part of a path. +AC_DEFUN([DX_DIRNAME_EXPR], + [[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']]) + +# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF) +# ------------------------------------- +# Expands according to the M4 (static) status of the feature. +AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])]) + +# DX_REQUIRE_PROG(VARIABLE, PROGRAM) +# ---------------------------------- +# Require the specified program to be found for the DX_CURRENT_FEATURE to work. +AC_DEFUN([DX_REQUIRE_PROG], [ +AC_PATH_TOOL([$1], [$2]) +if test "$DX_FLAG_DX_CURRENT_FEATURE$$1" = 1; then + AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION]) + AC_SUBST([DX_FLAG_DX_CURRENT_FEATURE], 0) +fi +]) + +# DX_TEST_FEATURE(FEATURE) +# ------------------------ +# Expand to a shell expression testing whether the feature is active. +AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1]) + +# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE) +# ------------------------------------------------- +# Verify that a required features has the right state before trying to turn on +# the DX_CURRENT_FEATURE. +AC_DEFUN([DX_CHECK_DEPEND], [ +test "$DX_FLAG_$1" = "$2" \ +|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1, + requires, contradicts) doxygen-DX_CURRENT_FEATURE]) +]) + +# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE) +# ---------------------------------------------------------- +# Turn off the DX_CURRENT_FEATURE if the required feature is off. +AC_DEFUN([DX_CLEAR_DEPEND], [ +test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_DX_CURRENT_FEATURE], 0) +]) + + +# DX_FEATURE_ARG(FEATURE, DESCRIPTION, +# CHECK_DEPEND, CLEAR_DEPEND, +# REQUIRE, DO-IF-ON, DO-IF-OFF) +# -------------------------------------------- +# Parse the command-line option controlling a feature. CHECK_DEPEND is called +# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND), +# otherwise CLEAR_DEPEND is called to turn off the default state if a required +# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional +# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and +# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature. +AC_DEFUN([DX_ARG_ABLE], [ + AC_DEFUN([DX_CURRENT_FEATURE], [$1]) + AC_DEFUN([DX_FLAG_DX_CURRENT_FEATURE], [DX_FLAG_$1]) + AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2]) + AC_ARG_ENABLE(doxygen-$1, + [AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1], + [--enable-doxygen-$1]), + DX_IF_FEATURE([$1], [don't $2], [$2]))], + [ +case "$enableval" in +#( +y|Y|yes|Yes|YES) + AC_SUBST([DX_FLAG_$1], 1) + $3 +;; #( +n|N|no|No|NO) + AC_SUBST([DX_FLAG_$1], 0) +;; #( +*) + AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1]) +;; +esac +], [ +AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)]) +$4 +]) +if DX_TEST_FEATURE([$1]); then + $5 + : +fi +if DX_TEST_FEATURE([$1]); then + AM_CONDITIONAL(DX_COND_$1, :) + $6 + : +else + AM_CONDITIONAL(DX_COND_$1, false) + $7 + : +fi +]) + +## -------------- ## +## Public macros. ## +## -------------- ## + +# DX_XXX_FEATURE(DEFAULT_STATE) +# ----------------------------- +AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc], [$1])]) +AC_DEFUN([DX_MAN_FEATURE], [AC_DEFUN([DX_FEATURE_man], [$1])]) +AC_DEFUN([DX_HTML_FEATURE], [AC_DEFUN([DX_FEATURE_html], [$1])]) +AC_DEFUN([DX_CHM_FEATURE], [AC_DEFUN([DX_FEATURE_chm], [$1])]) +AC_DEFUN([DX_CHI_FEATURE], [AC_DEFUN([DX_FEATURE_chi], [$1])]) +AC_DEFUN([DX_RTF_FEATURE], [AC_DEFUN([DX_FEATURE_rtf], [$1])]) +AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])]) +AC_DEFUN([DX_DOT_FEATURE], [AC_DEFUN([DX_FEATURE_dot], [$1])]) +AC_DEFUN([DX_PDF_FEATURE], [AC_DEFUN([DX_FEATURE_pdf], [$1])]) +AC_DEFUN([DX_PS_FEATURE], [AC_DEFUN([DX_FEATURE_ps], [$1])]) + +# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR]) +# --------------------------------------------------------- +# PROJECT also serves as the base name for the documentation files. +# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc". +AC_DEFUN([DX_INIT_DOXYGEN], [ + +# Files: +AC_SUBST([DX_PROJECT], [$1]) +AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])]) +AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])]) + +# Environment variables used inside doxygen.cfg: +DX_ENV_APPEND(SRCDIR, $srcdir) +DX_ENV_APPEND(PROJECT, $DX_PROJECT) +DX_ENV_APPEND(DOCDIR, $DX_DOCDIR) +DX_ENV_APPEND(VERSION, $PACKAGE_VERSION) + +# Doxygen itself: +DX_ARG_ABLE(doc, [generate any doxygen documentation], + [], + [], + [DX_REQUIRE_PROG([DX_DOXYGEN], doxygen) + DX_REQUIRE_PROG([DX_PERL], perl)], + [DX_ENV_APPEND(PERL_PATH, $DX_PERL)]) + +# Dot for graphics: +DX_ARG_ABLE(dot, [generate graphics for doxygen documentation], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [DX_REQUIRE_PROG([DX_DOT], dot)], + [DX_ENV_APPEND(HAVE_DOT, YES) + DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])], + [DX_ENV_APPEND(HAVE_DOT, NO)]) + +# Man pages generation: +DX_ARG_ABLE(man, [generate doxygen manual pages], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [], + [DX_ENV_APPEND(GENERATE_MAN, YES)], + [DX_ENV_APPEND(GENERATE_MAN, NO)]) + +# RTF file generation: +DX_ARG_ABLE(rtf, [generate doxygen RTF documentation], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [], + [DX_ENV_APPEND(GENERATE_RTF, YES)], + [DX_ENV_APPEND(GENERATE_RTF, NO)]) + +# XML file generation: +DX_ARG_ABLE(xml, [generate doxygen XML documentation], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [], + [DX_ENV_APPEND(GENERATE_XML, YES)], + [DX_ENV_APPEND(GENERATE_XML, NO)]) + +# (Compressed) HTML help generation: +DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [DX_REQUIRE_PROG([DX_HHC], hhc)], + [DX_ENV_APPEND(HHC_PATH, $DX_HHC) + DX_ENV_APPEND(GENERATE_HTML, YES) + DX_ENV_APPEND(GENERATE_HTMLHELP, YES)], + [DX_ENV_APPEND(GENERATE_HTMLHELP, NO)]) + +# Seperate CHI file generation. +DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file], + [DX_CHECK_DEPEND(chm, 1)], + [DX_CLEAR_DEPEND(chm, 1)], + [], + [DX_ENV_APPEND(GENERATE_CHI, YES)], + [DX_ENV_APPEND(GENERATE_CHI, NO)]) + +# Plain HTML pages generation: +DX_ARG_ABLE(html, [generate doxygen plain HTML documentation], + [DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)], + [DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)], + [], + [DX_ENV_APPEND(GENERATE_HTML, YES)], + [DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)]) + +# PostScript file generation: +DX_ARG_ABLE(ps, [generate doxygen PostScript documentation], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [DX_REQUIRE_PROG([DX_LATEX], latex) + DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex) + DX_REQUIRE_PROG([DX_DVIPS], dvips) + DX_REQUIRE_PROG([DX_EGREP], egrep)]) + +# PDF file generation: +DX_ARG_ABLE(pdf, [generate doxygen PDF documentation], + [DX_CHECK_DEPEND(doc, 1)], + [DX_CLEAR_DEPEND(doc, 1)], + [DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex) + DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex) + DX_REQUIRE_PROG([DX_EGREP], egrep)]) + +# LaTeX generation for PS and/or PDF: +if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then + AM_CONDITIONAL(DX_COND_latex, :) + DX_ENV_APPEND(GENERATE_LATEX, YES) +else + AM_CONDITIONAL(DX_COND_latex, false) + DX_ENV_APPEND(GENERATE_LATEX, NO) +fi + +# Paper size for PS and/or PDF: +AC_ARG_VAR(DOXYGEN_PAPER_SIZE, + [a4wide (default), a4, letter, legal or executive]) +case "$DOXYGEN_PAPER_SIZE" in +#( +"") + AC_SUBST(DOXYGEN_PAPER_SIZE, "") +;; #( +a4wide|a4|letter|legal|executive) + DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE) +;; #( +*) + AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE']) +;; +esac + +#For debugging: +#echo DX_FLAG_doc=$DX_FLAG_doc +#echo DX_FLAG_dot=$DX_FLAG_dot +#echo DX_FLAG_man=$DX_FLAG_man +#echo DX_FLAG_html=$DX_FLAG_html +#echo DX_FLAG_chm=$DX_FLAG_chm +#echo DX_FLAG_chi=$DX_FLAG_chi +#echo DX_FLAG_rtf=$DX_FLAG_rtf +#echo DX_FLAG_xml=$DX_FLAG_xml +#echo DX_FLAG_pdf=$DX_FLAG_pdf +#echo DX_FLAG_ps=$DX_FLAG_ps +#echo DX_ENV=$DX_ENV +]) diff --git a/examples/api/java/Strings.java b/examples/api/java/Strings.java index 9437115a9..bb9dcd822 100644 --- a/examples/api/java/Strings.java +++ b/examples/api/java/Strings.java @@ -1,91 +1,91 @@ -/********************* */
-/*! \file Strings.java
- ** \verbatim
- ** Original author: Tianyi Liang
- ** Major contributors: none
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief Reasoning about strings with CVC4 via Java API.
- **
- ** A simple demonstration of reasoning about strings with CVC4 via Jave API.
- **/
-
-import edu.nyu.acsys.CVC4.*;
-
-public class Strings {
- public static void main(String[] args) {
- System.loadLibrary("cvc4jni");
-
- ExprManager em = new ExprManager();
- SmtEngine smt = new SmtEngine(em);
-
- // Set the logic
- smt.setLogic("S");
-
- // Produce models
- smt.setOption("produce-models", new SExpr(true));
- // The option strings-exp is needed
- smt.setOption("strings-exp", new SExpr(true));
- // output-language
- smt.setOption("output-language", new SExpr("smt2"));
-
- // String type
- Type string = em.stringType();
-
- // String constants
- Expr ab = em.mkConst(new CVC4String("ab"));
- Expr abc = em.mkConst(new CVC4String("abc"));
- // Variables
- Expr x = em.mkVar("x", string);
- Expr y = em.mkVar("y", string);
- Expr z = em.mkVar("z", string);
-
- // String concatenation: x.ab.y
- Expr lhs = em.mkExpr(Kind.STRING_CONCAT, x, ab, y);
- // String concatenation: abc.z
- Expr rhs = em.mkExpr(Kind.STRING_CONCAT, abc, z);;
- // x.ab.y = abc.z
- Expr formula1 = em.mkExpr(Kind.EQUAL, lhs, rhs);
-
- // Length of y: |y|
- Expr leny = em.mkExpr(Kind.STRING_LENGTH, y);
- // |y| >= 0
- Expr formula2 = em.mkExpr(Kind.GEQ, leny, em.mkConst(new Rational(0)));
-
- // Regular expression: (ab[c-e]*f)|g|h
- Expr r = em.mkExpr(Kind.REGEXP_UNION,
- em.mkExpr(Kind.REGEXP_CONCAT,
- em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("ab"))),
- em.mkExpr(Kind.REGEXP_STAR,
- em.mkExpr(Kind.REGEXP_RANGE, em.mkConst(new CVC4String("c")), em.mkConst(new CVC4String("e")))),
- em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("f")))),
- em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("g"))),
- em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("h"))));
-
- // String variables
- Expr s1 = em.mkVar("s1", string);
- Expr s2 = em.mkVar("s2", string);
- // String concatenation: s1.s2
- Expr s = em.mkExpr(Kind.STRING_CONCAT, s1, s2);
-
- // s1.s2 in (ab[c-e]*f)|g|h
- Expr formula3 = em.mkExpr(Kind.STRING_IN_REGEXP, s, r);
-
- // Make a query
- Expr q = em.mkExpr(Kind.AND,
- formula1,
- formula2,
- formula3);
-
- // check sat
- Result result = smt.checkSat(q);
- System.out.println("CVC4 reports: " + q + " is " + result + ".");
-
- System.out.println(" x = " + smt.getValue(x));
- System.out.println(" s1.s2 = " + smt.getValue(s));
- }
-}
+/********************* */ +/*! \file Strings.java + ** \verbatim + ** Original author: Tianyi Liang + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief Reasoning about strings with CVC4 via Java API. + ** + ** A simple demonstration of reasoning about strings with CVC4 via Jave API. + **/ + +import edu.nyu.acsys.CVC4.*; + +public class Strings { + public static void main(String[] args) { + System.loadLibrary("cvc4jni"); + + ExprManager em = new ExprManager(); + SmtEngine smt = new SmtEngine(em); + + // Set the logic + smt.setLogic("S"); + + // Produce models + smt.setOption("produce-models", new SExpr(true)); + // The option strings-exp is needed + smt.setOption("strings-exp", new SExpr(true)); + // output-language + smt.setOption("output-language", new SExpr("smt2")); + + // String type + Type string = em.stringType(); + + // String constants + Expr ab = em.mkConst(new CVC4String("ab")); + Expr abc = em.mkConst(new CVC4String("abc")); + // Variables + Expr x = em.mkVar("x", string); + Expr y = em.mkVar("y", string); + Expr z = em.mkVar("z", string); + + // String concatenation: x.ab.y + Expr lhs = em.mkExpr(Kind.STRING_CONCAT, x, ab, y); + // String concatenation: abc.z + Expr rhs = em.mkExpr(Kind.STRING_CONCAT, abc, z);; + // x.ab.y = abc.z + Expr formula1 = em.mkExpr(Kind.EQUAL, lhs, rhs); + + // Length of y: |y| + Expr leny = em.mkExpr(Kind.STRING_LENGTH, y); + // |y| >= 0 + Expr formula2 = em.mkExpr(Kind.GEQ, leny, em.mkConst(new Rational(0))); + + // Regular expression: (ab[c-e]*f)|g|h + Expr r = em.mkExpr(Kind.REGEXP_UNION, + em.mkExpr(Kind.REGEXP_CONCAT, + em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("ab"))), + em.mkExpr(Kind.REGEXP_STAR, + em.mkExpr(Kind.REGEXP_RANGE, em.mkConst(new CVC4String("c")), em.mkConst(new CVC4String("e")))), + em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("f")))), + em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("g"))), + em.mkExpr(Kind.STRING_TO_REGEXP, em.mkConst(new CVC4String("h")))); + + // String variables + Expr s1 = em.mkVar("s1", string); + Expr s2 = em.mkVar("s2", string); + // String concatenation: s1.s2 + Expr s = em.mkExpr(Kind.STRING_CONCAT, s1, s2); + + // s1.s2 in (ab[c-e]*f)|g|h + Expr formula3 = em.mkExpr(Kind.STRING_IN_REGEXP, s, r); + + // Make a query + Expr q = em.mkExpr(Kind.AND, + formula1, + formula2, + formula3); + + // check sat + Result result = smt.checkSat(q); + System.out.println("CVC4 reports: " + q + " is " + result + "."); + + System.out.println(" x = " + smt.getValue(x)); + System.out.println(" s1.s2 = " + smt.getValue(s)); + } +} diff --git a/examples/api/strings.cpp b/examples/api/strings.cpp index a424c654a..14ab0e64d 100644 --- a/examples/api/strings.cpp +++ b/examples/api/strings.cpp @@ -1,101 +1,101 @@ -/********************* */
-/*! \file sets.cpp
- ** \verbatim
- ** Original author: Tianyi Liang
- ** Major contributors: none
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief Reasoning about strings with CVC4 via C++ API.
- **
- ** A simple demonstration of reasoning about strings with CVC4 via C++ API.
- **/
-
-#include <iostream>
-
-//#include <cvc4/cvc4.h> // use this after CVC4 is properly installed
-#include "smt/smt_engine.h"
-
-using namespace CVC4;
-
-int main() {
- ExprManager em;
- SmtEngine smt(&em);
-
- // Set the logic
- smt.setLogic("S");
-
- // Produce models
- smt.setOption("produce-models", true);
-
- // The option strings-exp is needed
- smt.setOption("strings-exp", true);
-
- // Set output language to SMTLIB2
- std::cout << Expr::setlanguage(language::output::LANG_SMTLIB_V2);
-
- // String type
- Type string = em.stringType();
-
- // std::string
- std::string std_str_ab("ab");
- // CVC4::String
- CVC4::String cvc4_str_ab(std_str_ab);
- CVC4::String cvc4_str_abc("abc");
- // String constants
- Expr ab = em.mkConst(cvc4_str_ab);
- Expr abc = em.mkConst(CVC4::String("abc"));
- // String variables
- Expr x = em.mkVar("x", string);
- Expr y = em.mkVar("y", string);
- Expr z = em.mkVar("z", string);
-
- // String concatenation: x.ab.y
- Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);
- // String concatenation: abc.z
- Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);
- // x.ab.y = abc.z
- Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);
-
- // Length of y: |y|
- Expr leny = em.mkExpr(kind::STRING_LENGTH, y);
- // |y| >= 0
- Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));
-
- // Regular expression: (ab[c-e]*f)|g|h
- Expr r = em.mkExpr(kind::REGEXP_UNION,
- em.mkExpr(kind::REGEXP_CONCAT,
- em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),
- em.mkExpr(kind::REGEXP_STAR,
- em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),
- em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),
- em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),
- em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));
-
- // String variables
- Expr s1 = em.mkVar("s1", string);
- Expr s2 = em.mkVar("s2", string);
- // String concatenation: s1.s2
- Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);
-
- // s1.s2 in (ab[c-e]*f)|g|h
- Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);
-
- // Make a query
- Expr q = em.mkExpr(kind::AND,
- formula1,
- formula2,
- formula3);
-
- // check sat
- Result result = smt.checkSat(q);
- std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;
-
- if(result == Result::SAT) {
- std::cout << " x = " << smt.getValue(x) << std::endl;
- std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;
- }
-}
+/********************* */ +/*! \file sets.cpp + ** \verbatim + ** Original author: Tianyi Liang + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief Reasoning about strings with CVC4 via C++ API. + ** + ** A simple demonstration of reasoning about strings with CVC4 via C++ API. + **/ + +#include <iostream> + +//#include <cvc4/cvc4.h> // use this after CVC4 is properly installed +#include "smt/smt_engine.h" + +using namespace CVC4; + +int main() { + ExprManager em; + SmtEngine smt(&em); + + // Set the logic + smt.setLogic("S"); + + // Produce models + smt.setOption("produce-models", true); + + // The option strings-exp is needed + smt.setOption("strings-exp", true); + + // Set output language to SMTLIB2 + std::cout << Expr::setlanguage(language::output::LANG_SMTLIB_V2); + + // String type + Type string = em.stringType(); + + // std::string + std::string std_str_ab("ab"); + // CVC4::String + CVC4::String cvc4_str_ab(std_str_ab); + CVC4::String cvc4_str_abc("abc"); + // String constants + Expr ab = em.mkConst(cvc4_str_ab); + Expr abc = em.mkConst(CVC4::String("abc")); + // String variables + Expr x = em.mkVar("x", string); + Expr y = em.mkVar("y", string); + Expr z = em.mkVar("z", string); + + // String concatenation: x.ab.y + Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y); + // String concatenation: abc.z + Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z); + // x.ab.y = abc.z + Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs); + + // Length of y: |y| + Expr leny = em.mkExpr(kind::STRING_LENGTH, y); + // |y| >= 0 + Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0))); + + // Regular expression: (ab[c-e]*f)|g|h + Expr r = em.mkExpr(kind::REGEXP_UNION, + em.mkExpr(kind::REGEXP_CONCAT, + em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))), + em.mkExpr(kind::REGEXP_STAR, + em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))), + em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))), + em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))), + em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h")))); + + // String variables + Expr s1 = em.mkVar("s1", string); + Expr s2 = em.mkVar("s2", string); + // String concatenation: s1.s2 + Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2); + + // s1.s2 in (ab[c-e]*f)|g|h + Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r); + + // Make a query + Expr q = em.mkExpr(kind::AND, + formula1, + formula2, + formula3); + + // check sat + Result result = smt.checkSat(q); + std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl; + + if(result == Result::SAT) { + std::cout << " x = " << smt.getValue(x) << std::endl; + std::cout << " s1.s2 = " << smt.getValue(s) << std::endl; + } +} diff --git a/proofs/lfsc_checker/libwriter.cpp b/proofs/lfsc_checker/libwriter.cpp index 49e9bbaad..016016c9d 100644 --- a/proofs/lfsc_checker/libwriter.cpp +++ b/proofs/lfsc_checker/libwriter.cpp @@ -1,238 +1,238 @@ -#include "libwriter.h"
-#include <sstream>
-#include <algorithm>
-#include <fstream>
-
-void libwriter::get_var_name( const std::string& n, std::string& nn ) {
- nn = std::string( n.c_str() );
- for( int i = 0; i <(int)n.length(); i++ ){
- char c = n[i];
- if (c <= 47)
- c += 65;
- else if (c >= 58 && c <= 64)
- c += 97-58;
- if ((c >= 91 && c <= 94) || c == 96)
- c += 104-91;
- else if (c >= 123)
- c -= 4;
- nn[i] = c;
- }
-}
-
-void libwriter::write_file()
-{
- //std::cout << "write lib" << std::endl;
- std::ostringstream os_enum;
- std::ostringstream os_print;
- std::ostringstream os_constructor_h;
- std::ostringstream os_constructor_c;
-
- for ( int a=0; a<(int)syms.size(); a++ ) {
- //std::cout << "sym #" << (a+1) << ": ";
- //std::cout << ((SymSExpr*)syms[a])->s.c_str() << std::endl;
- //defs[a]->print( std::cout );
- //std::cout << std::endl;
-
- if( defs[a]->getclass()==CEXPR ){
- //calculate which arguments are required for input
- std::vector< Expr* > args;
- std::vector< bool > argsNeed;
- std::vector< Expr* > argTypes;
- CExpr* c = ((CExpr*)defs[a]);
- while( c->getop()==PI ){
- //std::cout << c->kids[0] << std::endl;
- if( ((CExpr*)c->kids[1])->getop()!=RUN ){
- args.push_back( c->kids[0] );
- argsNeed.push_back( true );
- argTypes.push_back( c->kids[1] );
- }
- for( int b=0; b<(int)args.size(); b++ ){
- if( argsNeed[b] ){
- if( ((CExpr*)c->kids[1])->getop()==RUN ){
- if( ((CExpr*)c->kids[1])->kids[1]->free_in( args[b] ) ){
- argsNeed[b] = false;
- }
- }else{
- if( c->kids[1]->free_in( args[b] ) ){
- argsNeed[b] = false;
- }
- }
- }
- }
- c = (CExpr*)(c->kids[2]);
- }
-
- //record if this declares a judgement
- if( ((CExpr*)defs[a])->getop()==PI && c->getop()==TYPE ){
- //std::cout << "This is a judgement" << std::endl;
- judgements.push_back( syms[a] );
- //record if this declares a proof rule
- }else if( c->getclass()==CEXPR && std::find( judgements.begin(), judgements.end(), c->kids[0] )!=judgements.end() ){
- std::cout << "Handle rule: " << ((SymSExpr*)syms[a])->s.c_str() << std::endl;
- //std::cout << "These are required to input:" << std::endl;
- //for( int b=0; b<(int)args.size(); b++ ){
- // if( argsNeed[b] ){
- // std::cout << ((SymSExpr*)args[b])->s.c_str() << std::endl;
- // }
- //}
- os_enum << " rule_" << ((SymSExpr*)syms[a])->s.c_str() << "," << std::endl;
-
- os_print << " case rule_" << ((SymSExpr*)syms[a])->s.c_str() << ": os << \"";
- os_print << ((SymSExpr*)syms[a])->s.c_str() << "\";break;" << std::endl;
-
- std::ostringstream os_args;
- os_args << "(";
- bool firstTime = true;
- for( int b=0; b<(int)args.size(); b++ ){
- if( argsNeed[b] ){
- if( !firstTime )
- os_args << ",";
- std::string str;
- get_var_name( ((SymSExpr*)args[b])->s, str );
- os_args << " LFSCProof* " << str.c_str();
- firstTime = false;
- }
- }
- if( !firstTime ){
- os_args << " ";
- }
- os_args << ")";
-
- os_constructor_h << " static LFSCProof* make_" << ((SymSExpr*)syms[a])->s.c_str();
- os_constructor_h << os_args.str().c_str() << ";" << std::endl;
-
- os_constructor_c << "LFSCProof* LFSCProof::make_" << ((SymSExpr*)syms[a])->s.c_str();
- os_constructor_c << os_args.str().c_str() << "{" << std::endl;
- os_constructor_c << " LFSCProof **kids = new LFSCProof *[" << (int)args.size()+1 << "];" << std::endl;
- for( int b=0; b<(int)args.size(); b++ ){
- os_constructor_c << " kids[" << b << "] = ";
- if( argsNeed[b] ){
- std::string str;
- get_var_name( ((SymSExpr*)args[b])->s, str );
- os_constructor_c << str.c_str();
- }else{
- os_constructor_c << "hole";
- }
- os_constructor_c << ";" << std::endl;
- }
- os_constructor_c << " kids[" << (int)args.size() << "] = 0;" << std::endl;
- os_constructor_c << " return new LFSCProofC( rule_" << ((SymSExpr*)syms[a])->s.c_str() << ", kids );" << std::endl;
- os_constructor_c << "}" << std::endl << std::endl;
- }
- }
-
- //write the header
- static std::string filename( "lfsc_proof" );
- std::fstream fsh;
- std::string fnameh( filename );
- fnameh.append(".h");
- fsh.open( fnameh.c_str(), std::ios::out );
-
- fsh << "#ifndef LFSC_PROOF_LIB_H" << std::endl;
- fsh << "#define LFSC_PROOF_LIB_H" << std::endl;
- fsh << std::endl;
- fsh << "#include <string>" << std::endl;
- fsh << std::endl;
- fsh << "class LFSCProof{" << std::endl;
- fsh << "protected:" << std::endl;
- fsh << " enum{" << std::endl;
- fsh << os_enum.str().c_str();
- fsh << " };" << std::endl;
- fsh << " static LFSCProof* hole;" << std::endl;
- fsh << " LFSCProof(){}" << std::endl;
- fsh << "public:" << std::endl;
- fsh << " virtual ~LFSCProof(){}" << std::endl;
- fsh << " static void init();" << std::endl;
- fsh << std::endl;
- fsh << " //functions to build LFSC proofs" << std::endl;
- fsh << os_constructor_h.str().c_str();
- fsh << std::endl;
- fsh << " virtual void set_child( int i, LFSCProof* e ) {}" << std::endl;
- fsh << " virtual void print( std::ostream& os ){}" << std::endl;
- fsh << "};" << std::endl;
- fsh << std::endl;
- fsh << "class LFSCProofC : public LFSCProof{" << std::endl;
- fsh << " short id;" << std::endl;
- fsh << " LFSCProof **kids;" << std::endl;
- fsh << "public:" << std::endl;
- fsh << " LFSCProofC( short d_id, LFSCProof **d_kids ) : id( d_id ), kids( d_kids ){}" << std::endl;
- fsh << " void set_child( int i, LFSCProof* e ) { kids[i] = e; }" << std::endl;
- fsh << " void print( std::ostream& os );" << std::endl;
- fsh << "};" << std::endl;
- fsh << std::endl;
- fsh << "class LFSCProofSym : public LFSCProof{" << std::endl;
- fsh << "private:" << std::endl;
- fsh << " std::string s;" << std::endl;
- fsh << " LFSCProofSym( std::string ss ) : s( ss ){}" << std::endl;
- fsh << "public:" << std::endl;
- fsh << " static LFSCProofSym* make( std::string ss ) { return new LFSCProofSym( ss ); }" << std::endl;
- fsh << " static LFSCProofSym* make( const char* ss ) { return new LFSCProofSym( std::string( ss ) ); }" << std::endl;
- fsh << " ~LFSCProofSym(){}" << std::endl;
- fsh << " void print( std::ostream& os ) { os << s.c_str(); }" << std::endl;
- fsh << "};" << std::endl;
- fsh << std::endl;
- fsh << "class LFSCProofLam : public LFSCProof{" << std::endl;
- fsh << " LFSCProofSym* var;" << std::endl;
- fsh << " LFSCProof* body;" << std::endl;
- fsh << " LFSCProof* typ;" << std::endl;
- fsh << " LFSCProofLam( LFSCProofSym* d_var, LFSCProof* d_body, LFSCProof* d_typ ) : var( d_var ), body( d_body ), typ( d_typ ){}" << std::endl;
- fsh << "public:" << std::endl;
- fsh << " static LFSCProof* make( LFSCProofSym* d_var, LFSCProof* d_body, LFSCProof* d_typ = NULL ) {" << std::endl;
- fsh << " return new LFSCProofLam( d_var, d_body, d_typ );" << std::endl;
- fsh << " }" << std::endl;
- fsh << " ~LFSCProofLam(){}" << std::endl;
- fsh << std::endl;
- fsh << " void print( std::ostream& os );" << std::endl;
- fsh << "};" << std::endl;
- fsh << std::endl;
- fsh << "#endif" << std::endl;
-
- //write the cpp
- std::fstream fsc;
- std::string fnamec( filename );
- fnamec.append(".cpp");
- fsc.open( fnamec.c_str(), std::ios::out );
-
- fsc << "#include \"lfsc_proof.h\"" << std::endl;
- fsc << std::endl;
- fsc << "LFSCProof* LFSCProof::hole = NULL;" << std::endl;
- fsc << std::endl;
- fsc << "void LFSCProof::init(){" << std::endl;
- fsc << " hole = LFSCProofSym::make( \"_\" );" << std::endl;
- fsc << "}" << std::endl;
- fsc << std::endl;
- fsc << "void LFSCProofC::print( std::ostream& os ){" << std::endl;
- fsc << " os << \"(\";" << std::endl;
- fsc << " switch( id ){" << std::endl;
- fsc << os_print.str().c_str();
- fsc << " }" << std::endl;
- fsc << " int counter = 0;" << std::endl;
- fsc << " while( kids[counter] ){" << std::endl;
- fsc << " os << \" \";" << std::endl;
- fsc << " kids[counter]->print( os );" << std::endl;
- fsc << " counter++;" << std::endl;
- fsc << " }" << std::endl;
- fsc << " os << \")\";" << std::endl;
- fsc << "}" << std::endl;
- fsc << std::endl;
- fsc << "void LFSCProofLam::print( std::ostream& os ){" << std::endl;
- fsc << " os << \"(\";" << std::endl;
- fsc << " if( typ ){" << std::endl;
- fsc << " os << \"% \";" << std::endl;
- fsc << " }else{" << std::endl;
- fsc << " os << \"\\\\ \";" << std::endl;
- fsc << " }" << std::endl;
- fsc << " var->print( os );" << std::endl;
- fsc << " if( typ ){" << std::endl;
- fsc << " os << \" \";" << std::endl;
- fsc << " typ->print( os );" << std::endl;
- fsc << " }" << std::endl;
- fsc << " os << std::endl;" << std::endl;
- fsc << " body->print( os );" << std::endl;
- fsc << " os << \")\";" << std::endl;
- fsc << "}" << std::endl;
- fsc << std::endl;
- fsc << os_constructor_c.str().c_str();
- fsc << std::endl;
- }
-}
+#include "libwriter.h" +#include <sstream> +#include <algorithm> +#include <fstream> + +void libwriter::get_var_name( const std::string& n, std::string& nn ) { + nn = std::string( n.c_str() ); + for( int i = 0; i <(int)n.length(); i++ ){ + char c = n[i]; + if (c <= 47) + c += 65; + else if (c >= 58 && c <= 64) + c += 97-58; + if ((c >= 91 && c <= 94) || c == 96) + c += 104-91; + else if (c >= 123) + c -= 4; + nn[i] = c; + } +} + +void libwriter::write_file() +{ + //std::cout << "write lib" << std::endl; + std::ostringstream os_enum; + std::ostringstream os_print; + std::ostringstream os_constructor_h; + std::ostringstream os_constructor_c; + + for ( int a=0; a<(int)syms.size(); a++ ) { + //std::cout << "sym #" << (a+1) << ": "; + //std::cout << ((SymSExpr*)syms[a])->s.c_str() << std::endl; + //defs[a]->print( std::cout ); + //std::cout << std::endl; + + if( defs[a]->getclass()==CEXPR ){ + //calculate which arguments are required for input + std::vector< Expr* > args; + std::vector< bool > argsNeed; + std::vector< Expr* > argTypes; + CExpr* c = ((CExpr*)defs[a]); + while( c->getop()==PI ){ + //std::cout << c->kids[0] << std::endl; + if( ((CExpr*)c->kids[1])->getop()!=RUN ){ + args.push_back( c->kids[0] ); + argsNeed.push_back( true ); + argTypes.push_back( c->kids[1] ); + } + for( int b=0; b<(int)args.size(); b++ ){ + if( argsNeed[b] ){ + if( ((CExpr*)c->kids[1])->getop()==RUN ){ + if( ((CExpr*)c->kids[1])->kids[1]->free_in( args[b] ) ){ + argsNeed[b] = false; + } + }else{ + if( c->kids[1]->free_in( args[b] ) ){ + argsNeed[b] = false; + } + } + } + } + c = (CExpr*)(c->kids[2]); + } + + //record if this declares a judgement + if( ((CExpr*)defs[a])->getop()==PI && c->getop()==TYPE ){ + //std::cout << "This is a judgement" << std::endl; + judgements.push_back( syms[a] ); + //record if this declares a proof rule + }else if( c->getclass()==CEXPR && std::find( judgements.begin(), judgements.end(), c->kids[0] )!=judgements.end() ){ + std::cout << "Handle rule: " << ((SymSExpr*)syms[a])->s.c_str() << std::endl; + //std::cout << "These are required to input:" << std::endl; + //for( int b=0; b<(int)args.size(); b++ ){ + // if( argsNeed[b] ){ + // std::cout << ((SymSExpr*)args[b])->s.c_str() << std::endl; + // } + //} + os_enum << " rule_" << ((SymSExpr*)syms[a])->s.c_str() << "," << std::endl; + + os_print << " case rule_" << ((SymSExpr*)syms[a])->s.c_str() << ": os << \""; + os_print << ((SymSExpr*)syms[a])->s.c_str() << "\";break;" << std::endl; + + std::ostringstream os_args; + os_args << "("; + bool firstTime = true; + for( int b=0; b<(int)args.size(); b++ ){ + if( argsNeed[b] ){ + if( !firstTime ) + os_args << ","; + std::string str; + get_var_name( ((SymSExpr*)args[b])->s, str ); + os_args << " LFSCProof* " << str.c_str(); + firstTime = false; + } + } + if( !firstTime ){ + os_args << " "; + } + os_args << ")"; + + os_constructor_h << " static LFSCProof* make_" << ((SymSExpr*)syms[a])->s.c_str(); + os_constructor_h << os_args.str().c_str() << ";" << std::endl; + + os_constructor_c << "LFSCProof* LFSCProof::make_" << ((SymSExpr*)syms[a])->s.c_str(); + os_constructor_c << os_args.str().c_str() << "{" << std::endl; + os_constructor_c << " LFSCProof **kids = new LFSCProof *[" << (int)args.size()+1 << "];" << std::endl; + for( int b=0; b<(int)args.size(); b++ ){ + os_constructor_c << " kids[" << b << "] = "; + if( argsNeed[b] ){ + std::string str; + get_var_name( ((SymSExpr*)args[b])->s, str ); + os_constructor_c << str.c_str(); + }else{ + os_constructor_c << "hole"; + } + os_constructor_c << ";" << std::endl; + } + os_constructor_c << " kids[" << (int)args.size() << "] = 0;" << std::endl; + os_constructor_c << " return new LFSCProofC( rule_" << ((SymSExpr*)syms[a])->s.c_str() << ", kids );" << std::endl; + os_constructor_c << "}" << std::endl << std::endl; + } + } + + //write the header + static std::string filename( "lfsc_proof" ); + std::fstream fsh; + std::string fnameh( filename ); + fnameh.append(".h"); + fsh.open( fnameh.c_str(), std::ios::out ); + + fsh << "#ifndef LFSC_PROOF_LIB_H" << std::endl; + fsh << "#define LFSC_PROOF_LIB_H" << std::endl; + fsh << std::endl; + fsh << "#include <string>" << std::endl; + fsh << std::endl; + fsh << "class LFSCProof{" << std::endl; + fsh << "protected:" << std::endl; + fsh << " enum{" << std::endl; + fsh << os_enum.str().c_str(); + fsh << " };" << std::endl; + fsh << " static LFSCProof* hole;" << std::endl; + fsh << " LFSCProof(){}" << std::endl; + fsh << "public:" << std::endl; + fsh << " virtual ~LFSCProof(){}" << std::endl; + fsh << " static void init();" << std::endl; + fsh << std::endl; + fsh << " //functions to build LFSC proofs" << std::endl; + fsh << os_constructor_h.str().c_str(); + fsh << std::endl; + fsh << " virtual void set_child( int i, LFSCProof* e ) {}" << std::endl; + fsh << " virtual void print( std::ostream& os ){}" << std::endl; + fsh << "};" << std::endl; + fsh << std::endl; + fsh << "class LFSCProofC : public LFSCProof{" << std::endl; + fsh << " short id;" << std::endl; + fsh << " LFSCProof **kids;" << std::endl; + fsh << "public:" << std::endl; + fsh << " LFSCProofC( short d_id, LFSCProof **d_kids ) : id( d_id ), kids( d_kids ){}" << std::endl; + fsh << " void set_child( int i, LFSCProof* e ) { kids[i] = e; }" << std::endl; + fsh << " void print( std::ostream& os );" << std::endl; + fsh << "};" << std::endl; + fsh << std::endl; + fsh << "class LFSCProofSym : public LFSCProof{" << std::endl; + fsh << "private:" << std::endl; + fsh << " std::string s;" << std::endl; + fsh << " LFSCProofSym( std::string ss ) : s( ss ){}" << std::endl; + fsh << "public:" << std::endl; + fsh << " static LFSCProofSym* make( std::string ss ) { return new LFSCProofSym( ss ); }" << std::endl; + fsh << " static LFSCProofSym* make( const char* ss ) { return new LFSCProofSym( std::string( ss ) ); }" << std::endl; + fsh << " ~LFSCProofSym(){}" << std::endl; + fsh << " void print( std::ostream& os ) { os << s.c_str(); }" << std::endl; + fsh << "};" << std::endl; + fsh << std::endl; + fsh << "class LFSCProofLam : public LFSCProof{" << std::endl; + fsh << " LFSCProofSym* var;" << std::endl; + fsh << " LFSCProof* body;" << std::endl; + fsh << " LFSCProof* typ;" << std::endl; + fsh << " LFSCProofLam( LFSCProofSym* d_var, LFSCProof* d_body, LFSCProof* d_typ ) : var( d_var ), body( d_body ), typ( d_typ ){}" << std::endl; + fsh << "public:" << std::endl; + fsh << " static LFSCProof* make( LFSCProofSym* d_var, LFSCProof* d_body, LFSCProof* d_typ = NULL ) {" << std::endl; + fsh << " return new LFSCProofLam( d_var, d_body, d_typ );" << std::endl; + fsh << " }" << std::endl; + fsh << " ~LFSCProofLam(){}" << std::endl; + fsh << std::endl; + fsh << " void print( std::ostream& os );" << std::endl; + fsh << "};" << std::endl; + fsh << std::endl; + fsh << "#endif" << std::endl; + + //write the cpp + std::fstream fsc; + std::string fnamec( filename ); + fnamec.append(".cpp"); + fsc.open( fnamec.c_str(), std::ios::out ); + + fsc << "#include \"lfsc_proof.h\"" << std::endl; + fsc << std::endl; + fsc << "LFSCProof* LFSCProof::hole = NULL;" << std::endl; + fsc << std::endl; + fsc << "void LFSCProof::init(){" << std::endl; + fsc << " hole = LFSCProofSym::make( \"_\" );" << std::endl; + fsc << "}" << std::endl; + fsc << std::endl; + fsc << "void LFSCProofC::print( std::ostream& os ){" << std::endl; + fsc << " os << \"(\";" << std::endl; + fsc << " switch( id ){" << std::endl; + fsc << os_print.str().c_str(); + fsc << " }" << std::endl; + fsc << " int counter = 0;" << std::endl; + fsc << " while( kids[counter] ){" << std::endl; + fsc << " os << \" \";" << std::endl; + fsc << " kids[counter]->print( os );" << std::endl; + fsc << " counter++;" << std::endl; + fsc << " }" << std::endl; + fsc << " os << \")\";" << std::endl; + fsc << "}" << std::endl; + fsc << std::endl; + fsc << "void LFSCProofLam::print( std::ostream& os ){" << std::endl; + fsc << " os << \"(\";" << std::endl; + fsc << " if( typ ){" << std::endl; + fsc << " os << \"% \";" << std::endl; + fsc << " }else{" << std::endl; + fsc << " os << \"\\\\ \";" << std::endl; + fsc << " }" << std::endl; + fsc << " var->print( os );" << std::endl; + fsc << " if( typ ){" << std::endl; + fsc << " os << \" \";" << std::endl; + fsc << " typ->print( os );" << std::endl; + fsc << " }" << std::endl; + fsc << " os << std::endl;" << std::endl; + fsc << " body->print( os );" << std::endl; + fsc << " os << \")\";" << std::endl; + fsc << "}" << std::endl; + fsc << std::endl; + fsc << os_constructor_c.str().c_str(); + fsc << std::endl; + } +} diff --git a/proofs/lfsc_checker/libwriter.h b/proofs/lfsc_checker/libwriter.h index 093cf541b..91db5e911 100644 --- a/proofs/lfsc_checker/libwriter.h +++ b/proofs/lfsc_checker/libwriter.h @@ -1,28 +1,28 @@ -#ifndef LIB_WRITER_H
-#define LIB_WRITER_H
-
-#include "expr.h"
-#include <map>
-
-class libwriter
-{
-private:
- std::vector< Expr* > syms;
- std::vector< Expr* > defs;
-
- std::vector< Expr* > judgements;
- //get the variable name
- void get_var_name( const std::string& n, std::string& nn );
-public:
- libwriter(){}
- virtual ~libwriter(){}
-
- void add_symbol( Expr* s, Expr* t ) {
- syms.push_back( s );
- defs.push_back( t );
- }
-
- void write_file();
-};
-
-#endif
+#ifndef LIB_WRITER_H +#define LIB_WRITER_H + +#include "expr.h" +#include <map> + +class libwriter +{ +private: + std::vector< Expr* > syms; + std::vector< Expr* > defs; + + std::vector< Expr* > judgements; + //get the variable name + void get_var_name( const std::string& n, std::string& nn ); +public: + libwriter(){} + virtual ~libwriter(){} + + void add_symbol( Expr* s, Expr* t ) { + syms.push_back( s ); + defs.push_back( t ); + } + + void write_file(); +}; + +#endif diff --git a/proofs/lfsc_checker/print_smt2.cpp b/proofs/lfsc_checker/print_smt2.cpp index 34cb00cc4..40d9d1206 100644 --- a/proofs/lfsc_checker/print_smt2.cpp +++ b/proofs/lfsc_checker/print_smt2.cpp @@ -1,122 +1,122 @@ -#include "print_smt2.h"
-
-#ifdef PRINT_SMT2
-
-void print_smt2( Expr* p, std::ostream& s, short mode )
-{
- switch( p->getclass() )
- {
- case CEXPR:
- {
- switch( p->getop() )
- {
- case APP:
- {
+#include "print_smt2.h" + +#ifdef PRINT_SMT2 + +void print_smt2( Expr* p, std::ostream& s, short mode ) +{ + switch( p->getclass() ) + { + case CEXPR: + { + switch( p->getop() ) + { + case APP: + { std::vector<Expr *> args; - Expr *head = p->collect_args(args, false);
- short newMode = get_mode( head );
- if( is_smt2_poly_formula( head ) )
- {
- s << "(";
- head->print( s );
- s << " ";
- print_smt2( args[1], s, newMode );
- s << " ";
- print_smt2( args[2], s, newMode );
- s << ")";
- }
- else if( ( mode==2 || mode==3 ) && mode==newMode )
- {
- print_smt2( args[0], s, newMode );
- s << " ";
- print_smt2( args[1], s, newMode );
- }
- else if( newMode==1 )
- {
- if( mode!=1 || newMode!=mode ){
- s << "(";
- }
- print_smt2( args[2], s, newMode );
- s << " ";
- print_smt2( args[3], s, 0 );
- if( mode!=1 || newMode!=mode ){
- s << ")";
- }
- }
- else
- {
- s << "(";
- switch( newMode )
- {
- case 4: s << "=>";break;
- default: head->print( s );break;
- }
- s << " ";
- for( int a=0; a<(int)args.size(); a++ ){
- print_smt2( args[a], s, newMode );
- if( a!=(int)args.size()-1 )
- s << " ";
- }
- s << ")";
- }
- }
- break;
- default:
- std::cout << "Unhandled op " << p->getop() << std::endl;
- break;
- }
- }
- break;
- case HOLE_EXPR:
- {
- HoleExpr *e = (HoleExpr *)p;
- if( e->val ){
- print_smt2( e->val, s, mode );
- }else{
- s << "_";
- }
- }
- break;
- case SYMS_EXPR:
- case SYM_EXPR:
- if( ((SymExpr*)p)->val )
- print_smt2( ((SymExpr*)p)->val, s, mode );
- else
- p->print( s );
- break;
- default:
- std::cout << "Unhandled class " << p->getclass() << std::endl;
- break;
- }
-}
-
-bool is_smt2_poly_formula( Expr* e )
-{
- if( e->getclass()==SYMS_EXPR )
- {
- SymSExpr* s = (SymSExpr*)e;
- static std::string eq("=");
- static std::string distinct("distinct");
- return s->s==eq || s->s==distinct;
- }else{
- return false;
- }
-}
-
-short get_mode( Expr* e )
-{
- if( e->getclass()==SYMS_EXPR ){
- SymSExpr* s = (SymSExpr*)e;
- static std::string applys("apply");
- if ( s->s==applys ) return 1;
- static std::string ands("and");
- if ( s->s==ands ) return 2;
- static std::string ors("or");
- if ( s->s==ors ) return 3;
- static std::string impls("impl");
- if ( s->s==impls ) return 4;
- }
- return 0;
-}
-
-#endif
+ Expr *head = p->collect_args(args, false); + short newMode = get_mode( head ); + if( is_smt2_poly_formula( head ) ) + { + s << "("; + head->print( s ); + s << " "; + print_smt2( args[1], s, newMode ); + s << " "; + print_smt2( args[2], s, newMode ); + s << ")"; + } + else if( ( mode==2 || mode==3 ) && mode==newMode ) + { + print_smt2( args[0], s, newMode ); + s << " "; + print_smt2( args[1], s, newMode ); + } + else if( newMode==1 ) + { + if( mode!=1 || newMode!=mode ){ + s << "("; + } + print_smt2( args[2], s, newMode ); + s << " "; + print_smt2( args[3], s, 0 ); + if( mode!=1 || newMode!=mode ){ + s << ")"; + } + } + else + { + s << "("; + switch( newMode ) + { + case 4: s << "=>";break; + default: head->print( s );break; + } + s << " "; + for( int a=0; a<(int)args.size(); a++ ){ + print_smt2( args[a], s, newMode ); + if( a!=(int)args.size()-1 ) + s << " "; + } + s << ")"; + } + } + break; + default: + std::cout << "Unhandled op " << p->getop() << std::endl; + break; + } + } + break; + case HOLE_EXPR: + { + HoleExpr *e = (HoleExpr *)p; + if( e->val ){ + print_smt2( e->val, s, mode ); + }else{ + s << "_"; + } + } + break; + case SYMS_EXPR: + case SYM_EXPR: + if( ((SymExpr*)p)->val ) + print_smt2( ((SymExpr*)p)->val, s, mode ); + else + p->print( s ); + break; + default: + std::cout << "Unhandled class " << p->getclass() << std::endl; + break; + } +} + +bool is_smt2_poly_formula( Expr* e ) +{ + if( e->getclass()==SYMS_EXPR ) + { + SymSExpr* s = (SymSExpr*)e; + static std::string eq("="); + static std::string distinct("distinct"); + return s->s==eq || s->s==distinct; + }else{ + return false; + } +} + +short get_mode( Expr* e ) +{ + if( e->getclass()==SYMS_EXPR ){ + SymSExpr* s = (SymSExpr*)e; + static std::string applys("apply"); + if ( s->s==applys ) return 1; + static std::string ands("and"); + if ( s->s==ands ) return 2; + static std::string ors("or"); + if ( s->s==ors ) return 3; + static std::string impls("impl"); + if ( s->s==impls ) return 4; + } + return 0; +} + +#endif diff --git a/proofs/lfsc_checker/print_smt2.h b/proofs/lfsc_checker/print_smt2.h index c70b1dfa4..9bee0e81c 100644 --- a/proofs/lfsc_checker/print_smt2.h +++ b/proofs/lfsc_checker/print_smt2.h @@ -1,17 +1,17 @@ -#ifndef PRINT_SMT2_H
-#define PRINT_SMT2_H
-
-#define PRINT_SMT2
-
-#include "expr.h"
-
-#ifdef PRINT_SMT2
-void print_smt2( Expr* p, std::ostream& s, short mode = 0 );
-
-bool is_smt2_poly_formula( Expr* p );
-short get_mode( Expr* p );
-
-#endif
-
-
-#endif
+#ifndef PRINT_SMT2_H +#define PRINT_SMT2_H + +#define PRINT_SMT2 + +#include "expr.h" + +#ifdef PRINT_SMT2 +void print_smt2( Expr* p, std::ostream& s, short mode = 0 ); + +bool is_smt2_poly_formula( Expr* p ); +short get_mode( Expr* p ); + +#endif + + +#endif diff --git a/proofs/lfsc_checker/sccwriter.cpp b/proofs/lfsc_checker/sccwriter.cpp index d11a96b19..5c1da2a3f 100644 --- a/proofs/lfsc_checker/sccwriter.cpp +++ b/proofs/lfsc_checker/sccwriter.cpp @@ -1,335 +1,335 @@ -#include "sccwriter.h"
-
-#include <fstream>
-#include <sstream>
-
-int sccwriter::exprCount = 0;
-int sccwriter::strCount = 0;
-int sccwriter::argsCount = 0;
-int sccwriter::rnumCount = 0;
-
-int sccwriter::get_prog_index( const std::string& str )
-{
- for( int a=0; a<(int)progNames.size(); a++ ){
- if( progNames[a]==str ){
- return a;
- }
- }
- return -1;
-}
-
-int sccwriter::get_prog_index_by_expr( Expr* e )
-{
- for( int a=0; a<(int)progPtrs.size(); a++ ){
- if( progPtrs[a]==e ){
- return a;
- }
- }
- return -1;
-}
-
-bool sccwriter::is_var( const std::string& str )
-{
- for( int a=0; a<(int)vars.size(); a++ ){
- if( vars[a]==str ){
- return true;
- }
- }
- return false;
-}
-
-void sccwriter::add_global_sym( const std::string& str )
-{
- for( int a=0; a<(int)globalSyms.size(); a++ ){
- if( globalSyms[a]==str ){
- return;
- }
- }
- globalSyms.push_back( str );
-}
-
-void sccwriter::indent( std::ostream& os, int ind )
-{
- for( int a=0; a<ind; a++ )
- {
- os << " ";
- }
-}
-
-void sccwriter::write_function_header( std::ostream& os, int index, int opts )
-{
- //write the function header
- std::string fname;
- get_function_name( progNames[index], fname );
- os << "Expr* " << fname.c_str() << "( ";
- CExpr* progvars = (CExpr*)get_prog( index )->kids[1];
- int counter = 0;
- //write each argument
- while( progvars->kids[counter] )
- {
- if( counter!=0 )
- {
- os << ", ";
- }
- os << "Expr* ";
- write_variable( ((SymSExpr*)progvars->kids[counter])->s, os );
- //add to vars if options are set to do so
- if( opts&opt_write_add_args )
- {
- vars.push_back( ((SymSExpr*)progvars->kids[counter])->s );
- }
- counter++;
- }
- os << " )";
- if( opts&opt_write_call_debug )
- {
- os << "{" << std::endl;
- indent( os, 1 );
- os << "std::cout << \"Call function " << fname.c_str() << " with arguments \";" << std::endl;
- counter = 0;
- while( progvars->kids[counter] )
- {
- if( counter!=0 )
- {
- indent( os, 1 );
- os << "std::cout << \", \";" << std::endl;
- }
- indent( os, 1 );
- write_variable( ((SymSExpr*)progvars->kids[counter])->s, os );
- os << "->print( std::cout );" << std::endl;
- counter++;
- }
- indent( os, 1 );
- os << "std::cout << std::endl;" << std::endl;
- }
-}
-
-void sccwriter::get_function_name( const std::string& pname, std::string& fname )
-{
- fname = std::string( "f_" );
- fname.append( pname );
-}
-
-void sccwriter::write_variable( const std::string& n, std::ostream& os )
-{
- std::string nn;
- get_var_name( n, nn );
- os << nn.c_str();
-}
-
-void sccwriter::get_var_name( const std::string& n, std::string& nn ) {
- nn = std::string( n.c_str() );
- for( int i = 0; i <(int)n.length(); i++ ){
- char c = n[i];
- if (c <= 47)
- c += 65;
- else if (c >= 58 && c <= 64)
- c += 97-58;
- if ((c >= 91 && c <= 94) || c == 96)
- c += 104-91;
- else if (c >= 123)
- c -= 4;
- nn[i] = c;
- }
-}
-
-void sccwriter::write_file()
-{
- static std::string filename( "scccode" );
-
- //writer the h file
- std::fstream fsh;
- std::string fnameh( filename );
- fnameh.append(".h");
- fsh.open( fnameh.c_str(), std::ios::out );
- //write the header in h
- fsh << "#ifndef SCC_CODE_H" << std::endl;
- fsh << "#define SCC_CODE_H" << std::endl << std::endl;
- //include necessary files in h file
- fsh << "#include \"check.h\"" << std::endl << std::endl;
- //write the init function
- fsh << "void init_compiled_scc();" << std::endl << std::endl;
- //write the entry function
- fsh << "Expr* run_compiled_scc( Expr* p, std::vector< Expr* >& args );" << std::endl << std::endl;
- //write the side condition code functions
- for( int n=0; n<(int)progs.size(); n++ )
- {
- //write the header in the h file
- fsh << "inline ";
- write_function_header( fsh, n );
- fsh << ";" << std::endl << std::endl;
- }
- fsh << "#endif" << std::endl << std::endl;
- fsh.close();
-
-
- //writer the cpp code
- std::fstream fsc;
- std::string fnamec( filename );
- fnamec.append(".cpp");
- fsc.open( fnamec.c_str(), std::ios::out );
- //include the h file in the cpp
- fsc << "#include \"scccode.h\"" << std::endl << std::endl;
- std::ostringstream fsc_funcs;
- //write the side condition code functions
- for( currProgram=0; currProgram<(int)progs.size(); currProgram++ )
- {
- //reset naming counters
- vars.clear();
- exprCount = 0;
- strCount = 0;
- argsCount = 0;
- rnumCount = 0;
-
- //for debugging
- std::cout << "program #" << currProgram << " " << progNames[currProgram].c_str() << std::endl;
-
- //write the function header
- write_function_header( fsc_funcs, currProgram, opt_write_add_args|options );
- if( (options&opt_write_call_debug)==0 )
- {
- fsc_funcs << "{" << std::endl;
- }
- //write the code
- //std::vector< std::string > cleanVec;
- //write_code( get_prog( n )->kids[2], fsc, 1, "return ", cleanVec );
- //debug_write_code( progs[n].second->kids[2], fsc, 1 );
- std::string expr;
- write_expr( get_prog( currProgram )->kids[2], fsc_funcs, 1, expr );
- indent( fsc_funcs, 1 );
- fsc_funcs << "return " << expr.c_str() << ";" << std::endl;
- fsc_funcs << "}" << std::endl << std::endl;
- }
- //write the predefined symbols necessary - symbols and progs
- for( int a=0; a<(int)globalSyms.size(); a++ )
- {
- fsc << "Expr* e_" << globalSyms[a].c_str() << ";" << std::endl;
- }
- for( int a=0; a<(int)progs.size(); a++ )
- {
- fsc << "Expr* e_" << progNames[a].c_str() << ";" << std::endl;
- }
- fsc << std::endl;
- //write the init function - initialize symbols and progs
- fsc << "void init_compiled_scc(){" << std::endl;
- for( int a=0; a<(int)globalSyms.size(); a++ )
- {
- indent( fsc, 1 );
- fsc << "e_" << globalSyms[a].c_str() << " = symbols->get(\"" << globalSyms[a].c_str() << "\").first;" << std::endl;
- }
- for( int a=0; a<(int)progs.size(); a++ )
- {
- indent( fsc, 1 );
- fsc << "e_" << progNames[a].c_str() << " = progs[\"" << progNames[a].c_str() << "\"];" << std::endl;
- }
- fsc << "}" << std::endl << std::endl;
- fsc << "Expr* run_compiled_scc( Expr* p, std::vector< Expr* >& args ){" << std::endl;
- //for( int n=0; n<(int)progs.size(); n++ ){
- // indent( fsc, 1 );
- // fsc << "static std::string s_" << progNames[n].c_str() << " = std::string( \"" << progNames[n].c_str() << "\" );" << std::endl;
- //}
- for( int n=0; n<(int)progs.size(); n++ ){
- indent( fsc, 1 );
- if( n!=0 ){
- fsc << "}else ";
- }
- //for each function, test to see if the string matches the name of the function
- fsc << "if( p==e_" << progNames[n].c_str() << " ){" << std::endl;
- indent( fsc, 2 );
- std::string fname;
- get_function_name( progNames[n], fname );
- //map the function to the proper function
- fsc << "return " << fname.c_str() << "( ";
- //write the arguments to the function from args
- CExpr* progvars = (CExpr*)get_prog( n )->kids[1];
- int counter = 0;
- bool firstTime = true;
- while( progvars->kids[counter] )
- {
- if( !firstTime )
- {
- fsc << ", ";
- }
- fsc << "args[" << counter << "]";
- firstTime = false;
- counter++;
- }
- fsc << " );" << std::endl;
- }
- indent( fsc, 1 );
- fsc << "}else{" << std::endl;
- indent( fsc, 2 );
- //return null in the case the function could not be found
- fsc << "return NULL;" << std::endl;
- indent( fsc, 1 );
- fsc << "}" << std::endl;
- fsc << "}" << std::endl << std::endl;
- fsc << fsc_funcs.str().c_str();
-
- fsc.close();
-}
-
-void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* retModStr, int opts )
-{
- std::string retModString;
- std::string incString;
- if ( retModStr )
- {
- retModString = std::string( retModStr );
- retModString.append( " = " );
- incString = std::string( retModStr );
- incString.append( "->inc();" );
- }
- switch( code->getclass() )
- {
- case INT_EXPR:
- {
- indent( os, ind );
- os << retModString.c_str();
- os << "new IntExpr( " << mpz_get_si( ((IntExpr*)code)->n ) << " );" << std::endl;
- indent( os, ind );
- os << incString.c_str() << std::endl;
- }
- break;
- case RAT_EXPR:
- {
- mpz_t num, den;
- mpz_init(num);
- mpz_init(den);
- mpq_get_num( num, ((RatExpr*)code)->n );
- mpq_get_den( den, ((RatExpr*)code)->n );
- indent( os, ind );
- os << retModString.c_str();
- os << "new RatExpr( " << mpz_get_si( num ) << ", " << mpz_get_si( den ) << " );" << std::endl;
- indent( os, ind );
- os << incString.c_str() << std::endl;
- }
- break;
- case SYMS_EXPR:
- {
- //if it is a variable, simply write it to buffer
- if( is_var( ((SymSExpr*)code)->s ) )
- {
- indent( os, ind );
- os << retModString.c_str();
- write_variable( ((SymSExpr*)code)->s.c_str(), os );
- os << ";" << std::endl;
- }
- else //else must look at symbol lookup table
- {
- std::string var;
- get_var_name( ((SymSExpr*)code)->s, var );
- indent( os, ind );
- os << retModString.c_str() << "e_" << var.c_str() << ";" << std::endl;
- add_global_sym( var );
- }
- indent( os, ind );
- os << incString.c_str() << std::endl;
- }
- break;
- default:
- switch( code->getop() )
- {
+#include "sccwriter.h" + +#include <fstream> +#include <sstream> + +int sccwriter::exprCount = 0; +int sccwriter::strCount = 0; +int sccwriter::argsCount = 0; +int sccwriter::rnumCount = 0; + +int sccwriter::get_prog_index( const std::string& str ) +{ + for( int a=0; a<(int)progNames.size(); a++ ){ + if( progNames[a]==str ){ + return a; + } + } + return -1; +} + +int sccwriter::get_prog_index_by_expr( Expr* e ) +{ + for( int a=0; a<(int)progPtrs.size(); a++ ){ + if( progPtrs[a]==e ){ + return a; + } + } + return -1; +} + +bool sccwriter::is_var( const std::string& str ) +{ + for( int a=0; a<(int)vars.size(); a++ ){ + if( vars[a]==str ){ + return true; + } + } + return false; +} + +void sccwriter::add_global_sym( const std::string& str ) +{ + for( int a=0; a<(int)globalSyms.size(); a++ ){ + if( globalSyms[a]==str ){ + return; + } + } + globalSyms.push_back( str ); +} + +void sccwriter::indent( std::ostream& os, int ind ) +{ + for( int a=0; a<ind; a++ ) + { + os << " "; + } +} + +void sccwriter::write_function_header( std::ostream& os, int index, int opts ) +{ + //write the function header + std::string fname; + get_function_name( progNames[index], fname ); + os << "Expr* " << fname.c_str() << "( "; + CExpr* progvars = (CExpr*)get_prog( index )->kids[1]; + int counter = 0; + //write each argument + while( progvars->kids[counter] ) + { + if( counter!=0 ) + { + os << ", "; + } + os << "Expr* "; + write_variable( ((SymSExpr*)progvars->kids[counter])->s, os ); + //add to vars if options are set to do so + if( opts&opt_write_add_args ) + { + vars.push_back( ((SymSExpr*)progvars->kids[counter])->s ); + } + counter++; + } + os << " )"; + if( opts&opt_write_call_debug ) + { + os << "{" << std::endl; + indent( os, 1 ); + os << "std::cout << \"Call function " << fname.c_str() << " with arguments \";" << std::endl; + counter = 0; + while( progvars->kids[counter] ) + { + if( counter!=0 ) + { + indent( os, 1 ); + os << "std::cout << \", \";" << std::endl; + } + indent( os, 1 ); + write_variable( ((SymSExpr*)progvars->kids[counter])->s, os ); + os << "->print( std::cout );" << std::endl; + counter++; + } + indent( os, 1 ); + os << "std::cout << std::endl;" << std::endl; + } +} + +void sccwriter::get_function_name( const std::string& pname, std::string& fname ) +{ + fname = std::string( "f_" ); + fname.append( pname ); +} + +void sccwriter::write_variable( const std::string& n, std::ostream& os ) +{ + std::string nn; + get_var_name( n, nn ); + os << nn.c_str(); +} + +void sccwriter::get_var_name( const std::string& n, std::string& nn ) { + nn = std::string( n.c_str() ); + for( int i = 0; i <(int)n.length(); i++ ){ + char c = n[i]; + if (c <= 47) + c += 65; + else if (c >= 58 && c <= 64) + c += 97-58; + if ((c >= 91 && c <= 94) || c == 96) + c += 104-91; + else if (c >= 123) + c -= 4; + nn[i] = c; + } +} + +void sccwriter::write_file() +{ + static std::string filename( "scccode" ); + + //writer the h file + std::fstream fsh; + std::string fnameh( filename ); + fnameh.append(".h"); + fsh.open( fnameh.c_str(), std::ios::out ); + //write the header in h + fsh << "#ifndef SCC_CODE_H" << std::endl; + fsh << "#define SCC_CODE_H" << std::endl << std::endl; + //include necessary files in h file + fsh << "#include \"check.h\"" << std::endl << std::endl; + //write the init function + fsh << "void init_compiled_scc();" << std::endl << std::endl; + //write the entry function + fsh << "Expr* run_compiled_scc( Expr* p, std::vector< Expr* >& args );" << std::endl << std::endl; + //write the side condition code functions + for( int n=0; n<(int)progs.size(); n++ ) + { + //write the header in the h file + fsh << "inline "; + write_function_header( fsh, n ); + fsh << ";" << std::endl << std::endl; + } + fsh << "#endif" << std::endl << std::endl; + fsh.close(); + + + //writer the cpp code + std::fstream fsc; + std::string fnamec( filename ); + fnamec.append(".cpp"); + fsc.open( fnamec.c_str(), std::ios::out ); + //include the h file in the cpp + fsc << "#include \"scccode.h\"" << std::endl << std::endl; + std::ostringstream fsc_funcs; + //write the side condition code functions + for( currProgram=0; currProgram<(int)progs.size(); currProgram++ ) + { + //reset naming counters + vars.clear(); + exprCount = 0; + strCount = 0; + argsCount = 0; + rnumCount = 0; + + //for debugging + std::cout << "program #" << currProgram << " " << progNames[currProgram].c_str() << std::endl; + + //write the function header + write_function_header( fsc_funcs, currProgram, opt_write_add_args|options ); + if( (options&opt_write_call_debug)==0 ) + { + fsc_funcs << "{" << std::endl; + } + //write the code + //std::vector< std::string > cleanVec; + //write_code( get_prog( n )->kids[2], fsc, 1, "return ", cleanVec ); + //debug_write_code( progs[n].second->kids[2], fsc, 1 ); + std::string expr; + write_expr( get_prog( currProgram )->kids[2], fsc_funcs, 1, expr ); + indent( fsc_funcs, 1 ); + fsc_funcs << "return " << expr.c_str() << ";" << std::endl; + fsc_funcs << "}" << std::endl << std::endl; + } + //write the predefined symbols necessary - symbols and progs + for( int a=0; a<(int)globalSyms.size(); a++ ) + { + fsc << "Expr* e_" << globalSyms[a].c_str() << ";" << std::endl; + } + for( int a=0; a<(int)progs.size(); a++ ) + { + fsc << "Expr* e_" << progNames[a].c_str() << ";" << std::endl; + } + fsc << std::endl; + //write the init function - initialize symbols and progs + fsc << "void init_compiled_scc(){" << std::endl; + for( int a=0; a<(int)globalSyms.size(); a++ ) + { + indent( fsc, 1 ); + fsc << "e_" << globalSyms[a].c_str() << " = symbols->get(\"" << globalSyms[a].c_str() << "\").first;" << std::endl; + } + for( int a=0; a<(int)progs.size(); a++ ) + { + indent( fsc, 1 ); + fsc << "e_" << progNames[a].c_str() << " = progs[\"" << progNames[a].c_str() << "\"];" << std::endl; + } + fsc << "}" << std::endl << std::endl; + fsc << "Expr* run_compiled_scc( Expr* p, std::vector< Expr* >& args ){" << std::endl; + //for( int n=0; n<(int)progs.size(); n++ ){ + // indent( fsc, 1 ); + // fsc << "static std::string s_" << progNames[n].c_str() << " = std::string( \"" << progNames[n].c_str() << "\" );" << std::endl; + //} + for( int n=0; n<(int)progs.size(); n++ ){ + indent( fsc, 1 ); + if( n!=0 ){ + fsc << "}else "; + } + //for each function, test to see if the string matches the name of the function + fsc << "if( p==e_" << progNames[n].c_str() << " ){" << std::endl; + indent( fsc, 2 ); + std::string fname; + get_function_name( progNames[n], fname ); + //map the function to the proper function + fsc << "return " << fname.c_str() << "( "; + //write the arguments to the function from args + CExpr* progvars = (CExpr*)get_prog( n )->kids[1]; + int counter = 0; + bool firstTime = true; + while( progvars->kids[counter] ) + { + if( !firstTime ) + { + fsc << ", "; + } + fsc << "args[" << counter << "]"; + firstTime = false; + counter++; + } + fsc << " );" << std::endl; + } + indent( fsc, 1 ); + fsc << "}else{" << std::endl; + indent( fsc, 2 ); + //return null in the case the function could not be found + fsc << "return NULL;" << std::endl; + indent( fsc, 1 ); + fsc << "}" << std::endl; + fsc << "}" << std::endl << std::endl; + fsc << fsc_funcs.str().c_str(); + + fsc.close(); +} + +void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* retModStr, int opts ) +{ + std::string retModString; + std::string incString; + if ( retModStr ) + { + retModString = std::string( retModStr ); + retModString.append( " = " ); + incString = std::string( retModStr ); + incString.append( "->inc();" ); + } + switch( code->getclass() ) + { + case INT_EXPR: + { + indent( os, ind ); + os << retModString.c_str(); + os << "new IntExpr( " << mpz_get_si( ((IntExpr*)code)->n ) << " );" << std::endl; + indent( os, ind ); + os << incString.c_str() << std::endl; + } + break; + case RAT_EXPR: + { + mpz_t num, den; + mpz_init(num); + mpz_init(den); + mpq_get_num( num, ((RatExpr*)code)->n ); + mpq_get_den( den, ((RatExpr*)code)->n ); + indent( os, ind ); + os << retModString.c_str(); + os << "new RatExpr( " << mpz_get_si( num ) << ", " << mpz_get_si( den ) << " );" << std::endl; + indent( os, ind ); + os << incString.c_str() << std::endl; + } + break; + case SYMS_EXPR: + { + //if it is a variable, simply write it to buffer + if( is_var( ((SymSExpr*)code)->s ) ) + { + indent( os, ind ); + os << retModString.c_str(); + write_variable( ((SymSExpr*)code)->s.c_str(), os ); + os << ";" << std::endl; + } + else //else must look at symbol lookup table + { + std::string var; + get_var_name( ((SymSExpr*)code)->s, var ); + indent( os, ind ); + os << retModString.c_str() << "e_" << var.c_str() << ";" << std::endl; + add_global_sym( var ); + } + indent( os, ind ); + os << incString.c_str() << std::endl; + } + break; + default: + switch( code->getop() ) + { case APP: { //collect the arguments @@ -403,7 +403,7 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r //os << expr.c_str() << "->dec();" << std::endl; } } - break;
+ break; case MATCH: { //calculate the value for the expression @@ -565,13 +565,13 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r if( retModStr!=NULL ){ indent( os, ind ); os << retModString.c_str() << expr.c_str() << ";" << std::endl; - indent( os, ind );
+ indent( os, ind ); os << incString.c_str() << std::endl; } write_dec( expr, os, ind ); } break; - case IFMARKED:
+ case IFMARKED: { //calculate the value for the expression std::string expr; @@ -585,10 +585,10 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[2], os, ind+1, retModStr ); indent( os, ind ); - os << "}" << std::endl;
- //clean up memory
- write_dec( expr, os, ind );
- }
+ os << "}" << std::endl; + //clean up memory + write_dec( expr, os, ind ); + } break; #else case MARKVAR: @@ -612,7 +612,7 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r if( retModStr!=NULL ){ indent( os, ind ); os << retModString.c_str() << expr.c_str() << ";" << std::endl; - indent( os, ind );
+ indent( os, ind ); os << incString.c_str() << std::endl; } write_dec( expr, os, ind ); @@ -631,12 +631,12 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r write_code( ((CExpr*)code)->kids[3], os, ind+1, retModStr ); indent( os, ind ); os << "}" << std::endl; - //clean up memory
+ //clean up memory write_dec( expr1, os, ind ); write_dec( expr2, os, ind ); } break; - case IFMARKED:
+ case IFMARKED: { //calculate the value for the expression std::string expr; @@ -651,10 +651,10 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[3], os, ind+1, retModStr ); indent( os, ind ); - os << "}" << std::endl;
- //clean up memory
- write_dec( expr, os, ind );
- }
+ os << "}" << std::endl; + //clean up memory + write_dec( expr, os, ind ); + } break; #endif case ADD: @@ -709,8 +709,8 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r write_dec( expr2, os, ind ); } break; - case NEG:
- {
+ case NEG: + { //calculate the value for the first expression std::string expr1; write_expr( ((CExpr*)code)->kids[0], os, ind, expr1 ); @@ -726,9 +726,9 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r indent( os, ind+1 ); os << "mpz_neg( " << ss.str().c_str() << ", ((IntExpr*)" << expr1.c_str() << "->followDefs())->n );" << std::endl; indent( os, ind+1 ); - os << retModString.c_str() << "new IntExpr(" << ss.str().c_str() << ");" << std::endl;
+ os << retModString.c_str() << "new IntExpr(" << ss.str().c_str() << ");" << std::endl; indent( os, ind ); - os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl;
+ os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "mpq_t " << ss.str().c_str() << ";" << std::endl; indent( os, ind+1 ); @@ -736,55 +736,55 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r indent( os, ind+1 ); os << "mpq_neg( " << ss.str().c_str() << ", ((RatExpr*)" << expr1.c_str() << "->followDefs())->n );" << std::endl; indent( os, ind+1 ); - os << retModString.c_str() << "new RatExpr(" << ss.str().c_str() << ");" << std::endl;
+ os << retModString.c_str() << "new RatExpr(" << ss.str().c_str() << ");" << std::endl; indent( os, ind ); - os << "}" << std::endl;
- //clean up memory
- write_dec( expr1, os, ind );
- }
- break;
- case IFNEG:
- case IFZERO:
- {
+ os << "}" << std::endl; + //clean up memory + write_dec( expr1, os, ind ); + } + break; + case IFNEG: + case IFZERO: + { std::string expr1; - write_expr( ((CExpr*)code)->kids[0], os, ind, expr1 );
+ write_expr( ((CExpr*)code)->kids[0], os, ind, expr1 ); indent( os, ind ); - os << "if( " << expr1.c_str() << "->followDefs()->getclass()==INT_EXPR ){" << std::endl;
- indent( os, ind+1 );
- os << "if( mpz_sgn( ((IntExpr *)" << expr1.c_str() << "->followDefs())->n ) ";
- if( code->getop()==IFNEG )
- os << "<";
- else
- os << "==";
- os << " 0 ){" << std::endl;
- write_code( ((CExpr*)code)->kids[1], os, ind+2, retModStr );
- indent( os, ind+1 );
- os << "}else{" << std::endl;
- write_code( ((CExpr*)code)->kids[2], os, ind+2, retModStr );
- indent( os, ind+1 );
- os << "}" << std::endl;
+ os << "if( " << expr1.c_str() << "->followDefs()->getclass()==INT_EXPR ){" << std::endl; + indent( os, ind+1 ); + os << "if( mpz_sgn( ((IntExpr *)" << expr1.c_str() << "->followDefs())->n ) "; + if( code->getop()==IFNEG ) + os << "<"; + else + os << "=="; + os << " 0 ){" << std::endl; + write_code( ((CExpr*)code)->kids[1], os, ind+2, retModStr ); + indent( os, ind+1 ); + os << "}else{" << std::endl; + write_code( ((CExpr*)code)->kids[2], os, ind+2, retModStr ); + indent( os, ind+1 ); + os << "}" << std::endl; indent( os, ind ); - os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl;
- indent( os, ind+1 );
- os << "if( mpq_sgn( ((RatExpr *)" << expr1.c_str() << "->followDefs())->n ) ";
- if( code->getop()==IFNEG )
- os << "<";
- else
- os << "==";
- os << " 0 ){" << std::endl;
- write_code( ((CExpr*)code)->kids[1], os, ind+2, retModStr );
- indent( os, ind+1 );
- os << "}else{" << std::endl;
- write_code( ((CExpr*)code)->kids[2], os, ind+2, retModStr );
- indent( os, ind+1 );
- os << "}" << std::endl;
+ os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl; + indent( os, ind+1 ); + os << "if( mpq_sgn( ((RatExpr *)" << expr1.c_str() << "->followDefs())->n ) "; + if( code->getop()==IFNEG ) + os << "<"; + else + os << "=="; + os << " 0 ){" << std::endl; + write_code( ((CExpr*)code)->kids[1], os, ind+2, retModStr ); + indent( os, ind+1 ); + os << "}else{" << std::endl; + write_code( ((CExpr*)code)->kids[2], os, ind+2, retModStr ); + indent( os, ind+1 ); + os << "}" << std::endl; indent( os, ind ); - os << "}" << std::endl;
- //clean up memory
- write_dec( expr1, os, ind );
- }
- break;
- case RUN:/*?*/break;
+ os << "}" << std::endl; + //clean up memory + write_dec( expr1, os, ind ); + } + break; + case RUN:/*?*/break; case PI:/*?*/break; case LAM:/*?*/break; case TYPE:/*?*/break; @@ -793,16 +793,16 @@ void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* r case MPZ:/*?*/break; case PROG:/*?*/break; case PROGVARS:/*?*/break; - case PAT:/*?*/break;
- }
- break;
- }
-}
-
-void sccwriter::write_args( CExpr* code, std::ostream& os, int ind, int childCounter,
- std::vector< std::string >& args, int opts )
-{
- bool encounterCase = false;
+ case PAT:/*?*/break; + } + break; + } +} + +void sccwriter::write_args( CExpr* code, std::ostream& os, int ind, int childCounter, + std::vector< std::string >& args, int opts ) +{ + bool encounterCase = false; while( code->kids[childCounter] && (!encounterCase || code->kids[childCounter]->getop()==CASE ) ) { @@ -819,68 +819,68 @@ void sccwriter::write_args( CExpr* code, std::ostream& os, int ind, int childCou args.push_back( expr ); } childCounter++; - }
-}
-
-void sccwriter::write_expr( Expr* code, std::ostream& os, int ind, std::string& expr, int opts )
-{
- if( code->getclass()==SYMS_EXPR && is_var( ((SymSExpr*)code)->s ) )
- {
- get_var_name( ((SymSExpr*)code)->s, expr );
- indent( os, ind );
- os << expr.c_str() << "->inc();" << std::endl;
- }
- else
- {
+ } +} + +void sccwriter::write_expr( Expr* code, std::ostream& os, int ind, std::string& expr, int opts ) +{ + if( code->getclass()==SYMS_EXPR && is_var( ((SymSExpr*)code)->s ) ) + { + get_var_name( ((SymSExpr*)code)->s, expr ); + indent( os, ind ); + os << expr.c_str() << "->inc();" << std::endl; + } + else + { std::ostringstream ss; ss << "e" << exprCount; - exprCount++;
- //declare the expression
- indent( os, ind );
- if( code->getclass()==SYMS_EXPR && !is_var( ((SymSExpr*)code)->s ) )
- {
- os << "static ";
- }
- os << "Expr* " << ss.str().c_str() << ";" << std::endl;
- //write the expression
+ exprCount++; + //declare the expression + indent( os, ind ); + if( code->getclass()==SYMS_EXPR && !is_var( ((SymSExpr*)code)->s ) ) + { + os << "static "; + } + os << "Expr* " << ss.str().c_str() << ";" << std::endl; + //write the expression std::ostringstream ss2; ss2 << ss.str().c_str(); - write_code( code, os, ind, ss2.str().c_str(), opts );
-
- //if is not a sym expression, then decrement the expression and return null
- if( opts&opt_write_check_sym_expr )
+ write_code( code, os, ind, ss2.str().c_str(), opts ); + + //if is not a sym expression, then decrement the expression and return null + if( opts&opt_write_check_sym_expr ) { indent( os, ind ); os << "if (" << expr.c_str() << "->getclass() != SYM_EXPR) {" << std::endl; indent( os, ind+1 ); os << "exit( 1 );" << std::endl; indent( os, ind ); - os << "}" << std::endl;
- }
-
- expr = std::string( ss.str().c_str() );
- vars.push_back( expr );
- }
- //increment the counter for memory management
- //indent( os, ind );
- //os << expr.c_str() << "->inc();" << std::endl;
-}
-
-void sccwriter::write_dec( const std::string& expr, std::ostream& os, int ind )
-{
- bool wd = true;
- if( wd )
- {
- indent( os, ind );
- os << expr.c_str() << "->dec();" << std::endl;
- }
-}
-
-void sccwriter::debug_write_code( Expr* code, std::ostream& os, int ind )
-{
- indent( os, ind );
- switch( code->getclass() )
- {
+ os << "}" << std::endl; + } + + expr = std::string( ss.str().c_str() ); + vars.push_back( expr ); + } + //increment the counter for memory management + //indent( os, ind ); + //os << expr.c_str() << "->inc();" << std::endl; +} + +void sccwriter::write_dec( const std::string& expr, std::ostream& os, int ind ) +{ + bool wd = true; + if( wd ) + { + indent( os, ind ); + os << expr.c_str() << "->dec();" << std::endl; + } +} + +void sccwriter::debug_write_code( Expr* code, std::ostream& os, int ind ) +{ + indent( os, ind ); + switch( code->getclass() ) + { case INT_EXPR: os << "int_expr"; break; @@ -890,12 +890,12 @@ void sccwriter::debug_write_code( Expr* code, std::ostream& os, int ind ) case SYM_EXPR: os << "sym_expr"; break; - case SYMS_EXPR:
- os << "syms_expr: " << ((SymSExpr*)code)->s.c_str();
- break;
- default:
- switch( code->getop() )
- {
+ case SYMS_EXPR: + os << "syms_expr: " << ((SymSExpr*)code)->s.c_str(); + break; + default: + switch( code->getop() ) + { case APP: os << "app"; break; @@ -920,9 +920,9 @@ void sccwriter::debug_write_code( Expr* code, std::ostream& os, int ind ) case PROG: os << "prog"; break; - case PROGVARS:
- os << "progvars";
- break;
+ case PROGVARS: + os << "progvars"; + break; case MATCH: os << "match"; break; @@ -953,25 +953,25 @@ void sccwriter::debug_write_code( Expr* code, std::ostream& os, int ind ) case MARKVAR: os << "markvar"; break; - case IFMARKED:
- os << "ifmarked";
- break;
- case COMPARE:
- os << "compare";
- break;
- default:
- os << "???";
- break;
- }
- }
- os << std::endl;
- if( code->getop()!=0 )
- {
- CExpr* ce = (CExpr*)code;
- int counter = 0;
- while( ce->kids[counter] ){
- debug_write_code( ce->kids[counter], os, ind+1 );
- counter++;
- }
- }
-}
+ case IFMARKED: + os << "ifmarked"; + break; + case COMPARE: + os << "compare"; + break; + default: + os << "???"; + break; + } + } + os << std::endl; + if( code->getop()!=0 ) + { + CExpr* ce = (CExpr*)code; + int counter = 0; + while( ce->kids[counter] ){ + debug_write_code( ce->kids[counter], os, ind+1 ); + counter++; + } + } +} diff --git a/proofs/lfsc_checker/sccwriter.h b/proofs/lfsc_checker/sccwriter.h index f8922934f..bd9732579 100644 --- a/proofs/lfsc_checker/sccwriter.h +++ b/proofs/lfsc_checker/sccwriter.h @@ -1,86 +1,86 @@ -#ifndef SCC_WRITER_H
-#define SCC_WRITER_H
-
-#include "expr.h"
-#include <vector>
-#include "check.h"
-
-enum
-{
- opt_write_case_body = 0x00000001,
- opt_write_check_sym_expr = 0x00000002,
- opt_write_add_args = 0x000000004,
- opt_write_no_inc = 0x00000008,
-
- opt_write_call_debug = 0x00000010,
- opt_write_nested_app = 0x00000020,
-};
-
-class sccwriter
-{
-private:
- //options
- int options;
- //programs to write to file
- symmap progs;
- //list of indicies in progs
- std::vector< Expr* > progPtrs;
- std::vector< std::string > progNames;
- int currProgram;
- //current variables in the scope
- std::vector< std::string > vars;
- //global variables stored for lookups
- std::vector< std::string > globalSyms;
- //symbols that must be dec'ed
- std::vector< std::string > decSyms;
- //get program
- CExpr* get_prog( int n ) { return (CExpr*)progs[ progNames[n] ]; }
- //get index for string
- int get_prog_index_by_expr( Expr* e );
- int get_prog_index( const std::string& str );
- //is variable in current scope
- bool is_var( const std::string& str );
- //add global sym
- void add_global_sym( const std::string& str );
- //expression count
- static int exprCount;
- //string count
- static int strCount;
- //args count
- static int argsCount;
- //num count
- static int rnumCount;
- //indent
- static void indent( std::ostream& os, int ind );
- //write function header
- void write_function_header( std::ostream& os, int index, int opts = 0 );
- void write_code( Expr* code, std::ostream& os, int ind, const char* retModStr, int opts = 0 );
- //write all children starting at child counter to stream, store in Expr* e_...e_;
- void write_args( CExpr* code, std::ostream& os, int ind, int childCounter, std::vector< std::string >& args, int opts = 0 );
- //write expression - store result of code into e_ for some Expr* e_;
- void write_expr( Expr* code, std::ostream& os, int ind, std::string& expr, int opts = 0 );
- //write variable
- void write_variable( const std::string& n, std::ostream& os );
- //get function name
- void get_function_name( const std::string& pname, std::string& fname );
- //get the variable name
- void get_var_name( const std::string& n, std::string& nn );
- //write dec
- void write_dec( const std::string& expr, std::ostream& os, int ind );
-public:
- sccwriter( int opts = 0 ) : options( opts ){}
- virtual ~sccwriter(){}
-
- void add_scc( const std::string& pname, Expr* exp ) {
- //progs.push_back( std::pair< std::string, CExpr* >( pname, exp ) );
- progs[pname] = exp;
- progPtrs.push_back( exp );
- progNames.push_back( pname );
- }
-
- void write_file();
- //write code
- static void debug_write_code( Expr* code, std::ostream& os, int ind );
-};
-
-#endif
+#ifndef SCC_WRITER_H +#define SCC_WRITER_H + +#include "expr.h" +#include <vector> +#include "check.h" + +enum +{ + opt_write_case_body = 0x00000001, + opt_write_check_sym_expr = 0x00000002, + opt_write_add_args = 0x000000004, + opt_write_no_inc = 0x00000008, + + opt_write_call_debug = 0x00000010, + opt_write_nested_app = 0x00000020, +}; + +class sccwriter +{ +private: + //options + int options; + //programs to write to file + symmap progs; + //list of indicies in progs + std::vector< Expr* > progPtrs; + std::vector< std::string > progNames; + int currProgram; + //current variables in the scope + std::vector< std::string > vars; + //global variables stored for lookups + std::vector< std::string > globalSyms; + //symbols that must be dec'ed + std::vector< std::string > decSyms; + //get program + CExpr* get_prog( int n ) { return (CExpr*)progs[ progNames[n] ]; } + //get index for string + int get_prog_index_by_expr( Expr* e ); + int get_prog_index( const std::string& str ); + //is variable in current scope + bool is_var( const std::string& str ); + //add global sym + void add_global_sym( const std::string& str ); + //expression count + static int exprCount; + //string count + static int strCount; + //args count + static int argsCount; + //num count + static int rnumCount; + //indent + static void indent( std::ostream& os, int ind ); + //write function header + void write_function_header( std::ostream& os, int index, int opts = 0 ); + void write_code( Expr* code, std::ostream& os, int ind, const char* retModStr, int opts = 0 ); + //write all children starting at child counter to stream, store in Expr* e_...e_; + void write_args( CExpr* code, std::ostream& os, int ind, int childCounter, std::vector< std::string >& args, int opts = 0 ); + //write expression - store result of code into e_ for some Expr* e_; + void write_expr( Expr* code, std::ostream& os, int ind, std::string& expr, int opts = 0 ); + //write variable + void write_variable( const std::string& n, std::ostream& os ); + //get function name + void get_function_name( const std::string& pname, std::string& fname ); + //get the variable name + void get_var_name( const std::string& n, std::string& nn ); + //write dec + void write_dec( const std::string& expr, std::ostream& os, int ind ); +public: + sccwriter( int opts = 0 ) : options( opts ){} + virtual ~sccwriter(){} + + void add_scc( const std::string& pname, Expr* exp ) { + //progs.push_back( std::pair< std::string, CExpr* >( pname, exp ) ); + progs[pname] = exp; + progPtrs.push_back( exp ); + progNames.push_back( pname ); + } + + void write_file(); + //write code + static void debug_write_code( Expr* code, std::ostream& os, int ind ); +}; + +#endif diff --git a/proofs/signatures/ex_bv.plf b/proofs/signatures/ex_bv.plf index 02cadaeab..ae585e455 100755 --- a/proofs/signatures/ex_bv.plf +++ b/proofs/signatures/ex_bv.plf @@ -1,57 +1,57 @@ -; a = b ^ a = 00000 ^ b = 11111 is UNSAT
-
-(check
-(% a var_bv
-(% b var_bv
-(% f1 (th_holds (= BitVec (a_var_bv a) (a_var_bv b)))
-(% f2 (th_holds (= BitVec (a_var_bv a) (a_bv (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))))))
-(% f3 (th_holds (= BitVec (a_var_bv b) (a_bv (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))))))
-(: (holds cln)
-
-(decl_bv_atom_var 5 a (\ ba1
-(decl_bv_atom_var 5 b (\ ba2
-(decl_bv_atom_const _ (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))) (\ c (\ ba3
-(decl_bv_atom_const _ (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))) (\ d (\ ba4
-
-(decl_atom (bblast a 4) (\ v1 (\ a1
-(decl_atom (bblast b 4) (\ v2 (\ a2
-
-; bitblasting terms
-(th_let_pf _ (bv_bbl_var _ _ _ ba1) (\ bt1
-(th_let_pf _ (bv_bbl_var _ _ _ ba2) (\ bt2
-(th_let_pf _ (bv_bbl_const _ _ _ _ ba3) (\ bt3
-(th_let_pf _ (bv_bbl_const _ _ _ _ ba4) (\ bt4
-
-; bitblasting formulas
-(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt1 bt2) (\ bf1
-(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt1 bt3) (\ bf2
-(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt2 bt4) (\ bf3
-
-; CNFication
-; a.4 V ~b.4
-(satlem _ _
-(asf _ _ _ a1 (\ l1
-(ast _ _ _ a2 (\ l2
-(clausify_false
- (contra _ (impl_elim _ _ l2 (iff_elim_2 _ _ (and_elim_1 _ _ (impl_elim _ _ f1 bf1)))) l1) ; notice at the intermost we impl_elim, which converts from atom to bit-blasting representation
-))))) (\ C2
-
-; ~a.4
-(satlem _ _
-(ast _ _ _ a1 (\ l1
-(clausify_false
- (impl_elim _ _ l1 (iff_elim_1 _ _ (and_elim_1 _ _ (impl_elim _ _ f2 bf2))))
-))) (\ C3
-
-; b.4
-(satlem _ _
-(asf _ _ _ a2 (\ l2
-(clausify_false
- (contra _ (impl_elim _ _ truth (iff_elim_2 _ _ (and_elim_1 _ _ (impl_elim _ _ f3 bf3)))) l2)
-))) (\ C6
-
-
-(satlem_simplify _ _ _
-(R _ _ (R _ _ C6 C2 v2) C3 v1) (\ x x))
-
+; a = b ^ a = 00000 ^ b = 11111 is UNSAT + +(check +(% a var_bv +(% b var_bv +(% f1 (th_holds (= BitVec (a_var_bv a) (a_var_bv b))) +(% f2 (th_holds (= BitVec (a_var_bv a) (a_bv (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn)))))))) +(% f3 (th_holds (= BitVec (a_var_bv b) (a_bv (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn)))))))) +(: (holds cln) + +(decl_bv_atom_var 5 a (\ ba1 +(decl_bv_atom_var 5 b (\ ba2 +(decl_bv_atom_const _ (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))) (\ c (\ ba3 +(decl_bv_atom_const _ (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))) (\ d (\ ba4 + +(decl_atom (bblast a 4) (\ v1 (\ a1 +(decl_atom (bblast b 4) (\ v2 (\ a2 + +; bitblasting terms +(th_let_pf _ (bv_bbl_var _ _ _ ba1) (\ bt1 +(th_let_pf _ (bv_bbl_var _ _ _ ba2) (\ bt2 +(th_let_pf _ (bv_bbl_const _ _ _ _ ba3) (\ bt3 +(th_let_pf _ (bv_bbl_const _ _ _ _ ba4) (\ bt4 + +; bitblasting formulas +(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt1 bt2) (\ bf1 +(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt1 bt3) (\ bf2 +(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt2 bt4) (\ bf3 + +; CNFication +; a.4 V ~b.4 +(satlem _ _ +(asf _ _ _ a1 (\ l1 +(ast _ _ _ a2 (\ l2 +(clausify_false + (contra _ (impl_elim _ _ l2 (iff_elim_2 _ _ (and_elim_1 _ _ (impl_elim _ _ f1 bf1)))) l1) ; notice at the intermost we impl_elim, which converts from atom to bit-blasting representation +))))) (\ C2 + +; ~a.4 +(satlem _ _ +(ast _ _ _ a1 (\ l1 +(clausify_false + (impl_elim _ _ l1 (iff_elim_1 _ _ (and_elim_1 _ _ (impl_elim _ _ f2 bf2)))) +))) (\ C3 + +; b.4 +(satlem _ _ +(asf _ _ _ a2 (\ l2 +(clausify_false + (contra _ (impl_elim _ _ truth (iff_elim_2 _ _ (and_elim_1 _ _ (impl_elim _ _ f3 bf3)))) l2) +))) (\ C6 + + +(satlem_simplify _ _ _ +(R _ _ (R _ _ C6 C2 v2) C3 v1) (\ x x)) + )))))))))))))))))))))))))))))))))))))))))))
\ No newline at end of file diff --git a/proofs/signatures/th_bv.plf b/proofs/signatures/th_bv.plf index 3fb9d1356..0fb50f8cf 100755 --- a/proofs/signatures/th_bv.plf +++ b/proofs/signatures/th_bv.plf @@ -1,145 +1,145 @@ -; "bitvec" is a term of type "sort"
-(declare BitVec sort)
-
-; bit type
-(declare bit type)
-(declare b0 bit)
-(declare b1 bit)
-
-; bit vector type
-(declare bv type)
-(declare bvn bv)
-(declare bvc (! b bit (! v bv bv)))
-; a bv constant term
-(declare a_bv (! v bv (term BitVec)))
-
-; calculate the length of a bitvector
-(program bv_len ((v bv)) mpz
- (match v
- (bvn 0)
- ((bvc b v') (mp_add (bv_len v') 1))))
-
-; a bv variable
-(declare var_bv type)
-; a bv variable term
-(declare a_var_bv (! v var_bv (term BitVec)))
-
-
-; bit vector operators
-(define bvoper (! x (term BitVec)
- (! y (term BitVec)
- (term BitVec))))
-(declare bvand bvoper)
-(declare bvadd bvoper)
-;....
-
-; all bit-vector terms are mapped with "bv_atom" to:
-; - a simply-typed term of type "var_bv", which is necessary for bit-blasting
-; - a integer size
-(declare bv_atom (! x (term BitVec) (! y var_bv (! n mpz type))))
-
-(declare decl_bv_atom_var (! n mpz ; must be specified
- (! x var_bv
- (! p (! u (bv_atom (a_var_bv x) x n)
- (holds cln))
- (holds cln)))))
-
-(declare decl_bv_atom_const (! n mpz
- (! v bv
- (! s (^ (bv_len v) n)
- (! p (! w var_bv
- (! u (bv_atom (a_bv v) w n)
- (holds cln)))
- (holds cln))))))
-
-
-; other terms here?
-
-
-; bit blasted terms
-(declare bblt type)
-(declare bbltn bblt)
-(declare bbltc (! f formula (! v bblt bblt)))
-
-; (bblast_term x y) means term x corresponds to bit level interpretation y
-(declare bblast_term (! x (term BitVec) (! y bblt formula)))
-
-; a predicate to represent the n^th bit of a bitvector term
-(declare bblast (! x var_bv (! n mpz formula)))
-
-
-; bit blast constant
-(program bblast_const ((v bv) (n mpz)) bblt
- (mp_ifneg n (match v (bvn bbltn)
- (default (fail bblt)))
- (match v ((bvc b v') (bbltc (match b (b0 false) (b1 true)) (bblast_const v' (mp_add n (~ 1)))))
- (default (fail bblt)))))
-
-(declare bv_bbl_const (! n mpz
- (! v bv
- (! x var_bv
- (! f bblt
- (! u (bv_atom (a_bv v) x n)
- (! c (^ (bblast_const v (mp_add n (~ 1))) f)
- (th_holds (bblast_term (a_bv v) f)))))))))
-
-; bit blast variable
-(program bblast_var ((x var_bv) (n mpz)) bblt
- (mp_ifneg n bbltn
- (bbltc (bblast x n) (bblast_var x (mp_add n (~ 1))))))
-
-(declare bv_bbl_var (! n mpz
- (! x var_bv
- (! f bblt
- (! u (bv_atom (a_var_bv x) x n)
- (! c (^ (bblast_var x (mp_add n (~ 1))) f)
- (th_holds (bblast_term (a_var_bv x) f))))))))
-
-; bit blast x = y
-; for x,y of size n, it will return a conjuction (x.{n-1} = y.{n-1} ^ ( ... ^ (x.0 = y.0 ^ true)))
-(program bblast_eq ((x bblt) (y bblt)) formula
- (match x
- (bbltn (match y (bbltn true) (default (fail formula))))
- ((bbltc fx x') (match y
- (bbltn (fail formula))
- ((bbltc fy y') (and (iff fx fy) (bblast_eq x' y')))))))
-
-(declare bv_bbl_eq (! x (term BitVec)
- (! y (term BitVec)
- (! fx bblt
- (! fy bblt
- (! f formula
- (! ux (th_holds (bblast_term x fx))
- (! uy (th_holds (bblast_term y fy))
- (! c (^ (bblast_eq fx fy) f)
- (th_holds (impl (= BitVec x y) f)))))))))))
-
-
-; rewrite rule :
-; x + y = y + x
-(declare bvadd_symm (! x (term BitVec)
- (! y (term BitVec)
- (! x' var_bv
- (! y' var_bv
- (! n mpz
- (! ux (bv_atom x x' n)
- (! uy (bv_atom y y' n)
- (th_holds (= BitVec (bvadd x y) (bvadd y x)))))))))))
-
-
-
-; necessary?
-(program calc_bvand ((a bv) (b bv)) bv
- (match a
- (bvn (match b (bvn bvn) (default (fail bv))))
- ((bvc ba a') (match b
- ((bvc bb b') (bvc (match ba (b0 b0) (b1 bb)) (calc_bvand a' b')))
- (default (fail bv))))))
-
-; rewrite rule (w constants) :
-; a & b = c
-(declare bvand_const (! c bv
- (! a bv
- (! b bv
- (! u (^ (calc_bvand a b) c)
+; "bitvec" is a term of type "sort" +(declare BitVec sort) + +; bit type +(declare bit type) +(declare b0 bit) +(declare b1 bit) + +; bit vector type +(declare bv type) +(declare bvn bv) +(declare bvc (! b bit (! v bv bv))) +; a bv constant term +(declare a_bv (! v bv (term BitVec))) + +; calculate the length of a bitvector +(program bv_len ((v bv)) mpz + (match v + (bvn 0) + ((bvc b v') (mp_add (bv_len v') 1)))) + +; a bv variable +(declare var_bv type) +; a bv variable term +(declare a_var_bv (! v var_bv (term BitVec))) + + +; bit vector operators +(define bvoper (! x (term BitVec) + (! y (term BitVec) + (term BitVec)))) +(declare bvand bvoper) +(declare bvadd bvoper) +;.... + +; all bit-vector terms are mapped with "bv_atom" to: +; - a simply-typed term of type "var_bv", which is necessary for bit-blasting +; - a integer size +(declare bv_atom (! x (term BitVec) (! y var_bv (! n mpz type)))) + +(declare decl_bv_atom_var (! n mpz ; must be specified + (! x var_bv + (! p (! u (bv_atom (a_var_bv x) x n) + (holds cln)) + (holds cln))))) + +(declare decl_bv_atom_const (! n mpz + (! v bv + (! s (^ (bv_len v) n) + (! p (! w var_bv + (! u (bv_atom (a_bv v) w n) + (holds cln))) + (holds cln)))))) + + +; other terms here? + + +; bit blasted terms +(declare bblt type) +(declare bbltn bblt) +(declare bbltc (! f formula (! v bblt bblt))) + +; (bblast_term x y) means term x corresponds to bit level interpretation y +(declare bblast_term (! x (term BitVec) (! y bblt formula))) + +; a predicate to represent the n^th bit of a bitvector term +(declare bblast (! x var_bv (! n mpz formula))) + + +; bit blast constant +(program bblast_const ((v bv) (n mpz)) bblt + (mp_ifneg n (match v (bvn bbltn) + (default (fail bblt))) + (match v ((bvc b v') (bbltc (match b (b0 false) (b1 true)) (bblast_const v' (mp_add n (~ 1))))) + (default (fail bblt))))) + +(declare bv_bbl_const (! n mpz + (! v bv + (! x var_bv + (! f bblt + (! u (bv_atom (a_bv v) x n) + (! c (^ (bblast_const v (mp_add n (~ 1))) f) + (th_holds (bblast_term (a_bv v) f))))))))) + +; bit blast variable +(program bblast_var ((x var_bv) (n mpz)) bblt + (mp_ifneg n bbltn + (bbltc (bblast x n) (bblast_var x (mp_add n (~ 1)))))) + +(declare bv_bbl_var (! n mpz + (! x var_bv + (! f bblt + (! u (bv_atom (a_var_bv x) x n) + (! c (^ (bblast_var x (mp_add n (~ 1))) f) + (th_holds (bblast_term (a_var_bv x) f)))))))) + +; bit blast x = y +; for x,y of size n, it will return a conjuction (x.{n-1} = y.{n-1} ^ ( ... ^ (x.0 = y.0 ^ true))) +(program bblast_eq ((x bblt) (y bblt)) formula + (match x + (bbltn (match y (bbltn true) (default (fail formula)))) + ((bbltc fx x') (match y + (bbltn (fail formula)) + ((bbltc fy y') (and (iff fx fy) (bblast_eq x' y'))))))) + +(declare bv_bbl_eq (! x (term BitVec) + (! y (term BitVec) + (! fx bblt + (! fy bblt + (! f formula + (! ux (th_holds (bblast_term x fx)) + (! uy (th_holds (bblast_term y fy)) + (! c (^ (bblast_eq fx fy) f) + (th_holds (impl (= BitVec x y) f))))))))))) + + +; rewrite rule : +; x + y = y + x +(declare bvadd_symm (! x (term BitVec) + (! y (term BitVec) + (! x' var_bv + (! y' var_bv + (! n mpz + (! ux (bv_atom x x' n) + (! uy (bv_atom y y' n) + (th_holds (= BitVec (bvadd x y) (bvadd y x))))))))))) + + + +; necessary? +(program calc_bvand ((a bv) (b bv)) bv + (match a + (bvn (match b (bvn bvn) (default (fail bv)))) + ((bvc ba a') (match b + ((bvc bb b') (bvc (match ba (b0 b0) (b1 bb)) (calc_bvand a' b'))) + (default (fail bv)))))) + +; rewrite rule (w constants) : +; a & b = c +(declare bvand_const (! c bv + (! a bv + (! b bv + (! u (^ (calc_bvand a b) c) (th_holds (= BitVec (bvand (a_bv a) (a_bv b)) (a_bv c))))))))
\ No newline at end of file diff --git a/src/theory/quantifiers/conjecture_generator.cpp b/src/theory/quantifiers/conjecture_generator.cpp index 116debb7c..4167c3ad9 100644 --- a/src/theory/quantifiers/conjecture_generator.cpp +++ b/src/theory/quantifiers/conjecture_generator.cpp @@ -1,2180 +1,2180 @@ -/********************* */
-/*! \file conjecture_generator.cpp
- ** \verbatim
- ** Original author: Andrew Reynolds
- ** Major contributors: none
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief conjecture generator class
- **
- **/
-
-#include "theory/quantifiers/conjecture_generator.h"
-#include "theory/theory_engine.h"
-#include "theory/quantifiers/options.h"
-#include "theory/quantifiers/term_database.h"
-#include "theory/quantifiers/trigger.h"
-#include "theory/quantifiers/first_order_model.h"
-
-using namespace CVC4;
-using namespace CVC4::kind;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
-using namespace std;
-
-namespace CVC4 {
-
-struct sortConjectureScore {
- std::vector< int > d_scores;
- bool operator() (unsigned i, unsigned j) { return d_scores[i]>d_scores[j]; }
-};
-
-
-void OpArgIndex::addTerm( ConjectureGenerator * s, TNode n, unsigned index ){
- if( index==n.getNumChildren() ){
- Assert( n.hasOperator() );
- if( std::find( d_ops.begin(), d_ops.end(), n.getOperator() )==d_ops.end() ){
- d_ops.push_back( n.getOperator() );
- d_op_terms.push_back( n );
- }
- }else{
- d_child[s->getTermDatabase()->d_arg_reps[n][index]].addTerm( s, n, index+1 );
- }
-}
-
-Node OpArgIndex::getGroundTerm( ConjectureGenerator * s, std::vector< TNode >& args ) {
- if( d_ops.empty() ){
- for( std::map< TNode, OpArgIndex >::iterator it = d_child.begin(); it != d_child.end(); ++it ){
- std::map< TNode, Node >::iterator itf = s->d_ground_eqc_map.find( it->first );
- if( itf!=s->d_ground_eqc_map.end() ){
- args.push_back( itf->second );
- Node n = it->second.getGroundTerm( s, args );
- args.pop_back();
- if( !n.isNull() ){
- return n;
- }
- }
- }
- return Node::null();
- }else{
- std::vector< TNode > args2;
- args2.push_back( d_ops[0] );
- args2.insert( args2.end(), args.begin(), args.end() );
- return NodeManager::currentNM()->mkNode( d_op_terms[0].getKind(), args2 );
- }
-}
-
-void OpArgIndex::getGroundTerms( ConjectureGenerator * s, std::vector< TNode >& terms ) {
- terms.insert( terms.end(), d_op_terms.begin(), d_op_terms.end() );
- for( std::map< TNode, OpArgIndex >::iterator it = d_child.begin(); it != d_child.end(); ++it ){
- if( s->isGroundEqc( it->first ) ){
- it->second.getGroundTerms( s, terms );
- }
- }
-}
-
-
-
-ConjectureGenerator::ConjectureGenerator( QuantifiersEngine * qe, context::Context* c ) : QuantifiersModule( qe ),
-d_notify( *this ),
-d_uequalityEngine(d_notify, c, "ConjectureGenerator::ee", false),
-d_ee_conjectures( c ){
- d_fullEffortCount = 0;
- d_uequalityEngine.addFunctionKind( kind::APPLY_UF );
- d_uequalityEngine.addFunctionKind( kind::APPLY_CONSTRUCTOR );
-
-}
-
-void ConjectureGenerator::eqNotifyNewClass( TNode t ){
- Trace("thm-ee-debug") << "UEE : new equivalence class " << t << std::endl;
- d_upendingAdds.push_back( t );
-}
-
-void ConjectureGenerator::eqNotifyPreMerge(TNode t1, TNode t2) {
- //get maintained representatives
- TNode rt1 = t1;
- TNode rt2 = t2;
- std::map< Node, EqcInfo* >::iterator it1 = d_eqc_info.find( t1 );
- if( it1!=d_eqc_info.end() && !it1->second->d_rep.get().isNull() ){
- rt1 = it1->second->d_rep.get();
- }
- std::map< Node, EqcInfo* >::iterator it2 = d_eqc_info.find( t2 );
- if( it2!=d_eqc_info.end() && !it2->second->d_rep.get().isNull() ){
- rt2 = it2->second->d_rep.get();
- }
- Trace("thm-ee-debug") << "UEE : equality holds : " << t1 << " == " << t2 << std::endl;
- Trace("thm-ee-debug") << " ureps : " << rt1 << " == " << rt2 << std::endl;
- Trace("thm-ee-debug") << " relevant : " << d_pattern_is_relevant[rt1] << " " << d_pattern_is_relevant[rt2] << std::endl;
- Trace("thm-ee-debug") << " normal : " << d_pattern_is_normal[rt1] << " " << d_pattern_is_normal[rt2] << std::endl;
- Trace("thm-ee-debug") << " size : " << d_pattern_fun_sum[rt1] << " " << d_pattern_fun_sum[rt2] << std::endl;
-
- if( isUniversalLessThan( rt2, rt1 ) ){
- EqcInfo * ei;
- if( it1==d_eqc_info.end() ){
- ei = getOrMakeEqcInfo( t1, true );
- }else{
- ei = it1->second;
- }
- ei->d_rep = t2;
- }
-}
-
-void ConjectureGenerator::eqNotifyPostMerge(TNode t1, TNode t2) {
-
-}
-
-void ConjectureGenerator::eqNotifyDisequal(TNode t1, TNode t2, TNode reason) {
- Trace("thm-ee-debug") << "UEE : disequality holds : " << t1 << " != " << t2 << std::endl;
-
-}
-
-
-ConjectureGenerator::EqcInfo::EqcInfo( context::Context* c ) : d_rep( c, Node::null() ){
-
-}
-
-ConjectureGenerator::EqcInfo* ConjectureGenerator::getOrMakeEqcInfo( TNode n, bool doMake ) {
- //Assert( getUniversalRepresentative( n )==n );
- std::map< Node, EqcInfo* >::iterator eqc_i = d_eqc_info.find( n );
- if( eqc_i!=d_eqc_info.end() ){
- return eqc_i->second;
- }else if( doMake ){
- EqcInfo* ei = new EqcInfo( d_quantEngine->getSatContext() );
- d_eqc_info[n] = ei;
- return ei;
- }else{
- return NULL;
- }
-}
-
-void ConjectureGenerator::setUniversalRelevant( TNode n ) {
- //add pattern information
- registerPattern( n, n.getType() );
- d_urelevant_terms[n] = true;
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- setUniversalRelevant( n[i] );
- }
-}
-
-bool ConjectureGenerator::isUniversalLessThan( TNode rt1, TNode rt2 ) {
- //prefer the one that is (normal, smaller) lexographically
- Assert( d_pattern_is_relevant.find( rt1 )!=d_pattern_is_relevant.end() );
- Assert( d_pattern_is_relevant.find( rt2 )!=d_pattern_is_relevant.end() );
- Assert( d_pattern_is_normal.find( rt1 )!=d_pattern_is_normal.end() );
- Assert( d_pattern_is_normal.find( rt2 )!=d_pattern_is_normal.end() );
- Assert( d_pattern_fun_sum.find( rt1 )!=d_pattern_fun_sum.end() );
- Assert( d_pattern_fun_sum.find( rt2 )!=d_pattern_fun_sum.end() );
-
- if( d_pattern_is_relevant[rt1] && !d_pattern_is_relevant[rt2] ){
- Trace("thm-ee-debug") << "UEE : LT due to relevant." << std::endl;
- return true;
- }else if( d_pattern_is_relevant[rt1]==d_pattern_is_relevant[rt2] ){
- if( d_pattern_is_normal[rt1] && !d_pattern_is_normal[rt2] ){
- Trace("thm-ee-debug") << "UEE : LT due to normal." << std::endl;
- return true;
- }else if( d_pattern_is_normal[rt1]==d_pattern_is_normal[rt2] ){
- if( d_pattern_fun_sum[rt1]<d_pattern_fun_sum[rt2] ){
- Trace("thm-ee-debug") << "UEE : LT due to size." << std::endl;
- //decide which representative to use : based on size of the term
- return true;
- }else if( d_pattern_fun_sum[rt1]==d_pattern_fun_sum[rt2] ){
- //same size : tie goes to term that has already been reported
- return isReportedCanon( rt1 ) && !isReportedCanon( rt2 );
- }
- }
- }
- return false;
-}
-
-
-bool ConjectureGenerator::isReportedCanon( TNode n ) {
- return std::find( d_ue_canon.begin(), d_ue_canon.end(), n )==d_ue_canon.end();
-}
-
-void ConjectureGenerator::markReportedCanon( TNode n ) {
- if( !isReportedCanon( n ) ){
- d_ue_canon.push_back( n );
- }
-}
-
-bool ConjectureGenerator::areUniversalEqual( TNode n1, TNode n2 ) {
- return n1==n2 || ( d_uequalityEngine.hasTerm( n1 ) && d_uequalityEngine.hasTerm( n2 ) && d_uequalityEngine.areEqual( n1, n2 ) );
-}
-
-bool ConjectureGenerator::areUniversalDisequal( TNode n1, TNode n2 ) {
- return n1!=n2 && d_uequalityEngine.hasTerm( n1 ) && d_uequalityEngine.hasTerm( n2 ) && d_uequalityEngine.areDisequal( n1, n2, false );
-}
-
-TNode ConjectureGenerator::getUniversalRepresentative( TNode n, bool add ) {
- if( add ){
- if( d_urelevant_terms.find( n )==d_urelevant_terms.end() ){
- setUniversalRelevant( n );
- //add term to universal equality engine
- d_uequalityEngine.addTerm( n );
- // addding this term to equality engine will lead to a set of new terms (the new subterms of n)
- // now, do instantiation-based merging for each of these terms
- Trace("thm-ee-debug") << "Merge equivalence classes based on instantiations of terms..." << std::endl;
- //merge all pending equalities
- while( !d_upendingAdds.empty() ){
- Trace("sg-pending") << "Add " << d_upendingAdds.size() << " pending terms..." << std::endl;
- std::vector< Node > pending;
- pending.insert( pending.end(), d_upendingAdds.begin(), d_upendingAdds.end() );
- d_upendingAdds.clear();
- for( unsigned i=0; i<pending.size(); i++ ){
- Node t = pending[i];
- TypeNode tn = t.getType();
- Trace("thm-ee-add") << "UEE : Add universal term " << t << std::endl;
- std::vector< Node > eq_terms;
- //if occurs modulo equality at ground level, it is equivalent to representative of ground equality engine
- TNode gt = getTermDatabase()->evaluateTerm( t );
- if( !gt.isNull() && gt!=t ){
- eq_terms.push_back( gt );
- }
- //get all equivalent terms based on theorem database
- d_thm_index.getEquivalentTerms( t, eq_terms );
- if( !eq_terms.empty() ){
- Trace("thm-ee-add") << "UEE : Based on ground EE/theorem DB, it is equivalent to " << eq_terms.size() << " terms : " << std::endl;
- //add equivalent terms as equalities to universal engine
- for( unsigned i=0; i<eq_terms.size(); i++ ){
- Trace("thm-ee-add") << " " << eq_terms[i] << std::endl;
- bool assertEq = false;
- if( d_urelevant_terms.find( eq_terms[i] )!=d_urelevant_terms.end() ){
- assertEq = true;
- }else{
- Assert( eq_terms[i].getType()==tn );
- registerPattern( eq_terms[i], tn );
- if( isUniversalLessThan( eq_terms[i], t ) || ( options::conjectureUeeIntro() && d_pattern_fun_sum[t]>=d_pattern_fun_sum[eq_terms[i]] ) ){
- setUniversalRelevant( eq_terms[i] );
- assertEq = true;
- }
- }
- if( assertEq ){
- Node exp;
- d_uequalityEngine.assertEquality( t.eqNode( eq_terms[i] ), true, exp );
- }else{
- Trace("thm-ee-no-add") << "Do not add : " << t << " == " << eq_terms[i] << std::endl;
- }
- }
- }else{
- Trace("thm-ee-add") << "UEE : No equivalent terms." << std::endl;
- }
- }
- }
- }
- }
-
- if( d_uequalityEngine.hasTerm( n ) ){
- Node r = d_uequalityEngine.getRepresentative( n );
- EqcInfo * ei = getOrMakeEqcInfo( r );
- if( ei && !ei->d_rep.get().isNull() ){
- return ei->d_rep.get();
- }else{
- return r;
- }
- }else{
- return n;
- }
-}
-
-Node ConjectureGenerator::getFreeVar( TypeNode tn, unsigned i ) {
- Assert( !tn.isNull() );
- while( d_free_var[tn].size()<=i ){
- std::stringstream oss;
- oss << tn;
- std::string typ_name = oss.str();
- while( typ_name[0]=='(' ){
- typ_name.erase( typ_name.begin() );
- }
- std::stringstream os;
- os << typ_name[0] << i;
- Node x = NodeManager::currentNM()->mkBoundVar( os.str().c_str(), tn );
- d_free_var_num[x] = d_free_var[tn].size();
- d_free_var[tn].push_back( x );
- }
- return d_free_var[tn][i];
-}
-
-
-
-Node ConjectureGenerator::getCanonicalTerm( TNode n, std::map< TypeNode, unsigned >& var_count, std::map< TNode, TNode >& subs ) {
- if( n.getKind()==BOUND_VARIABLE ){
- std::map< TNode, TNode >::iterator it = subs.find( n );
- if( it==subs.end() ){
- TypeNode tn = n.getType();
- //allocate variable
- unsigned vn = var_count[tn];
- var_count[tn]++;
- subs[n] = getFreeVar( tn, vn );
- return subs[n];
- }else{
- return it->second;
- }
- }else{
- std::vector< Node > children;
- if( n.getKind()!=EQUAL ){
- if( n.hasOperator() ){
- TNode op = n.getOperator();
- if( !d_tge.isRelevantFunc( op ) ){
- return Node::null();
- }
- children.push_back( op );
- }else{
- return Node::null();
- }
- }
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- Node cn = getCanonicalTerm( n[i], var_count, subs );
- if( cn.isNull() ){
- return Node::null();
- }else{
- children.push_back( cn );
- }
- }
- return NodeManager::currentNM()->mkNode( n.getKind(), children );
- }
-}
-
-bool ConjectureGenerator::isHandledTerm( TNode n ){
- return !n.getAttribute(NoMatchAttribute()) && inst::Trigger::isAtomicTrigger( n ) && ( n.getKind()!=APPLY_UF || n.getOperator().getKind()!=SKOLEM );
-}
-
-Node ConjectureGenerator::getGroundEqc( TNode r ) {
- std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r );
- return it!=d_ground_eqc_map.end() ? it->second : Node::null();
-}
-
-bool ConjectureGenerator::isGroundEqc( TNode r ) {
- return d_ground_eqc_map.find( r )!=d_ground_eqc_map.end();
-}
-
-bool ConjectureGenerator::isGroundTerm( TNode n ) {
- return std::find( d_ground_terms.begin(), d_ground_terms.end(), n )!=d_ground_terms.end();
-}
-
-bool ConjectureGenerator::needsCheck( Theory::Effort e ) {
- // synchonized with instantiation engine
- return d_quantEngine->getInstWhenNeedsCheck( e );
-}
-
-bool ConjectureGenerator::hasEnumeratedUf( Node n ) {
- if( options::conjectureGenGtEnum()>0 ){
- std::map< Node, bool >::iterator it = d_uf_enum.find( n.getOperator() );
- if( it==d_uf_enum.end() ){
- d_uf_enum[n.getOperator()] = true;
- std::vector< Node > lem;
- getEnumeratePredUfTerm( n, options::conjectureGenGtEnum(), lem );
- if( !lem.empty() ){
- for( unsigned j=0; j<lem.size(); j++ ){
- d_quantEngine->addLemma( lem[j], false );
- d_hasAddedLemma = true;
- }
- return false;
- }
- }
- }
- return true;
-}
-
-void ConjectureGenerator::reset_round( Theory::Effort e ) {
-
-}
-
-void ConjectureGenerator::check( Theory::Effort e, unsigned quant_e ) {
- if( quant_e==QuantifiersEngine::QEFFORT_STANDARD ){
- d_fullEffortCount++;
- if( d_fullEffortCount%optFullCheckFrequency()==0 ){
- d_hasAddedLemma = false;
- d_tge.d_cg = this;
- double clSet = 0;
- if( Trace.isOn("sg-engine") ){
- clSet = double(clock())/double(CLOCKS_PER_SEC);
- Trace("sg-engine") << "---Conjecture Engine Round, effort = " << e << "---" << std::endl;
- }
- eq::EqualityEngine * ee = getEqualityEngine();
- d_conj_count = 0;
-
- Trace("sg-proc") << "Get eq classes..." << std::endl;
- d_op_arg_index.clear();
- d_ground_eqc_map.clear();
- d_bool_eqc[0] = Node::null();
- d_bool_eqc[1] = Node::null();
- std::vector< TNode > eqcs;
- d_em.clear();
- eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( ee );
- while( !eqcs_i.isFinished() ){
- TNode r = (*eqcs_i);
- eqcs.push_back( r );
- if( r.getType().isBoolean() ){
- if( areEqual( r, getTermDatabase()->d_true ) ){
- d_ground_eqc_map[r] = getTermDatabase()->d_true;
- d_bool_eqc[0] = r;
- }else if( areEqual( r, getTermDatabase()->d_false ) ){
- d_ground_eqc_map[r] = getTermDatabase()->d_false;
- d_bool_eqc[1] = r;
- }
- }
- d_em[r] = eqcs.size();
- eq::EqClassIterator ieqc_i = eq::EqClassIterator( r, ee );
- while( !ieqc_i.isFinished() ){
- TNode n = (*ieqc_i);
- if( getTermDatabase()->hasTermCurrent( n ) ){
- if( isHandledTerm( n ) ){
- d_op_arg_index[r].addTerm( this, n );
- }
- }
- ++ieqc_i;
- }
- ++eqcs_i;
- }
- Assert( !d_bool_eqc[0].isNull() );
- Assert( !d_bool_eqc[1].isNull() );
- d_urelevant_terms.clear();
- Trace("sg-proc") << "...done get eq classes" << std::endl;
-
- Trace("sg-proc") << "Determine ground EQC..." << std::endl;
- bool success;
- do{
- success = false;
- for( unsigned i=0; i<eqcs.size(); i++ ){
- TNode r = eqcs[i];
- if( d_ground_eqc_map.find( r )==d_ground_eqc_map.end() ){
- std::vector< TNode > args;
- Trace("sg-pat-debug") << "******* Get ground term for " << r << std::endl;
- Node n;
- if( getTermDatabase()->isInductionTerm( r ) ){
- n = d_op_arg_index[r].getGroundTerm( this, args );
- }else{
- n = r;
- }
- if( !n.isNull() ){
- Trace("sg-pat") << "Ground term for eqc " << r << " : " << std::endl;
- Trace("sg-pat") << " " << n << std::endl;
- d_ground_eqc_map[r] = n;
- success = true;
- }else{
- Trace("sg-pat-debug") << "...could not find ground term." << std::endl;
- }
- }
- }
- }while( success );
- //also get ground terms
- d_ground_terms.clear();
- for( unsigned i=0; i<eqcs.size(); i++ ){
- TNode r = eqcs[i];
- d_op_arg_index[r].getGroundTerms( this, d_ground_terms );
- }
- Trace("sg-proc") << "...done determine ground EQC" << std::endl;
-
- //debug printing
- if( Trace.isOn("sg-gen-eqc") ){
- for( unsigned i=0; i<eqcs.size(); i++ ){
- TNode r = eqcs[i];
- //print out members
- bool firstTime = true;
- bool isFalse = areEqual( r, getTermDatabase()->d_false );
- eq::EqClassIterator eqc_i = eq::EqClassIterator( r, ee );
- while( !eqc_i.isFinished() ){
- TNode n = (*eqc_i);
- if( getTermDatabase()->hasTermCurrent( n ) && !n.getAttribute(NoMatchAttribute()) && ( n.getKind()!=EQUAL || isFalse ) ){
- if( firstTime ){
- Trace("sg-gen-eqc") << "e" << d_em[r] << " : { " << std::endl;
- firstTime = false;
- }
- if( n.hasOperator() ){
- Trace("sg-gen-eqc") << " (" << n.getOperator();
- getTermDatabase()->computeArgReps( n );
- for( unsigned i=0; i<getTermDatabase()->d_arg_reps[n].size(); i++ ){
- Trace("sg-gen-eqc") << " e" << d_em[getTermDatabase()->d_arg_reps[n][i]];
- }
- Trace("sg-gen-eqc") << ") :: " << n << std::endl;
- }else{
- Trace("sg-gen-eqc") << " " << n << std::endl;
- }
- }
- ++eqc_i;
- }
- if( !firstTime ){
- Trace("sg-gen-eqc") << "}" << std::endl;
- //print out ground term
- std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r );
- if( it!=d_ground_eqc_map.end() ){
- Trace("sg-gen-eqc") << "- Ground term : " << it->second << std::endl;
- }
- }
- }
- }
-
- Trace("sg-proc") << "Compute relevant eqc..." << std::endl;
- d_tge.d_relevant_eqc[0].clear();
- d_tge.d_relevant_eqc[1].clear();
- for( unsigned i=0; i<eqcs.size(); i++ ){
- TNode r = eqcs[i];
- std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r );
- unsigned index = 1;
- if( it==d_ground_eqc_map.end() ){
- index = 0;
- }
- //based on unproven conjectures? TODO
- d_tge.d_relevant_eqc[index].push_back( r );
- }
- Trace("sg-gen-tg-debug") << "Initial relevant eqc : ";
- for( unsigned i=0; i<d_tge.d_relevant_eqc[0].size(); i++ ){
- Trace("sg-gen-tg-debug") << "e" << d_em[d_tge.d_relevant_eqc[0][i]] << " ";
- }
- Trace("sg-gen-tg-debug") << std::endl;
- Trace("sg-proc") << "...done compute relevant eqc" << std::endl;
-
-
- Trace("sg-proc") << "Collect signature information..." << std::endl;
- d_tge.collectSignatureInformation();
- if( d_hasAddedLemma ){
- Trace("sg-proc") << "...added enumeration lemmas." << std::endl;
- }
- Trace("sg-proc") << "...done collect signature information" << std::endl;
-
-
-
- Trace("sg-proc") << "Build theorem index..." << std::endl;
- d_ue_canon.clear();
- d_thm_index.clear();
- std::vector< Node > provenConj;
- quantifiers::FirstOrderModel* m = d_quantEngine->getModel();
- for( int i=0; i<m->getNumAssertedQuantifiers(); i++ ){
- Node q = m->getAssertedQuantifier( i );
- Trace("thm-db-debug") << "Is " << q << " a relevant theorem?" << std::endl;
- Node conjEq;
- if( q[1].getKind()==EQUAL ){
- bool isSubsume = false;
- bool inEe = false;
- for( unsigned r=0; r<2; r++ ){
- TNode nl = q[1][r==0 ? 0 : 1];
- TNode nr = q[1][r==0 ? 1 : 0];
- Node eq = nl.eqNode( nr );
- if( r==1 || std::find( d_conjectures.begin(), d_conjectures.end(), q )==d_conjectures.end() ){
- //must make it canonical
- std::map< TypeNode, unsigned > var_count;
- std::map< TNode, TNode > subs;
- Trace("sg-proc-debug") << "get canonical " << eq << std::endl;
- eq = getCanonicalTerm( eq, var_count, subs );
- }
- if( !eq.isNull() ){
- if( r==0 ){
- inEe = d_ee_conjectures.find( q[1] )!=d_ee_conjectures.end();
- if( !inEe ){
- //add to universal equality engine
- Node nl = getUniversalRepresentative( eq[0], true );
- Node nr = getUniversalRepresentative( eq[1], true );
- if( areUniversalEqual( nl, nr ) ){
- isSubsume = true;
- //set inactive (will be ignored by other modules)
- d_quantEngine->getModel()->setQuantifierActive( q, false );
- }else{
- Node exp;
- d_ee_conjectures[q[1]] = true;
- d_uequalityEngine.assertEquality( nl.eqNode( nr ), true, exp );
- }
- }
- Trace("sg-conjecture") << "*** CONJECTURE : currently proven" << (isSubsume ? " and subsumed" : "");
- Trace("sg-conjecture") << " : " << q[1] << std::endl;
- provenConj.push_back( q );
- }
- if( !isSubsume ){
- Trace("thm-db-debug") << "Adding theorem to database " << eq[0] << " == " << eq[1] << std::endl;
- d_thm_index.addTheorem( eq[0], eq[1] );
- }else{
- break;
- }
- }else{
- break;
- }
- }
- }
- }
- //examine status of other conjectures
- for( unsigned i=0; i<d_conjectures.size(); i++ ){
- Node q = d_conjectures[i];
- if( std::find( provenConj.begin(), provenConj.end(), q )==provenConj.end() ){
- //check each skolem variable
- bool disproven = true;
- //std::vector< Node > sk;
- //getTermDatabase()->getSkolemConstants( q, sk, true );
- Trace("sg-conjecture") << " CONJECTURE : ";
- std::vector< Node > ce;
- for( unsigned j=0; j<getTermDatabase()->d_skolem_constants[q].size(); j++ ){
- TNode k = getTermDatabase()->d_skolem_constants[q][j];
- TNode rk = getRepresentative( k );
- std::map< TNode, Node >::iterator git = d_ground_eqc_map.find( rk );
- //check if it is a ground term
- if( git==d_ground_eqc_map.end() ){
- Trace("sg-conjecture") << "ACTIVE : " << q;
- if( Trace.isOn("sg-gen-eqc") ){
- Trace("sg-conjecture") << " { ";
- for( unsigned k=0; k<getTermDatabase()->d_skolem_constants[q].size(); k++ ){ Trace("sg-conjecture") << getTermDatabase()->d_skolem_constants[q][k] << ( j==k ? "*" : "" ) << " "; }
- Trace("sg-conjecture") << "}";
- }
- Trace("sg-conjecture") << std::endl;
- disproven = false;
- break;
- }else{
- ce.push_back( git->second );
- }
- }
- if( disproven ){
- Trace("sg-conjecture") << "disproven : " << q << " : ";
- for( unsigned i=0; i<ce.size(); i++ ){
- Trace("sg-conjecture") << q[0][i] << " -> " << ce[i] << " ";
- }
- Trace("sg-conjecture") << std::endl;
- }
- }
- }
- Trace("thm-db") << "Theorem database is : " << std::endl;
- d_thm_index.debugPrint( "thm-db" );
- Trace("thm-db") << std::endl;
- Trace("sg-proc") << "...done build theorem index" << std::endl;
-
-
- //clear patterns
- d_patterns.clear();
- d_pattern_var_id.clear();
- d_pattern_var_duplicate.clear();
- d_pattern_is_normal.clear();
- d_pattern_is_relevant.clear();
- d_pattern_fun_id.clear();
- d_pattern_fun_sum.clear();
- d_rel_patterns.clear();
- d_rel_pattern_var_sum.clear();
- d_rel_pattern_typ_index.clear();
- d_rel_pattern_subs_index.clear();
-
- unsigned rel_term_count = 0;
- std::map< TypeNode, unsigned > rt_var_max;
- std::vector< TypeNode > rt_types;
- std::map< TypeNode, std::map< int, std::vector< Node > > > conj_lhs;
- unsigned addedLemmas = 0;
- for( unsigned depth=1; depth<=3; depth++ ){
- Trace("sg-proc") << "Generate relevant LHS at depth " << depth << "..." << std::endl;
- Trace("sg-rel-term") << "Relevant terms of depth " << depth << " : " << std::endl;
- //set up environment
- d_tge.d_var_id.clear();
- d_tge.d_var_limit.clear();
- d_tge.reset( depth, true, TypeNode::null() );
- while( d_tge.getNextTerm() ){
- //construct term
- Node nn = d_tge.getTerm();
- if( !options::conjectureFilterCanonical() || considerTermCanon( nn, true ) ){
- rel_term_count++;
- Trace("sg-rel-term") << "*** Relevant term : ";
- d_tge.debugPrint( "sg-rel-term", "sg-rel-term-debug2" );
- Trace("sg-rel-term") << std::endl;
-
- for( unsigned r=0; r<2; r++ ){
- Trace("sg-rel-term-debug") << "...from equivalence classes (" << r << ") : ";
- int index = d_tge.d_ccand_eqc[r].size()-1;
- for( unsigned j=0; j<d_tge.d_ccand_eqc[r][index].size(); j++ ){
- Trace("sg-rel-term-debug") << "e" << d_em[d_tge.d_ccand_eqc[r][index][j]] << " ";
- }
- Trace("sg-rel-term-debug") << std::endl;
- }
- TypeNode tnn = nn.getType();
- Trace("sg-gen-tg-debug") << "...term is " << nn << std::endl;
- conj_lhs[tnn][depth].push_back( nn );
-
- //add information about pattern
- Trace("sg-gen-tg-debug") << "Collect pattern information..." << std::endl;
- Assert( std::find( d_rel_patterns[tnn].begin(), d_rel_patterns[tnn].end(), nn )==d_rel_patterns[tnn].end() );
- d_rel_patterns[tnn].push_back( nn );
- //build information concerning the variables in this pattern
- unsigned sum = 0;
- std::map< TypeNode, unsigned > typ_to_subs_index;
- std::vector< TNode > gsubs_vars;
- for( std::map< TypeNode, unsigned >::iterator it = d_tge.d_var_id.begin(); it != d_tge.d_var_id.end(); ++it ){
- if( it->second>0 ){
- typ_to_subs_index[it->first] = sum;
- sum += it->second;
- for( unsigned i=0; i<it->second; i++ ){
- gsubs_vars.push_back( getFreeVar( it->first, i ) );
- }
- }
- }
- d_rel_pattern_var_sum[nn] = sum;
- //register the pattern
- registerPattern( nn, tnn );
- Assert( d_pattern_is_normal[nn] );
- Trace("sg-gen-tg-debug") << "...done collect pattern information" << std::endl;
-
- //record information about types
- Trace("sg-gen-tg-debug") << "Collect type information..." << std::endl;
- PatternTypIndex * pti = &d_rel_pattern_typ_index;
- for( std::map< TypeNode, unsigned >::iterator it = d_tge.d_var_id.begin(); it != d_tge.d_var_id.end(); ++it ){
- pti = &pti->d_children[it->first][it->second];
- //record maximum
- if( rt_var_max.find( it->first )==rt_var_max.end() || it->second>rt_var_max[it->first] ){
- rt_var_max[it->first] = it->second;
- }
- }
- if( std::find( rt_types.begin(), rt_types.end(), tnn )==rt_types.end() ){
- rt_types.push_back( tnn );
- }
- pti->d_terms.push_back( nn );
- Trace("sg-gen-tg-debug") << "...done collect type information" << std::endl;
-
- Trace("sg-gen-tg-debug") << "Build substitutions for ground EQC..." << std::endl;
- std::vector< TNode > gsubs_terms;
- gsubs_terms.resize( gsubs_vars.size() );
- int index = d_tge.d_ccand_eqc[1].size()-1;
- for( unsigned j=0; j<d_tge.d_ccand_eqc[1][index].size(); j++ ){
- TNode r = d_tge.d_ccand_eqc[1][index][j];
- Trace("sg-rel-term-debug") << " Matches for e" << d_em[r] << ", which is ground term " << d_ground_eqc_map[r] << ":" << std::endl;
- std::map< TypeNode, std::map< unsigned, TNode > > subs;
- std::map< TNode, bool > rev_subs;
- //only get ground terms
- unsigned mode = 2;
- d_tge.resetMatching( r, mode );
- while( d_tge.getNextMatch( r, subs, rev_subs ) ){
- //we will be building substitutions
- bool firstTime = true;
- for( std::map< TypeNode, std::map< unsigned, TNode > >::iterator it = subs.begin(); it != subs.end(); ++it ){
- unsigned tindex = typ_to_subs_index[it->first];
- for( std::map< unsigned, TNode >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){
- if( !firstTime ){
- Trace("sg-rel-term-debug") << ", ";
- }else{
- firstTime = false;
- Trace("sg-rel-term-debug") << " ";
- }
- Trace("sg-rel-term-debug") << it->first << ":x" << it2->first << " -> " << it2->second;
- Assert( tindex+it2->first<gsubs_terms.size() );
- gsubs_terms[tindex+it2->first] = it2->second;
- }
- }
- Trace("sg-rel-term-debug") << std::endl;
- d_rel_pattern_subs_index[nn].addSubstitution( r, gsubs_vars, gsubs_terms );
- }
- }
- Trace("sg-gen-tg-debug") << "...done build substitutions for ground EQC" << std::endl;
- }else{
- Trace("sg-gen-tg-debug") << "> not canonical : " << nn << std::endl;
- }
- }
- Trace("sg-proc") << "...done generate terms at depth " << depth << std::endl;
- Trace("sg-stats") << "--------> Total LHS of depth " << depth << " : " << rel_term_count << std::endl;
- //Trace("conjecture-count") << "Total LHS of depth " << depth << " : " << conj_lhs[depth].size() << std::endl;
-
- /* test...
- for( unsigned i=0; i<rt_types.size(); i++ ){
- Trace("sg-term-enum") << "Term enumeration for " << rt_types[i] << " : " << std::endl;
- Trace("sg-term-enum") << "Ground term : " << rt_types[i].mkGroundTerm() << std::endl;
- for( unsigned j=0; j<150; j++ ){
- Trace("sg-term-enum") << " " << getEnumerateTerm( rt_types[i], j ) << std::endl;
- }
- }
- */
-
- //consider types from relevant terms
- for( unsigned rdepth=0; rdepth<=depth; rdepth++ ){
- //set up environment
- d_tge.d_var_id.clear();
- d_tge.d_var_limit.clear();
- for( std::map< TypeNode, unsigned >::iterator it = rt_var_max.begin(); it != rt_var_max.end(); ++it ){
- d_tge.d_var_id[ it->first ] = it->second;
- d_tge.d_var_limit[ it->first ] = it->second;
- }
- std::random_shuffle( rt_types.begin(), rt_types.end() );
- std::map< TypeNode, std::vector< Node > > conj_rhs;
- for( unsigned i=0; i<rt_types.size(); i++ ){
-
- Trace("sg-proc") << "Generate relevant RHS terms of type " << rt_types[i] << " at depth " << rdepth << "..." << std::endl;
- d_tge.reset( rdepth, false, rt_types[i] );
-
- while( d_tge.getNextTerm() ){
- Node rhs = d_tge.getTerm();
- if( considerTermCanon( rhs, false ) ){
- Trace("sg-rel-prop") << "Relevant RHS : " << rhs << std::endl;
- //register pattern
- Assert( rhs.getType()==rt_types[i] );
- registerPattern( rhs, rt_types[i] );
- if( rdepth<depth ){
- //consider against all LHS at depth
- for( unsigned j=0; j<conj_lhs[rt_types[i]][depth].size(); j++ ){
- processCandidateConjecture( conj_lhs[rt_types[i]][depth][j], rhs, depth, rdepth );
- }
- }else{
- conj_rhs[rt_types[i]].push_back( rhs );
- }
- }
- }
- }
- flushWaitingConjectures( addedLemmas, depth, rdepth );
- //consider against all LHS up to depth
- if( rdepth==depth ){
- for( unsigned lhs_depth = 1; lhs_depth<=depth; lhs_depth++ ){
- if( (int)addedLemmas<options::conjectureGenPerRound() ){
- Trace("sg-proc") << "Consider conjectures at depth (" << lhs_depth << ", " << rdepth << ")..." << std::endl;
- for( std::map< TypeNode, std::vector< Node > >::iterator it = conj_rhs.begin(); it != conj_rhs.end(); ++it ){
- for( unsigned j=0; j<it->second.size(); j++ ){
- for( unsigned k=0; k<conj_lhs[it->first][lhs_depth].size(); k++ ){
- processCandidateConjecture( conj_lhs[it->first][lhs_depth][k], it->second[j], lhs_depth, rdepth );
- }
- }
- }
- flushWaitingConjectures( addedLemmas, lhs_depth, depth );
- }
- }
- }
- if( (int)addedLemmas>=options::conjectureGenPerRound() ){
- break;
- }
- }
- if( (int)addedLemmas>=options::conjectureGenPerRound() ){
- break;
- }
- }
- Trace("sg-stats") << "Total conjectures considered : " << d_conj_count << std::endl;
- if( Trace.isOn("thm-ee") ){
- Trace("thm-ee") << "Universal equality engine is : " << std::endl;
- eq::EqClassesIterator ueqcs_i = eq::EqClassesIterator( &d_uequalityEngine );
- while( !ueqcs_i.isFinished() ){
- TNode r = (*ueqcs_i);
- bool firstTime = true;
- TNode rr = getUniversalRepresentative( r );
- Trace("thm-ee") << " " << rr;
- Trace("thm-ee") << " : { ";
- eq::EqClassIterator ueqc_i = eq::EqClassIterator( r, &d_uequalityEngine );
- while( !ueqc_i.isFinished() ){
- TNode n = (*ueqc_i);
- if( rr!=n ){
- if( firstTime ){
- Trace("thm-ee") << std::endl;
- firstTime = false;
- }
- Trace("thm-ee") << " " << n << std::endl;
- }
- ++ueqc_i;
- }
- if( !firstTime ){ Trace("thm-ee") << " "; }
- Trace("thm-ee") << "}" << std::endl;
- ++ueqcs_i;
- }
- Trace("thm-ee") << std::endl;
- }
- if( Trace.isOn("sg-engine") ){
- double clSet2 = double(clock())/double(CLOCKS_PER_SEC);
- Trace("sg-engine") << "Finished conjecture generator, time = " << (clSet2-clSet) << std::endl;
- }
- }
- }
-}
-
-unsigned ConjectureGenerator::flushWaitingConjectures( unsigned& addedLemmas, int ldepth, int rdepth ) {
- if( !d_waiting_conjectures_lhs.empty() ){
- Trace("sg-proc") << "Generated " << d_waiting_conjectures_lhs.size() << " conjectures at depth " << ldepth << "/" << rdepth << "." << std::endl;
- if( (int)addedLemmas<options::conjectureGenPerRound() ){
- /*
- std::vector< unsigned > indices;
- for( unsigned i=0; i<d_waiting_conjectures_lhs.size(); i++ ){
- indices.push_back( i );
- }
- bool doSort = false;
- if( doSort ){
- //sort them based on score
- sortConjectureScore scs;
- scs.d_scores.insert( scs.d_scores.begin(), d_waiting_conjectures_score.begin(), d_waiting_conjectures_score.end() );
- std::sort( indices.begin(), indices.end(), scs );
- }
- //if( doSort && d_waiting_conjectures_score[indices[0]]<optFilterScoreThreshold() ){
- */
- unsigned prevCount = d_conj_count;
- for( unsigned i=0; i<d_waiting_conjectures_lhs.size(); i++ ){
- if( d_waiting_conjectures_score[i]>=optFilterScoreThreshold() ){
- //we have determined a relevant subgoal
- Node lhs = d_waiting_conjectures_lhs[i];
- Node rhs = d_waiting_conjectures_rhs[i];
- if( options::conjectureFilterCanonical() && ( getUniversalRepresentative( lhs )!=lhs || getUniversalRepresentative( rhs )!=rhs ) ){
- //skip
- }else{
- Trace("sg-engine") << "*** Consider conjecture : " << lhs << " == " << rhs << std::endl;
- Trace("sg-engine-debug") << " score : " << d_waiting_conjectures_score[i] << std::endl;
- if( optStatsOnly() ){
- d_conj_count++;
- }else{
- std::vector< Node > bvs;
- for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[lhs].begin(); it != d_pattern_var_id[lhs].end(); ++it ){
- for( unsigned i=0; i<=it->second; i++ ){
- bvs.push_back( getFreeVar( it->first, i ) );
- }
- }
- Node rsg;
- if( !bvs.empty() ){
- Node bvl = NodeManager::currentNM()->mkNode( BOUND_VAR_LIST, bvs );
- rsg = NodeManager::currentNM()->mkNode( FORALL, bvl, lhs.eqNode( rhs ) );
- }else{
- rsg = lhs.eqNode( rhs );
- }
- rsg = Rewriter::rewrite( rsg );
- d_conjectures.push_back( rsg );
- d_eq_conjectures[lhs].push_back( rhs );
- d_eq_conjectures[rhs].push_back( lhs );
-
- Node lem = NodeManager::currentNM()->mkNode( OR, rsg.negate(), rsg );
- d_quantEngine->addLemma( lem, false );
- d_quantEngine->addRequirePhase( rsg, false );
- addedLemmas++;
- if( (int)addedLemmas>=options::conjectureGenPerRound() ){
- break;
- }
- }
- }
- }
- }
- Trace("sg-proc") << "...have now added " << addedLemmas << " conjecture lemmas." << std::endl;
- if( optStatsOnly() ){
- Trace("sg-stats") << "Generated " << (d_conj_count-prevCount) << " conjectures at depth " << ldepth << "/" << rdepth << "." << std::endl;
- }
- }
- d_waiting_conjectures_lhs.clear();
- d_waiting_conjectures_rhs.clear();
- d_waiting_conjectures_score.clear();
- d_waiting_conjectures.clear();
- }
- return addedLemmas;
-}
-
-void ConjectureGenerator::registerQuantifier( Node q ) {
-
-}
-
-void ConjectureGenerator::assertNode( Node n ) {
-
-}
-
-bool ConjectureGenerator::considerTermCanon( Node ln, bool genRelevant ){
- if( !ln.isNull() ){
- //do not consider if it is non-canonical, and either:
- // (1) we are not generating relevant terms, or
- // (2) its canonical form is a generalization.
- TNode lnr = getUniversalRepresentative( ln, true );
- if( lnr==ln ){
- markReportedCanon( ln );
- }else if( !genRelevant || isGeneralization( lnr, ln ) ){
- Trace("sg-gen-consider-term") << "Do not consider term, " << ln << " is not canonical representation (which is " << lnr << ")." << std::endl;
- return false;
- }
- }
- Trace("sg-gen-tg-debug") << "Will consider term canon " << ln << std::endl;
- Trace("sg-gen-consider-term-debug") << std::endl;
- return true;
-}
-
-unsigned ConjectureGenerator::collectFunctions( TNode opat, TNode pat, std::map< TNode, unsigned >& funcs,
- std::map< TypeNode, unsigned >& mnvn, std::map< TypeNode, unsigned >& mxvn ){
- if( pat.hasOperator() ){
- funcs[pat.getOperator()]++;
- if( !d_tge.isRelevantFunc( pat.getOperator() ) ){
- d_pattern_is_relevant[opat] = false;
- }
- unsigned sum = 1;
- for( unsigned i=0; i<pat.getNumChildren(); i++ ){
- sum += collectFunctions( opat, pat[i], funcs, mnvn, mxvn );
- }
- return sum;
- }else{
- Assert( pat.getNumChildren()==0 );
- funcs[pat]++;
- //for variables
- if( pat.getKind()==BOUND_VARIABLE ){
- if( funcs[pat]>1 ){
- //duplicate variable
- d_pattern_var_duplicate[opat]++;
- }else{
- //check for max/min
- TypeNode tn = pat.getType();
- unsigned vn = d_free_var_num[pat];
- std::map< TypeNode, unsigned >::iterator it = mnvn.find( tn );
- if( it!=mnvn.end() ){
- if( vn<it->second ){
- d_pattern_is_normal[opat] = false;
- mnvn[tn] = vn;
- }else if( vn>mxvn[tn] ){
- if( vn!=mxvn[tn]+1 ){
- d_pattern_is_normal[opat] = false;
- }
- mxvn[tn] = vn;
- }
- }else{
- //first variable of this type
- mnvn[tn] = vn;
- mxvn[tn] = vn;
- }
- }
- }else{
- d_pattern_is_relevant[opat] = false;
- }
- return 1;
- }
-}
-
-void ConjectureGenerator::registerPattern( Node pat, TypeNode tpat ) {
- if( std::find( d_patterns[tpat].begin(), d_patterns[tpat].end(), pat )==d_patterns[tpat].end() ){
- d_patterns[TypeNode::null()].push_back( pat );
- d_patterns[tpat].push_back( pat );
-
- Assert( d_pattern_fun_id.find( pat )==d_pattern_fun_id.end() );
- Assert( d_pattern_var_id.find( pat )==d_pattern_var_id.end() );
-
- //collect functions
- std::map< TypeNode, unsigned > mnvn;
- d_pattern_fun_sum[pat] = collectFunctions( pat, pat, d_pattern_fun_id[pat], mnvn, d_pattern_var_id[pat] );
- if( d_pattern_is_normal.find( pat )==d_pattern_is_normal.end() ){
- d_pattern_is_normal[pat] = true;
- }
- if( d_pattern_is_relevant.find( pat )==d_pattern_is_relevant.end() ){
- d_pattern_is_relevant[pat] = true;
- }
- }
-}
-
-bool ConjectureGenerator::isGeneralization( TNode patg, TNode pat, std::map< TNode, TNode >& subs ) {
- if( patg.getKind()==BOUND_VARIABLE ){
- std::map< TNode, TNode >::iterator it = subs.find( patg );
- if( it!=subs.end() ){
- return it->second==pat;
- }else{
- subs[patg] = pat;
- return true;
- }
- }else{
- Assert( patg.hasOperator() );
- if( !pat.hasOperator() || patg.getOperator()!=pat.getOperator() ){
- return false;
- }else{
- Assert( patg.getNumChildren()==pat.getNumChildren() );
- for( unsigned i=0; i<patg.getNumChildren(); i++ ){
- if( !isGeneralization( patg[i], pat[i], subs ) ){
- return false;
- }
- }
- return true;
- }
- }
-}
-
-int ConjectureGenerator::calculateGeneralizationDepth( TNode n, std::vector< TNode >& fv ) {
- if( n.getKind()==BOUND_VARIABLE ){
- if( std::find( fv.begin(), fv.end(), n )==fv.end() ){
- fv.push_back( n );
- return 0;
- }else{
- return 1;
- }
- }else{
- int depth = 1;
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- depth += calculateGeneralizationDepth( n[i], fv );
- }
- return depth;
- }
-}
-
-Node ConjectureGenerator::getPredicateForType( TypeNode tn ) {
- std::map< TypeNode, Node >::iterator it = d_typ_pred.find( tn );
- if( it==d_typ_pred.end() ){
- TypeNode op_tn = NodeManager::currentNM()->mkFunctionType( tn, NodeManager::currentNM()->booleanType() );
- Node op = NodeManager::currentNM()->mkSkolem( "PE", op_tn, "was created by conjecture ground term enumerator." );
- d_typ_pred[tn] = op;
- return op;
- }else{
- return it->second;
- }
-}
-
-void ConjectureGenerator::getEnumerateUfTerm( Node n, unsigned num, std::vector< Node >& terms ) {
- if( n.getNumChildren()>0 ){
- std::vector< int > vec;
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- vec.push_back( 0 );
- }
- vec.pop_back();
- int size_limit = 0;
- int vec_sum = -1;
- unsigned index = 0;
- unsigned last_size = terms.size();
- while( terms.size()<num ){
- bool success = true;
- if( vec_sum==-1 ){
- vec_sum = 0;
- vec.push_back( size_limit );
- }else{
- //see if we can iterate current
- if( vec_sum<size_limit && !getTermDatabase()->getEnumerateTerm( n[index].getType(), vec[index]+1 ).isNull() ){
- vec[index]++;
- vec_sum++;
- vec.push_back( size_limit - vec_sum );
- }else{
- vec_sum -= vec[index];
- vec[index] = 0;
- index++;
- if( index==n.getNumChildren() ){
- success = false;
- }
- }
- }
- if( success ){
- if( vec.size()==n.getNumChildren() ){
- Node lc = getTermDatabase()->getEnumerateTerm( n[vec.size()-1].getType(), vec[vec.size()-1] );
- if( !lc.isNull() ){
- for( unsigned i=0; i<vec.size(); i++ ){
- Trace("sg-gt-enum-debug") << vec[i] << " ";
- }
- Trace("sg-gt-enum-debug") << " / " << size_limit << std::endl;
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- Trace("sg-gt-enum-debug") << n[i].getType() << " ";
- }
- Trace("sg-gt-enum-debug") << std::endl;
- std::vector< Node > children;
- children.push_back( n.getOperator() );
- for( unsigned i=0; i<(vec.size()-1); i++ ){
- Node nn = getTermDatabase()->getEnumerateTerm( n[i].getType(), vec[i] );
- Assert( !nn.isNull() );
- Assert( nn.getType()==n[i].getType() );
- children.push_back( nn );
- }
- children.push_back( lc );
- Node n = NodeManager::currentNM()->mkNode( APPLY_UF, children );
- Trace("sg-gt-enum") << "Ground term enumerate : " << n << std::endl;
- terms.push_back( n );
- }
- vec.pop_back();
- index = 0;
- }
- }else{
- if( terms.size()>last_size ){
- last_size = terms.size();
- size_limit++;
- for( unsigned i=0; i<vec.size(); i++ ){
- vec[i] = 0;
- }
- vec_sum = -1;
- }else{
- return;
- }
- }
- }
- }else{
- terms.push_back( n );
- }
-}
-
-void ConjectureGenerator::getEnumeratePredUfTerm( Node n, unsigned num, std::vector< Node >& terms ) {
- std::vector< Node > uf_terms;
- getEnumerateUfTerm( n, num, uf_terms );
- Node p = getPredicateForType( n.getType() );
- for( unsigned i=0; i<uf_terms.size(); i++ ){
- terms.push_back( NodeManager::currentNM()->mkNode( APPLY_UF, p, uf_terms[i] ) );
- }
-}
-
-void ConjectureGenerator::processCandidateConjecture( TNode lhs, TNode rhs, unsigned lhs_depth, unsigned rhs_depth ) {
- int score = considerCandidateConjecture( lhs, rhs );
- if( score>0 ){
- Trace("sg-conjecture") << "* Candidate conjecture : " << lhs << " == " << rhs << std::endl;
- Trace("sg-conjecture-debug") << " LHS, RHS generalization depth : " << lhs_depth << ", " << rhs_depth << std::endl;
- Trace("sg-conjecture-debug") << " confirmed = " << d_subs_confirmCount << ", #witnesses range = " << d_subs_confirmWitnessRange.size() << "." << std::endl;
- Trace("sg-conjecture-debug") << " #witnesses for ";
- bool firstTime = true;
- for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){
- if( !firstTime ){
- Trace("sg-conjecture-debug") << ", ";
- }
- Trace("sg-conjecture-debug") << it->first << " : " << it->second.size();
- //if( it->second.size()==1 ){
- // Trace("sg-conjecture-debug") << " (" << it->second[0] << ")";
- //}
- Trace("sg-conjecture-debug2") << " (";
- for( unsigned j=0; j<it->second.size(); j++ ){
- if( j>0 ){ Trace("sg-conjecture-debug2") << " "; }
- Trace("sg-conjecture-debug2") << d_ground_eqc_map[it->second[j]];
- }
- Trace("sg-conjecture-debug2") << ")";
- firstTime = false;
- }
- Trace("sg-conjecture-debug") << std::endl;
- Trace("sg-conjecture-debug") << " unknown = " << d_subs_unkCount << std::endl;
- //Assert( getUniversalRepresentative( rhs )==rhs );
- //Assert( getUniversalRepresentative( lhs )==lhs );
- d_waiting_conjectures_lhs.push_back( lhs );
- d_waiting_conjectures_rhs.push_back( rhs );
- d_waiting_conjectures_score.push_back( score );
- d_waiting_conjectures[lhs].push_back( rhs );
- d_waiting_conjectures[rhs].push_back( lhs );
- }
-}
-
-int ConjectureGenerator::considerCandidateConjecture( TNode lhs, TNode rhs ) {
- Assert( lhs.getType()==rhs.getType() );
-
- Trace("sg-cconj-debug") << "Consider candidate conjecture : " << lhs << " == " << rhs << "?" << std::endl;
- if( lhs==rhs ){
- Trace("sg-cconj-debug") << " -> trivial." << std::endl;
- return -1;
- }else{
- if( lhs.getKind()==APPLY_CONSTRUCTOR && rhs.getKind()==APPLY_CONSTRUCTOR ){
- Trace("sg-cconj-debug") << " -> irrelevant by syntactic analysis." << std::endl;
- return -1;
- }
- //variables of LHS must subsume variables of RHS
- for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[rhs].begin(); it != d_pattern_var_id[rhs].end(); ++it ){
- std::map< TypeNode, unsigned >::iterator itl = d_pattern_var_id[lhs].find( it->first );
- if( itl!=d_pattern_var_id[lhs].end() ){
- if( itl->second<it->second ){
- Trace("sg-cconj-debug") << " -> variables of sort " << it->first << " are not subsumed." << std::endl;
- return -1;
- }else{
- Trace("sg-cconj-debug2") << " variables of sort " << it->first << " are : " << itl->second << " vs " << it->second << std::endl;
- }
- }else{
- Trace("sg-cconj-debug") << " -> has no variables of sort " << it->first << "." << std::endl;
- return -1;
- }
- }
-
- //currently active conjecture?
- std::map< Node, std::vector< Node > >::iterator iteq = d_eq_conjectures.find( lhs );
- if( iteq!=d_eq_conjectures.end() ){
- if( std::find( iteq->second.begin(), iteq->second.end(), rhs )!=iteq->second.end() ){
- Trace("sg-cconj-debug") << " -> this conjecture is already active." << std::endl;
- return -1;
- }
- }
- //current a waiting conjecture?
- std::map< Node, std::vector< Node > >::iterator itw = d_waiting_conjectures.find( lhs );
- if( itw!=d_waiting_conjectures.end() ){
- if( std::find( itw->second.begin(), itw->second.end(), rhs )!=itw->second.end() ){
- Trace("sg-cconj-debug") << " -> already are considering this conjecture." << std::endl;
- return -1;
- }
- }
- //check if canonical representation (should be, but for efficiency this is not guarenteed)
- //if( options::conjectureFilterCanonical() && ( getUniversalRepresentative( lhs )!=lhs || getUniversalRepresentative( rhs )!=rhs ) ){
- // Trace("sg-cconj") << " -> after processing, not canonical." << std::endl;
- // return -1;
- //}
-
- int score;
- bool scoreSet = false;
-
- Trace("sg-cconj") << "Consider possible candidate conjecture : " << lhs << " == " << rhs << "?" << std::endl;
- //find witness for counterexample, if possible
- if( options::conjectureFilterModel() ){
- Assert( d_rel_pattern_var_sum.find( lhs )!=d_rel_pattern_var_sum.end() );
- Trace("sg-cconj-debug") << "Notify substitutions over " << d_rel_pattern_var_sum[lhs] << " variables." << std::endl;
- std::map< TNode, TNode > subs;
- d_subs_confirmCount = 0;
- d_subs_confirmWitnessRange.clear();
- d_subs_confirmWitnessDomain.clear();
- d_subs_unkCount = 0;
- if( !d_rel_pattern_subs_index[lhs].notifySubstitutions( this, subs, rhs, d_rel_pattern_var_sum[lhs] ) ){
- Trace("sg-cconj") << " -> found witness that falsifies the conjecture." << std::endl;
- return -1;
- }
- //score is the minimum number of distinct substitutions for a variable
- for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){
- int num = (int)it->second.size();
- if( !scoreSet || num<score ){
- score = num;
- scoreSet = true;
- }
- }
- if( !scoreSet ){
- score = 0;
- }
- Trace("sg-cconj") << " confirmed = " << d_subs_confirmCount << ", #witnesses range = " << d_subs_confirmWitnessRange.size() << "." << std::endl;
- for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){
- Trace("sg-cconj") << " #witnesses for " << it->first << " : " << it->second.size() << std::endl;
- }
- }else{
- score = 1;
- }
-
- Trace("sg-cconj") << " -> SUCCESS." << std::endl;
- Trace("sg-cconj") << " score : " << score << std::endl;
-
- return score;
- }
-}
-
-bool ConjectureGenerator::notifySubstitution( TNode glhs, std::map< TNode, TNode >& subs, TNode rhs ) {
- if( Trace.isOn("sg-cconj-debug") ){
- Trace("sg-cconj-debug") << "Ground eqc for LHS : " << glhs << ", based on substituion: " << std::endl;
- for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){
- Assert( getRepresentative( it->second )==it->second );
- Trace("sg-cconj-debug") << " " << it->first << " -> " << it->second << std::endl;
- }
- }
- Trace("sg-cconj-debug") << "Evaluate RHS : : " << rhs << std::endl;
- //get the representative of rhs with substitution subs
- TNode grhs = getTermDatabase()->evaluateTerm( rhs, subs, true );
- Trace("sg-cconj-debug") << "...done evaluating term, got : " << grhs << std::endl;
- if( !grhs.isNull() ){
- if( glhs!=grhs ){
- Trace("sg-cconj-debug") << "Ground eqc for RHS : " << grhs << std::endl;
- //check based on ground terms
- std::map< TNode, Node >::iterator itl = d_ground_eqc_map.find( glhs );
- if( itl!=d_ground_eqc_map.end() ){
- std::map< TNode, Node >::iterator itr = d_ground_eqc_map.find( grhs );
- if( itr!=d_ground_eqc_map.end() ){
- Trace("sg-cconj-debug") << "We have ground terms " << itl->second << " and " << itr->second << "." << std::endl;
- if( itl->second.isConst() && itr->second.isConst() ){
- Trace("sg-cconj-debug") << "...disequal constants." << std::endl;
- Trace("sg-cconj-witness") << " Witness of falsification : " << itl->second << " != " << itr->second << ", substutition is : " << std::endl;
- for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){
- Trace("sg-cconj-witness") << " " << it->first << " -> " << it->second << std::endl;
- }
- return false;
- }
- }
- }
- }
- Trace("sg-cconj-debug") << "RHS is identical." << std::endl;
- bool isGroundSubs = true;
- for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){
- std::map< TNode, Node >::iterator git = d_ground_eqc_map.find( it->second );
- if( git==d_ground_eqc_map.end() ){
- isGroundSubs = false;
- break;
- }
- }
- if( isGroundSubs ){
- if( glhs==grhs ){
- Trace("sg-cconj-witness") << " Witnessed " << glhs << " == " << grhs << ", substutition is : " << std::endl;
- for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){
- Trace("sg-cconj-witness") << " " << it->first << " -> " << it->second << std::endl;
- if( std::find( d_subs_confirmWitnessDomain[it->first].begin(), d_subs_confirmWitnessDomain[it->first].end(), it->second )==d_subs_confirmWitnessDomain[it->first].end() ){
- d_subs_confirmWitnessDomain[it->first].push_back( it->second );
- }
- }
- d_subs_confirmCount++;
- if( std::find( d_subs_confirmWitnessRange.begin(), d_subs_confirmWitnessRange.end(), glhs )==d_subs_confirmWitnessRange.end() ){
- d_subs_confirmWitnessRange.push_back( glhs );
- }
- }else{
- if( optFilterUnknown() ){
- Trace("sg-cconj-debug") << "...ground substitution giving terms that are neither equal nor disequal." << std::endl;
- return false;
- }
- }
- }
- }else{
- Trace("sg-cconj-debug") << "(could not ground eqc for RHS)." << std::endl;
- }
- return true;
-}
-
-
-
-
-
-
-void TermGenerator::reset( TermGenEnv * s, TypeNode tn ) {
- Assert( d_children.empty() );
- d_typ = tn;
- d_status = 0;
- d_status_num = 0;
- d_children.clear();
- Trace("sg-gen-tg-debug2") << "...add to context " << this << std::endl;
- d_id = s->d_tg_id;
- s->changeContext( true );
-}
-
-bool TermGenerator::getNextTerm( TermGenEnv * s, unsigned depth ) {
- if( Trace.isOn("sg-gen-tg-debug2") ){
- Trace("sg-gen-tg-debug2") << this << " getNextTerm depth " << depth << " : status = " << d_status << ", num = " << d_status_num;
- if( d_status==5 ){
- TNode f = s->getTgFunc( d_typ, d_status_num );
- Trace("sg-gen-tg-debug2") << ", f = " << f;
- Trace("sg-gen-tg-debug2") << ", #args = " << s->d_func_args[f].size();
- Trace("sg-gen-tg-debug2") << ", childNum = " << d_status_child_num;
- Trace("sg-gen-tg-debug2") << ", #children = " << d_children.size();
- }
- Trace("sg-gen-tg-debug2") << std::endl;
- }
-
- if( d_status==0 ){
- d_status++;
- if( !d_typ.isNull() ){
- if( s->allowVar( d_typ ) ){
- //allocate variable
- d_status_num = s->d_var_id[d_typ];
- s->addVar( d_typ );
- Trace("sg-gen-tg-debug2") << this << " ...return unique var #" << d_status_num << std::endl;
- return s->considerCurrentTerm() ? true : getNextTerm( s, depth );
- }else{
- //check allocating new variable
- d_status++;
- d_status_num = -1;
- if( s->d_gen_relevant_terms ){
- s->d_tg_gdepth++;
- }
- return getNextTerm( s, depth );
- }
- }else{
- d_status = 4;
- d_status_num = -1;
- return getNextTerm( s, depth );
- }
- }else if( d_status==2 ){
- //cleanup previous information
- //if( d_status_num>=0 ){
- // s->d_var_eq_tg[d_status_num].pop_back();
- //}
- //check if there is another variable
- if( (d_status_num+1)<(int)s->getNumTgVars( d_typ ) ){
- d_status_num++;
- //we have equated two variables
- //s->d_var_eq_tg[d_status_num].push_back( d_id );
- Trace("sg-gen-tg-debug2") << this << "...consider other var #" << d_status_num << std::endl;
- return s->considerCurrentTerm() ? true : getNextTerm( s, depth );
- }else{
- if( s->d_gen_relevant_terms ){
- s->d_tg_gdepth--;
- }
- d_status++;
- return getNextTerm( s, depth );
- }
- }else if( d_status==4 ){
- d_status++;
- if( depth>0 && (d_status_num+1)<(int)s->getNumTgFuncs( d_typ ) ){
- d_status_num++;
- d_status_child_num = 0;
- Trace("sg-gen-tg-debug2") << this << "...consider function " << s->getTgFunc( d_typ, d_status_num ) << std::endl;
- s->d_tg_gdepth++;
- if( !s->considerCurrentTerm() ){
- s->d_tg_gdepth--;
- //don't consider this function
- d_status--;
- }else{
- //we have decided on a function application
- }
- return getNextTerm( s, depth );
- }else{
- //do not choose function applications at depth 0
- d_status++;
- return getNextTerm( s, depth );
- }
- }else if( d_status==5 ){
- //iterating over arguments
- TNode f = s->getTgFunc( d_typ, d_status_num );
- if( d_status_child_num<0 ){
- //no more arguments
- s->d_tg_gdepth--;
- d_status--;
- return getNextTerm( s, depth );
- }else if( d_status_child_num==(int)s->d_func_args[f].size() ){
- d_status_child_num--;
- return s->considerCurrentTermCanon( d_id ) ? true : getNextTerm( s, depth );
- //return true;
- }else{
- Assert( d_status_child_num<(int)s->d_func_args[f].size() );
- if( d_status_child_num==(int)d_children.size() ){
- d_children.push_back( s->d_tg_id );
- Assert( s->d_tg_alloc.find( s->d_tg_id )==s->d_tg_alloc.end() );
- s->d_tg_alloc[d_children[d_status_child_num]].reset( s, s->d_func_args[f][d_status_child_num] );
- return getNextTerm( s, depth );
- }else{
- Assert( d_status_child_num+1==(int)d_children.size() );
- if( s->d_tg_alloc[d_children[d_status_child_num]].getNextTerm( s, depth-1 ) ){
- d_status_child_num++;
- return getNextTerm( s, depth );
- }else{
- d_children.pop_back();
- d_status_child_num--;
- return getNextTerm( s, depth );
- }
- }
- }
- }else if( d_status==1 || d_status==3 ){
- if( d_status==1 ){
- s->removeVar( d_typ );
- Assert( d_status_num==(int)s->d_var_id[d_typ] );
- //check if there is only one feasible equivalence class. if so, don't make pattern any more specific.
- //unsigned i = s->d_ccand_eqc[0].size()-1;
- //if( s->d_ccand_eqc[0][i].size()==1 && s->d_ccand_eqc[1][i].empty() ){
- // d_status = 6;
- // return getNextTerm( s, depth );
- //}
- s->d_tg_gdepth++;
- }
- d_status++;
- d_status_num = -1;
- return getNextTerm( s, depth );
- }else{
- //clean up
- Assert( d_children.empty() );
- Trace("sg-gen-tg-debug2") << "...remove from context " << this << std::endl;
- s->changeContext( false );
- Assert( d_id==s->d_tg_id );
- return false;
- }
-}
-
-void TermGenerator::resetMatching( TermGenEnv * s, TNode eqc, unsigned mode ) {
- d_match_status = 0;
- d_match_status_child_num = 0;
- d_match_children.clear();
- d_match_children_end.clear();
- d_match_mode = mode;
- //if this term generalizes, it must generalize a non-ground term
- //if( (d_match_mode & ( 1 << 2 ))!=0 && s->isGroundEqc( eqc ) && d_status==5 ){
- // d_match_status = -1;
- //}
-}
-
-bool TermGenerator::getNextMatch( TermGenEnv * s, TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ) {
- if( d_match_status<0 ){
- return false;
- }
- if( Trace.isOn("sg-gen-tg-match") ){
- Trace("sg-gen-tg-match") << "Matching ";
- debugPrint( s, "sg-gen-tg-match", "sg-gen-tg-match" );
- Trace("sg-gen-tg-match") << " with eqc e" << s->d_cg->d_em[eqc] << "..." << std::endl;
- Trace("sg-gen-tg-match") << " mstatus = " << d_match_status;
- if( d_status==5 ){
- TNode f = s->getTgFunc( d_typ, d_status_num );
- Trace("sg-gen-tg-debug2") << ", f = " << f;
- Trace("sg-gen-tg-debug2") << ", #args = " << s->d_func_args[f].size();
- Trace("sg-gen-tg-debug2") << ", mchildNum = " << d_match_status_child_num;
- Trace("sg-gen-tg-debug2") << ", #mchildren = " << d_match_children.size();
- }
- Trace("sg-gen-tg-debug2") << ", current substitution : {";
- for( std::map< TypeNode, std::map< unsigned, TNode > >::iterator itt = subs.begin(); itt != subs.end(); ++itt ){
- for( std::map< unsigned, TNode >::iterator it = itt->second.begin(); it != itt->second.end(); ++it ){
- Trace("sg-gen-tg-debug2") << " " << it->first << " -> e" << s->d_cg->d_em[it->second];
- }
- }
- Trace("sg-gen-tg-debug2") << " } " << std::endl;
- }
- if( d_status==1 ){
- //a variable
- if( d_match_status==0 ){
- d_match_status++;
- if( (d_match_mode & ( 1 << 1 ))!=0 ){
- //only ground terms
- if( !s->isGroundEqc( eqc ) ){
- return false;
- }
- }else if( (d_match_mode & ( 1 << 2 ))!=0 ){
- //only non-ground terms
- //if( s->isGroundEqc( eqc ) ){
- // return false;
- //}
- }
- //store the match : restricted if match_mode.0 = 1
- if( (d_match_mode & ( 1 << 0 ))!=0 ){
- std::map< TNode, bool >::iterator it = rev_subs.find( eqc );
- if( it==rev_subs.end() ){
- rev_subs[eqc] = true;
- }else{
- return false;
- }
- }
- Assert( subs[d_typ].find( d_status_num )==subs[d_typ].end() );
- subs[d_typ][d_status_num] = eqc;
- return true;
- }else{
- //clean up
- subs[d_typ].erase( d_status_num );
- if( (d_match_mode & ( 1 << 0 ))!=0 ){
- rev_subs.erase( eqc );
- }
- return false;
- }
- }else if( d_status==2 ){
- if( d_match_status==0 ){
- d_match_status++;
- Assert( d_status_num<(int)s->getNumTgVars( d_typ ) );
- std::map< unsigned, TNode >::iterator it = subs[d_typ].find( d_status_num );
- Assert( it!=subs[d_typ].end() );
- return it->second==eqc;
- }else{
- return false;
- }
- }else if( d_status==5 ){
- //Assert( d_match_children.size()<=d_children.size() );
- //enumerating over f-applications in eqc
- if( d_match_status_child_num<0 ){
- return false;
- }else if( d_match_status==0 ){
- //set up next binding
- if( d_match_status_child_num==(int)d_match_children.size() ){
- if( d_match_status_child_num==0 ){
- //initial binding
- TNode f = s->getTgFunc( d_typ, d_status_num );
- std::map< TNode, TermArgTrie >::iterator it = s->getTermDatabase()->d_func_map_eqc_trie[f].d_data.find( eqc );
- if( it!=s->getTermDatabase()->d_func_map_eqc_trie[f].d_data.end() ){
- d_match_children.push_back( it->second.d_data.begin() );
- d_match_children_end.push_back( it->second.d_data.end() );
- }else{
- d_match_status++;
- d_match_status_child_num--;
- return getNextMatch( s, eqc, subs, rev_subs );
- }
- }else{
- d_match_children.push_back( d_match_children[d_match_status_child_num-1]->second.d_data.begin() );
- d_match_children_end.push_back( d_match_children[d_match_status_child_num-1]->second.d_data.end() );
- }
- }
- d_match_status++;
- Assert( d_match_status_child_num+1==(int)d_match_children.size() );
- if( d_match_children[d_match_status_child_num]==d_match_children_end[d_match_status_child_num] ){
- //no more arguments to bind
- d_match_children.pop_back();
- d_match_children_end.pop_back();
- d_match_status_child_num--;
- return getNextMatch( s, eqc, subs, rev_subs );
- }else{
- if( d_match_status_child_num==(int)d_children.size() ){
- //successfully matched all children
- d_match_children.pop_back();
- d_match_children_end.pop_back();
- d_match_status_child_num--;
- return true;//return d_match_children[d_match_status]!=d_match_children_end[d_match_status];
- }else{
- //do next binding
- s->d_tg_alloc[d_children[d_match_status_child_num]].resetMatching( s, d_match_children[d_match_status_child_num]->first, d_match_mode );
- return getNextMatch( s, eqc, subs, rev_subs );
- }
- }
- }else{
- Assert( d_match_status==1 );
- Assert( d_match_status_child_num+1==(int)d_match_children.size() );
- Assert( d_match_children[d_match_status_child_num]!=d_match_children_end[d_match_status_child_num] );
- d_match_status--;
- if( s->d_tg_alloc[d_children[d_match_status_child_num]].getNextMatch( s, d_match_children[d_match_status_child_num]->first, subs, rev_subs ) ){
- d_match_status_child_num++;
- return getNextMatch( s, eqc, subs, rev_subs );
- }else{
- //iterate
- d_match_children[d_match_status_child_num]++;
- return getNextMatch( s, eqc, subs, rev_subs );
- }
- }
- }
- Assert( false );
- return false;
-}
-
-unsigned TermGenerator::getDepth( TermGenEnv * s ) {
- if( d_status==5 ){
- unsigned maxd = 0;
- for( unsigned i=0; i<d_children.size(); i++ ){
- unsigned d = s->d_tg_alloc[d_children[i]].getDepth( s );
- if( d>maxd ){
- maxd = d;
- }
- }
- return 1+maxd;
- }else{
- return 0;
- }
-}
-
-unsigned TermGenerator::calculateGeneralizationDepth( TermGenEnv * s, std::map< TypeNode, std::vector< int > >& fvs ) {
- if( d_status==5 ){
- unsigned sum = 1;
- for( unsigned i=0; i<d_children.size(); i++ ){
- sum += s->d_tg_alloc[d_children[i]].calculateGeneralizationDepth( s, fvs );
- }
- return sum;
- }else{
- Assert( d_status==2 || d_status==1 );
- std::map< TypeNode, std::vector< int > >::iterator it = fvs.find( d_typ );
- if( it!=fvs.end() ){
- if( std::find( it->second.begin(), it->second.end(), d_status_num )!=it->second.end() ){
- return 1;
- }
- }
- fvs[d_typ].push_back( d_status_num );
- return 0;
- }
-}
-
-unsigned TermGenerator::getGeneralizationDepth( TermGenEnv * s ) {
- //if( s->d_gen_relevant_terms ){
- // return s->d_tg_gdepth;
- //}else{
- std::map< TypeNode, std::vector< int > > fvs;
- return calculateGeneralizationDepth( s, fvs );
- //}
-}
-
-Node TermGenerator::getTerm( TermGenEnv * s ) {
- if( d_status==1 || d_status==2 ){
- Assert( !d_typ.isNull() );
- return s->getFreeVar( d_typ, d_status_num );
- }else if( d_status==5 ){
- Node f = s->getTgFunc( d_typ, d_status_num );
- if( d_children.size()==s->d_func_args[f].size() ){
- std::vector< Node > children;
- if( s->d_tg_func_param[f] ){
- children.push_back( f );
- }
- for( unsigned i=0; i<d_children.size(); i++ ){
- Node nc = s->d_tg_alloc[d_children[i]].getTerm( s );
- if( nc.isNull() ){
- return Node::null();
- }else{
- //Assert( nc.getType()==s->d_func_args[f][i] );
- children.push_back( nc );
- }
- }
- return NodeManager::currentNM()->mkNode( s->d_func_kind[f], children );
- }
- }else{
- Assert( false );
- }
- return Node::null();
-}
-
-void TermGenerator::debugPrint( TermGenEnv * s, const char * c, const char * cd ) {
- Trace(cd) << "[*" << d_id << "," << d_status << "]:";
- if( d_status==1 || d_status==2 ){
- Trace(c) << s->getFreeVar( d_typ, d_status_num );
- }else if( d_status==5 ){
- TNode f = s->getTgFunc( d_typ, d_status_num );
- Trace(c) << "(" << f;
- for( unsigned i=0; i<d_children.size(); i++ ){
- Trace(c) << " ";
- s->d_tg_alloc[d_children[i]].debugPrint( s, c, cd );
- }
- if( d_children.size()<s->d_func_args[f].size() ){
- Trace(c) << " ...";
- }
- Trace(c) << ")";
- }else{
- Trace(c) << "???";
- }
-}
-
-void TermGenEnv::collectSignatureInformation() {
- d_typ_tg_funcs.clear();
- d_funcs.clear();
- d_func_kind.clear();
- d_func_args.clear();
- TypeNode tnull;
- for( std::map< Node, TermArgTrie >::iterator it = getTermDatabase()->d_func_map_trie.begin(); it != getTermDatabase()->d_func_map_trie.end(); ++it ){
- if( !getTermDatabase()->d_op_map[it->first].empty() ){
- Node nn = getTermDatabase()->d_op_map[it->first][0];
- if( d_cg->isHandledTerm( nn ) && nn.getKind()!=APPLY_SELECTOR_TOTAL && !nn.getType().isBoolean() ){
- bool do_enum = true;
- //check if we have enumerated ground terms
- if( nn.getKind()==APPLY_UF ){
- if( !d_cg->hasEnumeratedUf( nn ) ){
- do_enum = false;
- }
- }
- if( do_enum ){
- d_funcs.push_back( it->first );
- for( unsigned i=0; i<nn.getNumChildren(); i++ ){
- d_func_args[it->first].push_back( nn[i].getType() );
- }
- d_func_kind[it->first] = nn.getKind();
- d_typ_tg_funcs[tnull].push_back( it->first );
- d_typ_tg_funcs[nn.getType()].push_back( it->first );
- d_tg_func_param[it->first] = ( nn.getMetaKind() == kind::metakind::PARAMETERIZED );
- Trace("sg-rel-sig") << "Will enumerate function applications of : " << it->first << ", #args = " << d_func_args[it->first].size() << ", kind = " << nn.getKind() << std::endl;
- getTermDatabase()->computeUfEqcTerms( it->first );
- }
- }
- }
- }
- //shuffle functions
- for( std::map< TypeNode, std::vector< TNode > >::iterator it = d_typ_tg_funcs.begin(); it != d_typ_tg_funcs.end(); ++it ){
- std::random_shuffle( it->second.begin(), it->second.end() );
- if( it->first.isNull() ){
- Trace("sg-gen-tg-debug") << "In this order : ";
- for( unsigned i=0; i<it->second.size(); i++ ){
- Trace("sg-gen-tg-debug") << it->second[i] << " ";
- }
- Trace("sg-gen-tg-debug") << std::endl;
- }
- }
-}
-
-void TermGenEnv::reset( unsigned depth, bool genRelevant, TypeNode tn ) {
- Assert( d_tg_alloc.empty() );
- d_tg_alloc.clear();
-
- if( genRelevant ){
- for( unsigned i=0; i<2; i++ ){
- d_ccand_eqc[i].clear();
- d_ccand_eqc[i].push_back( d_relevant_eqc[i] );
- }
- }
-
- d_tg_id = 0;
- d_tg_gdepth = 0;
- d_tg_gdepth_limit = depth;
- d_gen_relevant_terms = genRelevant;
- d_tg_alloc[0].reset( this, tn );
-}
-
-bool TermGenEnv::getNextTerm() {
- if( d_tg_alloc[0].getNextTerm( this, d_tg_gdepth_limit ) ){
- Assert( (int)d_tg_alloc[0].getGeneralizationDepth( this )<=d_tg_gdepth_limit );
- if( (int)d_tg_alloc[0].getGeneralizationDepth( this )!=d_tg_gdepth_limit ){
- return getNextTerm();
- }else{
- return true;
- }
- }else{
- return false;
- }
-}
-
-//reset matching
-void TermGenEnv::resetMatching( TNode eqc, unsigned mode ) {
- d_tg_alloc[0].resetMatching( this, eqc, mode );
-}
-
-//get next match
-bool TermGenEnv::getNextMatch( TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ) {
- return d_tg_alloc[0].getNextMatch( this, eqc, subs, rev_subs );
-}
-
-//get term
-Node TermGenEnv::getTerm() {
- return d_tg_alloc[0].getTerm( this );
-}
-
-void TermGenEnv::debugPrint( const char * c, const char * cd ) {
- d_tg_alloc[0].debugPrint( this, c, cd );
-}
-
-unsigned TermGenEnv::getNumTgVars( TypeNode tn ) {
- return d_var_id[tn];
-}
-
-bool TermGenEnv::allowVar( TypeNode tn ) {
- std::map< TypeNode, unsigned >::iterator it = d_var_limit.find( tn );
- if( it==d_var_limit.end() ){
- return true;
- }else{
- return d_var_id[tn]<it->second;
- }
-}
-
-void TermGenEnv::addVar( TypeNode tn ) {
- d_var_id[tn]++;
-}
-
-void TermGenEnv::removeVar( TypeNode tn ) {
- d_var_id[tn]--;
- //d_var_eq_tg.pop_back();
- //d_var_tg.pop_back();
-}
-
-unsigned TermGenEnv::getNumTgFuncs( TypeNode tn ) {
- return d_typ_tg_funcs[tn].size();
-}
-
-TNode TermGenEnv::getTgFunc( TypeNode tn, unsigned i ) {
- return d_typ_tg_funcs[tn][i];
-}
-
-Node TermGenEnv::getFreeVar( TypeNode tn, unsigned i ) {
- return d_cg->getFreeVar( tn, i );
-}
-
-bool TermGenEnv::considerCurrentTerm() {
- Assert( !d_tg_alloc.empty() );
-
- //if generalization depth is too large, don't consider it
- unsigned i = d_tg_alloc.size();
- Trace("sg-gen-tg-debug") << "Consider term ";
- d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" );
- Trace("sg-gen-tg-debug") << "? curr term size = " << d_tg_alloc.size() << ", last status = " << d_tg_alloc[i-1].d_status;
- Trace("sg-gen-tg-debug") << std::endl;
-
- if( d_tg_gdepth_limit>=0 && d_tg_alloc[0].getGeneralizationDepth( this )>(unsigned)d_tg_gdepth_limit ){
- Trace("sg-gen-consider-term") << "-> generalization depth of ";
- d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-tg-debug" );
- Trace("sg-gen-consider-term") << " is too high " << d_tg_gdepth << " " << d_tg_alloc[0].getGeneralizationDepth( this ) << ", do not consider." << std::endl;
- return false;
- }
-
- //----optimizations
- /*
- if( d_tg_alloc[i-1].d_status==1 ){
- }else if( d_tg_alloc[i-1].d_status==2 ){
- }else if( d_tg_alloc[i-1].d_status==5 ){
- }else{
- Trace("sg-gen-tg-debug") << "Bad tg: " << &d_tg_alloc[i-1] << std::endl;
- Assert( false );
- }
- */
- //if equated two variables, first check if context-independent TODO
- //----end optimizations
-
-
- //check based on which candidate equivalence classes match
- if( d_gen_relevant_terms ){
- Trace("sg-gen-tg-debug") << "Filter based on relevant ground EQC";
- Trace("sg-gen-tg-debug") << ", #eqc to try = " << d_ccand_eqc[0][i-1].size() << "/" << d_ccand_eqc[1][i-1].size() << std::endl;
-
- Assert( d_ccand_eqc[0].size()>=2 );
- Assert( d_ccand_eqc[0].size()==d_ccand_eqc[1].size() );
- Assert( d_ccand_eqc[0].size()==d_tg_id+1 );
- Assert( d_tg_id==d_tg_alloc.size() );
- for( unsigned r=0; r<2; r++ ){
- d_ccand_eqc[r][i].clear();
- }
-
- //re-check feasibility of EQC
- for( unsigned r=0; r<2; r++ ){
- for( unsigned j=0; j<d_ccand_eqc[r][i-1].size(); j++ ){
- std::map< TypeNode, std::map< unsigned, TNode > > subs;
- std::map< TNode, bool > rev_subs;
- unsigned mode;
- if( r==0 ){
- mode = d_cg->optReqDistinctVarPatterns() ? ( 1 << 0 ) : 0;
- mode = mode | (1 << 2 );
- }else{
- mode = 1 << 1;
- }
- d_tg_alloc[0].resetMatching( this, d_ccand_eqc[r][i-1][j], mode );
- if( d_tg_alloc[0].getNextMatch( this, d_ccand_eqc[r][i-1][j], subs, rev_subs ) ){
- d_ccand_eqc[r][i].push_back( d_ccand_eqc[r][i-1][j] );
- }
- }
- }
- for( unsigned r=0; r<2; r++ ){
- Trace("sg-gen-tg-debug") << "Current eqc of type " << r << " : ";
- for( unsigned j=0; j<d_ccand_eqc[r][i].size(); j++ ){
- Trace("sg-gen-tg-debug") << "e" << d_cg->d_em[d_ccand_eqc[r][i][j]] << " ";
- }
- Trace("sg-gen-tg-debug") << std::endl;
- }
- if( options::conjectureFilterActiveTerms() && d_ccand_eqc[0][i].empty() ){
- Trace("sg-gen-consider-term") << "Do not consider term of form ";
- d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-consider-term-debug" );
- Trace("sg-gen-consider-term") << " since no relevant EQC matches it." << std::endl;
- return false;
- }
- if( options::conjectureFilterModel() && d_ccand_eqc[1][i].empty() ){
- Trace("sg-gen-consider-term") << "Do not consider term of form ";
- d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-consider-term-debug" );
- Trace("sg-gen-consider-term") << " since no ground EQC matches it." << std::endl;
- return false;
- }
- }
- Trace("sg-gen-tg-debug") << "Will consider term ";
- d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" );
- Trace("sg-gen-tg-debug") << std::endl;
- Trace("sg-gen-consider-term-debug") << std::endl;
- return true;
-}
-
-void TermGenEnv::changeContext( bool add ) {
- if( add ){
- for( unsigned r=0; r<2; r++ ){
- d_ccand_eqc[r].push_back( std::vector< TNode >() );
- }
- d_tg_id++;
- }else{
- for( unsigned r=0; r<2; r++ ){
- d_ccand_eqc[r].pop_back();
- }
- d_tg_id--;
- Assert( d_tg_alloc.find( d_tg_id )!=d_tg_alloc.end() );
- d_tg_alloc.erase( d_tg_id );
- }
-}
-
-bool TermGenEnv::considerCurrentTermCanon( unsigned tg_id ){
- Assert( tg_id<d_tg_alloc.size() );
- if( options::conjectureFilterCanonical() ){
- //check based on a canonicity of the term (if there is one)
- Trace("sg-gen-tg-debug") << "Consider term canon ";
- d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" );
- Trace("sg-gen-tg-debug") << ", tg is [" << tg_id << "]..." << std::endl;
-
- Node ln = d_tg_alloc[tg_id].getTerm( this );
- Trace("sg-gen-tg-debug") << "Term is " << ln << std::endl;
- return d_cg->considerTermCanon( ln, d_gen_relevant_terms );
- }
- return true;
-}
-
-bool TermGenEnv::isRelevantFunc( Node f ) {
- return std::find( d_funcs.begin(), d_funcs.end(), f )!=d_funcs.end();
-}
-TermDb * TermGenEnv::getTermDatabase() {
- return d_cg->getTermDatabase();
-}
-Node TermGenEnv::getGroundEqc( TNode r ) {
- return d_cg->getGroundEqc( r );
-}
-bool TermGenEnv::isGroundEqc( TNode r ){
- return d_cg->isGroundEqc( r );
-}
-bool TermGenEnv::isGroundTerm( TNode n ){
- return d_cg->isGroundTerm( n );
-}
-
-
-void SubstitutionIndex::addSubstitution( TNode eqc, std::vector< TNode >& vars, std::vector< TNode >& terms, unsigned i ) {
- if( i==vars.size() ){
- d_var = eqc;
- }else{
- Assert( d_var.isNull() || d_var==vars[i] );
- d_var = vars[i];
- d_children[terms[i]].addSubstitution( eqc, vars, terms, i+1 );
- }
-}
-
-bool SubstitutionIndex::notifySubstitutions( ConjectureGenerator * s, std::map< TNode, TNode >& subs, TNode rhs, unsigned numVars, unsigned i ) {
- if( i==numVars ){
- Assert( d_children.empty() );
- return s->notifySubstitution( d_var, subs, rhs );
- }else{
- Assert( i==0 || !d_children.empty() );
- for( std::map< TNode, SubstitutionIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){
- Trace("sg-cconj-debug2") << "Try " << d_var << " -> " << it->first << " (" << i << "/" << numVars << ")" << std::endl;
- subs[d_var] = it->first;
- if( !it->second.notifySubstitutions( s, subs, rhs, numVars, i+1 ) ){
- return false;
- }
- }
- return true;
- }
-}
-
-
-void TheoremIndex::addTheorem( std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ){
- if( lhs_v.empty() ){
- if( std::find( d_terms.begin(), d_terms.end(), rhs )==d_terms.end() ){
- d_terms.push_back( rhs );
- }
- }else{
- unsigned index = lhs_v.size()-1;
- if( lhs_arg[index]==lhs_v[index].getNumChildren() ){
- lhs_v.pop_back();
- lhs_arg.pop_back();
- addTheorem( lhs_v, lhs_arg, rhs );
- }else{
- lhs_arg[index]++;
- addTheoremNode( lhs_v[index][lhs_arg[index]-1], lhs_v, lhs_arg, rhs );
- }
- }
-}
-
-void TheoremIndex::addTheoremNode( TNode curr, std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ){
- Trace("thm-db-debug") << "Adding conjecture for subterm " << curr << "..." << std::endl;
- if( curr.hasOperator() ){
- lhs_v.push_back( curr );
- lhs_arg.push_back( 0 );
- d_children[curr.getOperator()].addTheorem( lhs_v, lhs_arg, rhs );
- }else{
- Assert( curr.getKind()==kind::BOUND_VARIABLE );
- TypeNode tn = curr.getType();
- Assert( d_var[tn].isNull() || d_var[tn]==curr );
- d_var[tn] = curr;
- d_children[curr].addTheorem( lhs_v, lhs_arg, rhs );
- }
-}
-
-void TheoremIndex::getEquivalentTerms( std::vector< TNode >& n_v, std::vector< unsigned >& n_arg,
- std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs,
- std::vector< Node >& terms ) {
- Trace("thm-db-debug") << "Get equivalent terms " << n_v.size() << " " << n_arg.size() << std::endl;
- if( n_v.empty() ){
- Trace("thm-db-debug") << "Number of terms : " << d_terms.size() << std::endl;
- //apply substutitions to RHS's
- for( unsigned i=0; i<d_terms.size(); i++ ){
- Node n = d_terms[i].substitute( vars.begin(), vars.end(), subs.begin(), subs.end() );
- terms.push_back( n );
- }
- }else{
- unsigned index = n_v.size()-1;
- if( n_arg[index]==n_v[index].getNumChildren() ){
- n_v.pop_back();
- n_arg.pop_back();
- getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms );
- }else{
- n_arg[index]++;
- getEquivalentTermsNode( n_v[index][n_arg[index]-1], n_v, n_arg, smap, vars, subs, terms );
- }
- }
-}
-
-void TheoremIndex::getEquivalentTermsNode( Node curr, std::vector< TNode >& n_v, std::vector< unsigned >& n_arg,
- std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs,
- std::vector< Node >& terms ) {
- Trace("thm-db-debug") << "Get equivalent based on subterm " << curr << "..." << std::endl;
- if( curr.hasOperator() ){
- Trace("thm-db-debug") << "Check based on operator..." << std::endl;
- std::map< TNode, TheoremIndex >::iterator it = d_children.find( curr.getOperator() );
- if( it!=d_children.end() ){
- n_v.push_back( curr );
- n_arg.push_back( 0 );
- it->second.getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms );
- }
- Trace("thm-db-debug") << "...done check based on operator" << std::endl;
- }
- TypeNode tn = curr.getType();
- std::map< TypeNode, TNode >::iterator itt = d_var.find( tn );
- if( itt!=d_var.end() ){
- Trace("thm-db-debug") << "Check for substitution with " << itt->second << "..." << std::endl;
- Assert( curr.getType()==itt->second.getType() );
- //add to substitution if possible
- bool success = false;
- std::map< TNode, TNode >::iterator it = smap.find( itt->second );
- if( it==smap.end() ){
- smap[itt->second] = curr;
- vars.push_back( itt->second );
- subs.push_back( curr );
- success = true;
- }else if( it->second==curr ){
- success = true;
- }else{
- //also check modulo equality (in universal equality engine)
- }
- Trace("thm-db-debug") << "...check for substitution with " << itt->second << ", success = " << success << "." << std::endl;
- if( success ){
- d_children[itt->second].getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms );
- }
- }
-}
-
-void TheoremIndex::debugPrint( const char * c, unsigned ind ) {
- for( std::map< TNode, TheoremIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){
- for( unsigned i=0; i<ind; i++ ){ Trace(c) << " "; }
- Trace(c) << it->first << std::endl;
- it->second.debugPrint( c, ind+1 );
- }
- if( !d_terms.empty() ){
- for( unsigned i=0; i<ind; i++ ){ Trace(c) << " "; }
- Trace(c) << "{";
- for( unsigned i=0; i<d_terms.size(); i++ ){
- Trace(c) << " " << d_terms[i];
- }
- Trace(c) << " }" << std::endl;
- }
- //if( !d_var.isNull() ){
- // for( unsigned i=0; i<ind; i++ ){ Trace(c) << " "; }
- // Trace(c) << "var:" << d_var << std::endl;
- //}
-}
-
-bool ConjectureGenerator::optReqDistinctVarPatterns() { return false; }
-bool ConjectureGenerator::optFilterUnknown() { return true; } //may change
-int ConjectureGenerator::optFilterScoreThreshold() { return 1; }
-unsigned ConjectureGenerator::optFullCheckFrequency() { return 1; }
-
-bool ConjectureGenerator::optStatsOnly() { return false; }
-
-}
+/********************* */ +/*! \file conjecture_generator.cpp + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief conjecture generator class + ** + **/ + +#include "theory/quantifiers/conjecture_generator.h" +#include "theory/theory_engine.h" +#include "theory/quantifiers/options.h" +#include "theory/quantifiers/term_database.h" +#include "theory/quantifiers/trigger.h" +#include "theory/quantifiers/first_order_model.h" + +using namespace CVC4; +using namespace CVC4::kind; +using namespace CVC4::theory; +using namespace CVC4::theory::quantifiers; +using namespace std; + +namespace CVC4 { + +struct sortConjectureScore { + std::vector< int > d_scores; + bool operator() (unsigned i, unsigned j) { return d_scores[i]>d_scores[j]; } +}; + + +void OpArgIndex::addTerm( ConjectureGenerator * s, TNode n, unsigned index ){ + if( index==n.getNumChildren() ){ + Assert( n.hasOperator() ); + if( std::find( d_ops.begin(), d_ops.end(), n.getOperator() )==d_ops.end() ){ + d_ops.push_back( n.getOperator() ); + d_op_terms.push_back( n ); + } + }else{ + d_child[s->getTermDatabase()->d_arg_reps[n][index]].addTerm( s, n, index+1 ); + } +} + +Node OpArgIndex::getGroundTerm( ConjectureGenerator * s, std::vector< TNode >& args ) { + if( d_ops.empty() ){ + for( std::map< TNode, OpArgIndex >::iterator it = d_child.begin(); it != d_child.end(); ++it ){ + std::map< TNode, Node >::iterator itf = s->d_ground_eqc_map.find( it->first ); + if( itf!=s->d_ground_eqc_map.end() ){ + args.push_back( itf->second ); + Node n = it->second.getGroundTerm( s, args ); + args.pop_back(); + if( !n.isNull() ){ + return n; + } + } + } + return Node::null(); + }else{ + std::vector< TNode > args2; + args2.push_back( d_ops[0] ); + args2.insert( args2.end(), args.begin(), args.end() ); + return NodeManager::currentNM()->mkNode( d_op_terms[0].getKind(), args2 ); + } +} + +void OpArgIndex::getGroundTerms( ConjectureGenerator * s, std::vector< TNode >& terms ) { + terms.insert( terms.end(), d_op_terms.begin(), d_op_terms.end() ); + for( std::map< TNode, OpArgIndex >::iterator it = d_child.begin(); it != d_child.end(); ++it ){ + if( s->isGroundEqc( it->first ) ){ + it->second.getGroundTerms( s, terms ); + } + } +} + + + +ConjectureGenerator::ConjectureGenerator( QuantifiersEngine * qe, context::Context* c ) : QuantifiersModule( qe ), +d_notify( *this ), +d_uequalityEngine(d_notify, c, "ConjectureGenerator::ee", false), +d_ee_conjectures( c ){ + d_fullEffortCount = 0; + d_uequalityEngine.addFunctionKind( kind::APPLY_UF ); + d_uequalityEngine.addFunctionKind( kind::APPLY_CONSTRUCTOR ); + +} + +void ConjectureGenerator::eqNotifyNewClass( TNode t ){ + Trace("thm-ee-debug") << "UEE : new equivalence class " << t << std::endl; + d_upendingAdds.push_back( t ); +} + +void ConjectureGenerator::eqNotifyPreMerge(TNode t1, TNode t2) { + //get maintained representatives + TNode rt1 = t1; + TNode rt2 = t2; + std::map< Node, EqcInfo* >::iterator it1 = d_eqc_info.find( t1 ); + if( it1!=d_eqc_info.end() && !it1->second->d_rep.get().isNull() ){ + rt1 = it1->second->d_rep.get(); + } + std::map< Node, EqcInfo* >::iterator it2 = d_eqc_info.find( t2 ); + if( it2!=d_eqc_info.end() && !it2->second->d_rep.get().isNull() ){ + rt2 = it2->second->d_rep.get(); + } + Trace("thm-ee-debug") << "UEE : equality holds : " << t1 << " == " << t2 << std::endl; + Trace("thm-ee-debug") << " ureps : " << rt1 << " == " << rt2 << std::endl; + Trace("thm-ee-debug") << " relevant : " << d_pattern_is_relevant[rt1] << " " << d_pattern_is_relevant[rt2] << std::endl; + Trace("thm-ee-debug") << " normal : " << d_pattern_is_normal[rt1] << " " << d_pattern_is_normal[rt2] << std::endl; + Trace("thm-ee-debug") << " size : " << d_pattern_fun_sum[rt1] << " " << d_pattern_fun_sum[rt2] << std::endl; + + if( isUniversalLessThan( rt2, rt1 ) ){ + EqcInfo * ei; + if( it1==d_eqc_info.end() ){ + ei = getOrMakeEqcInfo( t1, true ); + }else{ + ei = it1->second; + } + ei->d_rep = t2; + } +} + +void ConjectureGenerator::eqNotifyPostMerge(TNode t1, TNode t2) { + +} + +void ConjectureGenerator::eqNotifyDisequal(TNode t1, TNode t2, TNode reason) { + Trace("thm-ee-debug") << "UEE : disequality holds : " << t1 << " != " << t2 << std::endl; + +} + + +ConjectureGenerator::EqcInfo::EqcInfo( context::Context* c ) : d_rep( c, Node::null() ){ + +} + +ConjectureGenerator::EqcInfo* ConjectureGenerator::getOrMakeEqcInfo( TNode n, bool doMake ) { + //Assert( getUniversalRepresentative( n )==n ); + std::map< Node, EqcInfo* >::iterator eqc_i = d_eqc_info.find( n ); + if( eqc_i!=d_eqc_info.end() ){ + return eqc_i->second; + }else if( doMake ){ + EqcInfo* ei = new EqcInfo( d_quantEngine->getSatContext() ); + d_eqc_info[n] = ei; + return ei; + }else{ + return NULL; + } +} + +void ConjectureGenerator::setUniversalRelevant( TNode n ) { + //add pattern information + registerPattern( n, n.getType() ); + d_urelevant_terms[n] = true; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + setUniversalRelevant( n[i] ); + } +} + +bool ConjectureGenerator::isUniversalLessThan( TNode rt1, TNode rt2 ) { + //prefer the one that is (normal, smaller) lexographically + Assert( d_pattern_is_relevant.find( rt1 )!=d_pattern_is_relevant.end() ); + Assert( d_pattern_is_relevant.find( rt2 )!=d_pattern_is_relevant.end() ); + Assert( d_pattern_is_normal.find( rt1 )!=d_pattern_is_normal.end() ); + Assert( d_pattern_is_normal.find( rt2 )!=d_pattern_is_normal.end() ); + Assert( d_pattern_fun_sum.find( rt1 )!=d_pattern_fun_sum.end() ); + Assert( d_pattern_fun_sum.find( rt2 )!=d_pattern_fun_sum.end() ); + + if( d_pattern_is_relevant[rt1] && !d_pattern_is_relevant[rt2] ){ + Trace("thm-ee-debug") << "UEE : LT due to relevant." << std::endl; + return true; + }else if( d_pattern_is_relevant[rt1]==d_pattern_is_relevant[rt2] ){ + if( d_pattern_is_normal[rt1] && !d_pattern_is_normal[rt2] ){ + Trace("thm-ee-debug") << "UEE : LT due to normal." << std::endl; + return true; + }else if( d_pattern_is_normal[rt1]==d_pattern_is_normal[rt2] ){ + if( d_pattern_fun_sum[rt1]<d_pattern_fun_sum[rt2] ){ + Trace("thm-ee-debug") << "UEE : LT due to size." << std::endl; + //decide which representative to use : based on size of the term + return true; + }else if( d_pattern_fun_sum[rt1]==d_pattern_fun_sum[rt2] ){ + //same size : tie goes to term that has already been reported + return isReportedCanon( rt1 ) && !isReportedCanon( rt2 ); + } + } + } + return false; +} + + +bool ConjectureGenerator::isReportedCanon( TNode n ) { + return std::find( d_ue_canon.begin(), d_ue_canon.end(), n )==d_ue_canon.end(); +} + +void ConjectureGenerator::markReportedCanon( TNode n ) { + if( !isReportedCanon( n ) ){ + d_ue_canon.push_back( n ); + } +} + +bool ConjectureGenerator::areUniversalEqual( TNode n1, TNode n2 ) { + return n1==n2 || ( d_uequalityEngine.hasTerm( n1 ) && d_uequalityEngine.hasTerm( n2 ) && d_uequalityEngine.areEqual( n1, n2 ) ); +} + +bool ConjectureGenerator::areUniversalDisequal( TNode n1, TNode n2 ) { + return n1!=n2 && d_uequalityEngine.hasTerm( n1 ) && d_uequalityEngine.hasTerm( n2 ) && d_uequalityEngine.areDisequal( n1, n2, false ); +} + +TNode ConjectureGenerator::getUniversalRepresentative( TNode n, bool add ) { + if( add ){ + if( d_urelevant_terms.find( n )==d_urelevant_terms.end() ){ + setUniversalRelevant( n ); + //add term to universal equality engine + d_uequalityEngine.addTerm( n ); + // addding this term to equality engine will lead to a set of new terms (the new subterms of n) + // now, do instantiation-based merging for each of these terms + Trace("thm-ee-debug") << "Merge equivalence classes based on instantiations of terms..." << std::endl; + //merge all pending equalities + while( !d_upendingAdds.empty() ){ + Trace("sg-pending") << "Add " << d_upendingAdds.size() << " pending terms..." << std::endl; + std::vector< Node > pending; + pending.insert( pending.end(), d_upendingAdds.begin(), d_upendingAdds.end() ); + d_upendingAdds.clear(); + for( unsigned i=0; i<pending.size(); i++ ){ + Node t = pending[i]; + TypeNode tn = t.getType(); + Trace("thm-ee-add") << "UEE : Add universal term " << t << std::endl; + std::vector< Node > eq_terms; + //if occurs modulo equality at ground level, it is equivalent to representative of ground equality engine + TNode gt = getTermDatabase()->evaluateTerm( t ); + if( !gt.isNull() && gt!=t ){ + eq_terms.push_back( gt ); + } + //get all equivalent terms based on theorem database + d_thm_index.getEquivalentTerms( t, eq_terms ); + if( !eq_terms.empty() ){ + Trace("thm-ee-add") << "UEE : Based on ground EE/theorem DB, it is equivalent to " << eq_terms.size() << " terms : " << std::endl; + //add equivalent terms as equalities to universal engine + for( unsigned i=0; i<eq_terms.size(); i++ ){ + Trace("thm-ee-add") << " " << eq_terms[i] << std::endl; + bool assertEq = false; + if( d_urelevant_terms.find( eq_terms[i] )!=d_urelevant_terms.end() ){ + assertEq = true; + }else{ + Assert( eq_terms[i].getType()==tn ); + registerPattern( eq_terms[i], tn ); + if( isUniversalLessThan( eq_terms[i], t ) || ( options::conjectureUeeIntro() && d_pattern_fun_sum[t]>=d_pattern_fun_sum[eq_terms[i]] ) ){ + setUniversalRelevant( eq_terms[i] ); + assertEq = true; + } + } + if( assertEq ){ + Node exp; + d_uequalityEngine.assertEquality( t.eqNode( eq_terms[i] ), true, exp ); + }else{ + Trace("thm-ee-no-add") << "Do not add : " << t << " == " << eq_terms[i] << std::endl; + } + } + }else{ + Trace("thm-ee-add") << "UEE : No equivalent terms." << std::endl; + } + } + } + } + } + + if( d_uequalityEngine.hasTerm( n ) ){ + Node r = d_uequalityEngine.getRepresentative( n ); + EqcInfo * ei = getOrMakeEqcInfo( r ); + if( ei && !ei->d_rep.get().isNull() ){ + return ei->d_rep.get(); + }else{ + return r; + } + }else{ + return n; + } +} + +Node ConjectureGenerator::getFreeVar( TypeNode tn, unsigned i ) { + Assert( !tn.isNull() ); + while( d_free_var[tn].size()<=i ){ + std::stringstream oss; + oss << tn; + std::string typ_name = oss.str(); + while( typ_name[0]=='(' ){ + typ_name.erase( typ_name.begin() ); + } + std::stringstream os; + os << typ_name[0] << i; + Node x = NodeManager::currentNM()->mkBoundVar( os.str().c_str(), tn ); + d_free_var_num[x] = d_free_var[tn].size(); + d_free_var[tn].push_back( x ); + } + return d_free_var[tn][i]; +} + + + +Node ConjectureGenerator::getCanonicalTerm( TNode n, std::map< TypeNode, unsigned >& var_count, std::map< TNode, TNode >& subs ) { + if( n.getKind()==BOUND_VARIABLE ){ + std::map< TNode, TNode >::iterator it = subs.find( n ); + if( it==subs.end() ){ + TypeNode tn = n.getType(); + //allocate variable + unsigned vn = var_count[tn]; + var_count[tn]++; + subs[n] = getFreeVar( tn, vn ); + return subs[n]; + }else{ + return it->second; + } + }else{ + std::vector< Node > children; + if( n.getKind()!=EQUAL ){ + if( n.hasOperator() ){ + TNode op = n.getOperator(); + if( !d_tge.isRelevantFunc( op ) ){ + return Node::null(); + } + children.push_back( op ); + }else{ + return Node::null(); + } + } + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + Node cn = getCanonicalTerm( n[i], var_count, subs ); + if( cn.isNull() ){ + return Node::null(); + }else{ + children.push_back( cn ); + } + } + return NodeManager::currentNM()->mkNode( n.getKind(), children ); + } +} + +bool ConjectureGenerator::isHandledTerm( TNode n ){ + return !n.getAttribute(NoMatchAttribute()) && inst::Trigger::isAtomicTrigger( n ) && ( n.getKind()!=APPLY_UF || n.getOperator().getKind()!=SKOLEM ); +} + +Node ConjectureGenerator::getGroundEqc( TNode r ) { + std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r ); + return it!=d_ground_eqc_map.end() ? it->second : Node::null(); +} + +bool ConjectureGenerator::isGroundEqc( TNode r ) { + return d_ground_eqc_map.find( r )!=d_ground_eqc_map.end(); +} + +bool ConjectureGenerator::isGroundTerm( TNode n ) { + return std::find( d_ground_terms.begin(), d_ground_terms.end(), n )!=d_ground_terms.end(); +} + +bool ConjectureGenerator::needsCheck( Theory::Effort e ) { + // synchonized with instantiation engine + return d_quantEngine->getInstWhenNeedsCheck( e ); +} + +bool ConjectureGenerator::hasEnumeratedUf( Node n ) { + if( options::conjectureGenGtEnum()>0 ){ + std::map< Node, bool >::iterator it = d_uf_enum.find( n.getOperator() ); + if( it==d_uf_enum.end() ){ + d_uf_enum[n.getOperator()] = true; + std::vector< Node > lem; + getEnumeratePredUfTerm( n, options::conjectureGenGtEnum(), lem ); + if( !lem.empty() ){ + for( unsigned j=0; j<lem.size(); j++ ){ + d_quantEngine->addLemma( lem[j], false ); + d_hasAddedLemma = true; + } + return false; + } + } + } + return true; +} + +void ConjectureGenerator::reset_round( Theory::Effort e ) { + +} + +void ConjectureGenerator::check( Theory::Effort e, unsigned quant_e ) { + if( quant_e==QuantifiersEngine::QEFFORT_STANDARD ){ + d_fullEffortCount++; + if( d_fullEffortCount%optFullCheckFrequency()==0 ){ + d_hasAddedLemma = false; + d_tge.d_cg = this; + double clSet = 0; + if( Trace.isOn("sg-engine") ){ + clSet = double(clock())/double(CLOCKS_PER_SEC); + Trace("sg-engine") << "---Conjecture Engine Round, effort = " << e << "---" << std::endl; + } + eq::EqualityEngine * ee = getEqualityEngine(); + d_conj_count = 0; + + Trace("sg-proc") << "Get eq classes..." << std::endl; + d_op_arg_index.clear(); + d_ground_eqc_map.clear(); + d_bool_eqc[0] = Node::null(); + d_bool_eqc[1] = Node::null(); + std::vector< TNode > eqcs; + d_em.clear(); + eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( ee ); + while( !eqcs_i.isFinished() ){ + TNode r = (*eqcs_i); + eqcs.push_back( r ); + if( r.getType().isBoolean() ){ + if( areEqual( r, getTermDatabase()->d_true ) ){ + d_ground_eqc_map[r] = getTermDatabase()->d_true; + d_bool_eqc[0] = r; + }else if( areEqual( r, getTermDatabase()->d_false ) ){ + d_ground_eqc_map[r] = getTermDatabase()->d_false; + d_bool_eqc[1] = r; + } + } + d_em[r] = eqcs.size(); + eq::EqClassIterator ieqc_i = eq::EqClassIterator( r, ee ); + while( !ieqc_i.isFinished() ){ + TNode n = (*ieqc_i); + if( getTermDatabase()->hasTermCurrent( n ) ){ + if( isHandledTerm( n ) ){ + d_op_arg_index[r].addTerm( this, n ); + } + } + ++ieqc_i; + } + ++eqcs_i; + } + Assert( !d_bool_eqc[0].isNull() ); + Assert( !d_bool_eqc[1].isNull() ); + d_urelevant_terms.clear(); + Trace("sg-proc") << "...done get eq classes" << std::endl; + + Trace("sg-proc") << "Determine ground EQC..." << std::endl; + bool success; + do{ + success = false; + for( unsigned i=0; i<eqcs.size(); i++ ){ + TNode r = eqcs[i]; + if( d_ground_eqc_map.find( r )==d_ground_eqc_map.end() ){ + std::vector< TNode > args; + Trace("sg-pat-debug") << "******* Get ground term for " << r << std::endl; + Node n; + if( getTermDatabase()->isInductionTerm( r ) ){ + n = d_op_arg_index[r].getGroundTerm( this, args ); + }else{ + n = r; + } + if( !n.isNull() ){ + Trace("sg-pat") << "Ground term for eqc " << r << " : " << std::endl; + Trace("sg-pat") << " " << n << std::endl; + d_ground_eqc_map[r] = n; + success = true; + }else{ + Trace("sg-pat-debug") << "...could not find ground term." << std::endl; + } + } + } + }while( success ); + //also get ground terms + d_ground_terms.clear(); + for( unsigned i=0; i<eqcs.size(); i++ ){ + TNode r = eqcs[i]; + d_op_arg_index[r].getGroundTerms( this, d_ground_terms ); + } + Trace("sg-proc") << "...done determine ground EQC" << std::endl; + + //debug printing + if( Trace.isOn("sg-gen-eqc") ){ + for( unsigned i=0; i<eqcs.size(); i++ ){ + TNode r = eqcs[i]; + //print out members + bool firstTime = true; + bool isFalse = areEqual( r, getTermDatabase()->d_false ); + eq::EqClassIterator eqc_i = eq::EqClassIterator( r, ee ); + while( !eqc_i.isFinished() ){ + TNode n = (*eqc_i); + if( getTermDatabase()->hasTermCurrent( n ) && !n.getAttribute(NoMatchAttribute()) && ( n.getKind()!=EQUAL || isFalse ) ){ + if( firstTime ){ + Trace("sg-gen-eqc") << "e" << d_em[r] << " : { " << std::endl; + firstTime = false; + } + if( n.hasOperator() ){ + Trace("sg-gen-eqc") << " (" << n.getOperator(); + getTermDatabase()->computeArgReps( n ); + for( unsigned i=0; i<getTermDatabase()->d_arg_reps[n].size(); i++ ){ + Trace("sg-gen-eqc") << " e" << d_em[getTermDatabase()->d_arg_reps[n][i]]; + } + Trace("sg-gen-eqc") << ") :: " << n << std::endl; + }else{ + Trace("sg-gen-eqc") << " " << n << std::endl; + } + } + ++eqc_i; + } + if( !firstTime ){ + Trace("sg-gen-eqc") << "}" << std::endl; + //print out ground term + std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r ); + if( it!=d_ground_eqc_map.end() ){ + Trace("sg-gen-eqc") << "- Ground term : " << it->second << std::endl; + } + } + } + } + + Trace("sg-proc") << "Compute relevant eqc..." << std::endl; + d_tge.d_relevant_eqc[0].clear(); + d_tge.d_relevant_eqc[1].clear(); + for( unsigned i=0; i<eqcs.size(); i++ ){ + TNode r = eqcs[i]; + std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r ); + unsigned index = 1; + if( it==d_ground_eqc_map.end() ){ + index = 0; + } + //based on unproven conjectures? TODO + d_tge.d_relevant_eqc[index].push_back( r ); + } + Trace("sg-gen-tg-debug") << "Initial relevant eqc : "; + for( unsigned i=0; i<d_tge.d_relevant_eqc[0].size(); i++ ){ + Trace("sg-gen-tg-debug") << "e" << d_em[d_tge.d_relevant_eqc[0][i]] << " "; + } + Trace("sg-gen-tg-debug") << std::endl; + Trace("sg-proc") << "...done compute relevant eqc" << std::endl; + + + Trace("sg-proc") << "Collect signature information..." << std::endl; + d_tge.collectSignatureInformation(); + if( d_hasAddedLemma ){ + Trace("sg-proc") << "...added enumeration lemmas." << std::endl; + } + Trace("sg-proc") << "...done collect signature information" << std::endl; + + + + Trace("sg-proc") << "Build theorem index..." << std::endl; + d_ue_canon.clear(); + d_thm_index.clear(); + std::vector< Node > provenConj; + quantifiers::FirstOrderModel* m = d_quantEngine->getModel(); + for( int i=0; i<m->getNumAssertedQuantifiers(); i++ ){ + Node q = m->getAssertedQuantifier( i ); + Trace("thm-db-debug") << "Is " << q << " a relevant theorem?" << std::endl; + Node conjEq; + if( q[1].getKind()==EQUAL ){ + bool isSubsume = false; + bool inEe = false; + for( unsigned r=0; r<2; r++ ){ + TNode nl = q[1][r==0 ? 0 : 1]; + TNode nr = q[1][r==0 ? 1 : 0]; + Node eq = nl.eqNode( nr ); + if( r==1 || std::find( d_conjectures.begin(), d_conjectures.end(), q )==d_conjectures.end() ){ + //must make it canonical + std::map< TypeNode, unsigned > var_count; + std::map< TNode, TNode > subs; + Trace("sg-proc-debug") << "get canonical " << eq << std::endl; + eq = getCanonicalTerm( eq, var_count, subs ); + } + if( !eq.isNull() ){ + if( r==0 ){ + inEe = d_ee_conjectures.find( q[1] )!=d_ee_conjectures.end(); + if( !inEe ){ + //add to universal equality engine + Node nl = getUniversalRepresentative( eq[0], true ); + Node nr = getUniversalRepresentative( eq[1], true ); + if( areUniversalEqual( nl, nr ) ){ + isSubsume = true; + //set inactive (will be ignored by other modules) + d_quantEngine->getModel()->setQuantifierActive( q, false ); + }else{ + Node exp; + d_ee_conjectures[q[1]] = true; + d_uequalityEngine.assertEquality( nl.eqNode( nr ), true, exp ); + } + } + Trace("sg-conjecture") << "*** CONJECTURE : currently proven" << (isSubsume ? " and subsumed" : ""); + Trace("sg-conjecture") << " : " << q[1] << std::endl; + provenConj.push_back( q ); + } + if( !isSubsume ){ + Trace("thm-db-debug") << "Adding theorem to database " << eq[0] << " == " << eq[1] << std::endl; + d_thm_index.addTheorem( eq[0], eq[1] ); + }else{ + break; + } + }else{ + break; + } + } + } + } + //examine status of other conjectures + for( unsigned i=0; i<d_conjectures.size(); i++ ){ + Node q = d_conjectures[i]; + if( std::find( provenConj.begin(), provenConj.end(), q )==provenConj.end() ){ + //check each skolem variable + bool disproven = true; + //std::vector< Node > sk; + //getTermDatabase()->getSkolemConstants( q, sk, true ); + Trace("sg-conjecture") << " CONJECTURE : "; + std::vector< Node > ce; + for( unsigned j=0; j<getTermDatabase()->d_skolem_constants[q].size(); j++ ){ + TNode k = getTermDatabase()->d_skolem_constants[q][j]; + TNode rk = getRepresentative( k ); + std::map< TNode, Node >::iterator git = d_ground_eqc_map.find( rk ); + //check if it is a ground term + if( git==d_ground_eqc_map.end() ){ + Trace("sg-conjecture") << "ACTIVE : " << q; + if( Trace.isOn("sg-gen-eqc") ){ + Trace("sg-conjecture") << " { "; + for( unsigned k=0; k<getTermDatabase()->d_skolem_constants[q].size(); k++ ){ Trace("sg-conjecture") << getTermDatabase()->d_skolem_constants[q][k] << ( j==k ? "*" : "" ) << " "; } + Trace("sg-conjecture") << "}"; + } + Trace("sg-conjecture") << std::endl; + disproven = false; + break; + }else{ + ce.push_back( git->second ); + } + } + if( disproven ){ + Trace("sg-conjecture") << "disproven : " << q << " : "; + for( unsigned i=0; i<ce.size(); i++ ){ + Trace("sg-conjecture") << q[0][i] << " -> " << ce[i] << " "; + } + Trace("sg-conjecture") << std::endl; + } + } + } + Trace("thm-db") << "Theorem database is : " << std::endl; + d_thm_index.debugPrint( "thm-db" ); + Trace("thm-db") << std::endl; + Trace("sg-proc") << "...done build theorem index" << std::endl; + + + //clear patterns + d_patterns.clear(); + d_pattern_var_id.clear(); + d_pattern_var_duplicate.clear(); + d_pattern_is_normal.clear(); + d_pattern_is_relevant.clear(); + d_pattern_fun_id.clear(); + d_pattern_fun_sum.clear(); + d_rel_patterns.clear(); + d_rel_pattern_var_sum.clear(); + d_rel_pattern_typ_index.clear(); + d_rel_pattern_subs_index.clear(); + + unsigned rel_term_count = 0; + std::map< TypeNode, unsigned > rt_var_max; + std::vector< TypeNode > rt_types; + std::map< TypeNode, std::map< int, std::vector< Node > > > conj_lhs; + unsigned addedLemmas = 0; + for( unsigned depth=1; depth<=3; depth++ ){ + Trace("sg-proc") << "Generate relevant LHS at depth " << depth << "..." << std::endl; + Trace("sg-rel-term") << "Relevant terms of depth " << depth << " : " << std::endl; + //set up environment + d_tge.d_var_id.clear(); + d_tge.d_var_limit.clear(); + d_tge.reset( depth, true, TypeNode::null() ); + while( d_tge.getNextTerm() ){ + //construct term + Node nn = d_tge.getTerm(); + if( !options::conjectureFilterCanonical() || considerTermCanon( nn, true ) ){ + rel_term_count++; + Trace("sg-rel-term") << "*** Relevant term : "; + d_tge.debugPrint( "sg-rel-term", "sg-rel-term-debug2" ); + Trace("sg-rel-term") << std::endl; + + for( unsigned r=0; r<2; r++ ){ + Trace("sg-rel-term-debug") << "...from equivalence classes (" << r << ") : "; + int index = d_tge.d_ccand_eqc[r].size()-1; + for( unsigned j=0; j<d_tge.d_ccand_eqc[r][index].size(); j++ ){ + Trace("sg-rel-term-debug") << "e" << d_em[d_tge.d_ccand_eqc[r][index][j]] << " "; + } + Trace("sg-rel-term-debug") << std::endl; + } + TypeNode tnn = nn.getType(); + Trace("sg-gen-tg-debug") << "...term is " << nn << std::endl; + conj_lhs[tnn][depth].push_back( nn ); + + //add information about pattern + Trace("sg-gen-tg-debug") << "Collect pattern information..." << std::endl; + Assert( std::find( d_rel_patterns[tnn].begin(), d_rel_patterns[tnn].end(), nn )==d_rel_patterns[tnn].end() ); + d_rel_patterns[tnn].push_back( nn ); + //build information concerning the variables in this pattern + unsigned sum = 0; + std::map< TypeNode, unsigned > typ_to_subs_index; + std::vector< TNode > gsubs_vars; + for( std::map< TypeNode, unsigned >::iterator it = d_tge.d_var_id.begin(); it != d_tge.d_var_id.end(); ++it ){ + if( it->second>0 ){ + typ_to_subs_index[it->first] = sum; + sum += it->second; + for( unsigned i=0; i<it->second; i++ ){ + gsubs_vars.push_back( getFreeVar( it->first, i ) ); + } + } + } + d_rel_pattern_var_sum[nn] = sum; + //register the pattern + registerPattern( nn, tnn ); + Assert( d_pattern_is_normal[nn] ); + Trace("sg-gen-tg-debug") << "...done collect pattern information" << std::endl; + + //record information about types + Trace("sg-gen-tg-debug") << "Collect type information..." << std::endl; + PatternTypIndex * pti = &d_rel_pattern_typ_index; + for( std::map< TypeNode, unsigned >::iterator it = d_tge.d_var_id.begin(); it != d_tge.d_var_id.end(); ++it ){ + pti = &pti->d_children[it->first][it->second]; + //record maximum + if( rt_var_max.find( it->first )==rt_var_max.end() || it->second>rt_var_max[it->first] ){ + rt_var_max[it->first] = it->second; + } + } + if( std::find( rt_types.begin(), rt_types.end(), tnn )==rt_types.end() ){ + rt_types.push_back( tnn ); + } + pti->d_terms.push_back( nn ); + Trace("sg-gen-tg-debug") << "...done collect type information" << std::endl; + + Trace("sg-gen-tg-debug") << "Build substitutions for ground EQC..." << std::endl; + std::vector< TNode > gsubs_terms; + gsubs_terms.resize( gsubs_vars.size() ); + int index = d_tge.d_ccand_eqc[1].size()-1; + for( unsigned j=0; j<d_tge.d_ccand_eqc[1][index].size(); j++ ){ + TNode r = d_tge.d_ccand_eqc[1][index][j]; + Trace("sg-rel-term-debug") << " Matches for e" << d_em[r] << ", which is ground term " << d_ground_eqc_map[r] << ":" << std::endl; + std::map< TypeNode, std::map< unsigned, TNode > > subs; + std::map< TNode, bool > rev_subs; + //only get ground terms + unsigned mode = 2; + d_tge.resetMatching( r, mode ); + while( d_tge.getNextMatch( r, subs, rev_subs ) ){ + //we will be building substitutions + bool firstTime = true; + for( std::map< TypeNode, std::map< unsigned, TNode > >::iterator it = subs.begin(); it != subs.end(); ++it ){ + unsigned tindex = typ_to_subs_index[it->first]; + for( std::map< unsigned, TNode >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){ + if( !firstTime ){ + Trace("sg-rel-term-debug") << ", "; + }else{ + firstTime = false; + Trace("sg-rel-term-debug") << " "; + } + Trace("sg-rel-term-debug") << it->first << ":x" << it2->first << " -> " << it2->second; + Assert( tindex+it2->first<gsubs_terms.size() ); + gsubs_terms[tindex+it2->first] = it2->second; + } + } + Trace("sg-rel-term-debug") << std::endl; + d_rel_pattern_subs_index[nn].addSubstitution( r, gsubs_vars, gsubs_terms ); + } + } + Trace("sg-gen-tg-debug") << "...done build substitutions for ground EQC" << std::endl; + }else{ + Trace("sg-gen-tg-debug") << "> not canonical : " << nn << std::endl; + } + } + Trace("sg-proc") << "...done generate terms at depth " << depth << std::endl; + Trace("sg-stats") << "--------> Total LHS of depth " << depth << " : " << rel_term_count << std::endl; + //Trace("conjecture-count") << "Total LHS of depth " << depth << " : " << conj_lhs[depth].size() << std::endl; + + /* test... + for( unsigned i=0; i<rt_types.size(); i++ ){ + Trace("sg-term-enum") << "Term enumeration for " << rt_types[i] << " : " << std::endl; + Trace("sg-term-enum") << "Ground term : " << rt_types[i].mkGroundTerm() << std::endl; + for( unsigned j=0; j<150; j++ ){ + Trace("sg-term-enum") << " " << getEnumerateTerm( rt_types[i], j ) << std::endl; + } + } + */ + + //consider types from relevant terms + for( unsigned rdepth=0; rdepth<=depth; rdepth++ ){ + //set up environment + d_tge.d_var_id.clear(); + d_tge.d_var_limit.clear(); + for( std::map< TypeNode, unsigned >::iterator it = rt_var_max.begin(); it != rt_var_max.end(); ++it ){ + d_tge.d_var_id[ it->first ] = it->second; + d_tge.d_var_limit[ it->first ] = it->second; + } + std::random_shuffle( rt_types.begin(), rt_types.end() ); + std::map< TypeNode, std::vector< Node > > conj_rhs; + for( unsigned i=0; i<rt_types.size(); i++ ){ + + Trace("sg-proc") << "Generate relevant RHS terms of type " << rt_types[i] << " at depth " << rdepth << "..." << std::endl; + d_tge.reset( rdepth, false, rt_types[i] ); + + while( d_tge.getNextTerm() ){ + Node rhs = d_tge.getTerm(); + if( considerTermCanon( rhs, false ) ){ + Trace("sg-rel-prop") << "Relevant RHS : " << rhs << std::endl; + //register pattern + Assert( rhs.getType()==rt_types[i] ); + registerPattern( rhs, rt_types[i] ); + if( rdepth<depth ){ + //consider against all LHS at depth + for( unsigned j=0; j<conj_lhs[rt_types[i]][depth].size(); j++ ){ + processCandidateConjecture( conj_lhs[rt_types[i]][depth][j], rhs, depth, rdepth ); + } + }else{ + conj_rhs[rt_types[i]].push_back( rhs ); + } + } + } + } + flushWaitingConjectures( addedLemmas, depth, rdepth ); + //consider against all LHS up to depth + if( rdepth==depth ){ + for( unsigned lhs_depth = 1; lhs_depth<=depth; lhs_depth++ ){ + if( (int)addedLemmas<options::conjectureGenPerRound() ){ + Trace("sg-proc") << "Consider conjectures at depth (" << lhs_depth << ", " << rdepth << ")..." << std::endl; + for( std::map< TypeNode, std::vector< Node > >::iterator it = conj_rhs.begin(); it != conj_rhs.end(); ++it ){ + for( unsigned j=0; j<it->second.size(); j++ ){ + for( unsigned k=0; k<conj_lhs[it->first][lhs_depth].size(); k++ ){ + processCandidateConjecture( conj_lhs[it->first][lhs_depth][k], it->second[j], lhs_depth, rdepth ); + } + } + } + flushWaitingConjectures( addedLemmas, lhs_depth, depth ); + } + } + } + if( (int)addedLemmas>=options::conjectureGenPerRound() ){ + break; + } + } + if( (int)addedLemmas>=options::conjectureGenPerRound() ){ + break; + } + } + Trace("sg-stats") << "Total conjectures considered : " << d_conj_count << std::endl; + if( Trace.isOn("thm-ee") ){ + Trace("thm-ee") << "Universal equality engine is : " << std::endl; + eq::EqClassesIterator ueqcs_i = eq::EqClassesIterator( &d_uequalityEngine ); + while( !ueqcs_i.isFinished() ){ + TNode r = (*ueqcs_i); + bool firstTime = true; + TNode rr = getUniversalRepresentative( r ); + Trace("thm-ee") << " " << rr; + Trace("thm-ee") << " : { "; + eq::EqClassIterator ueqc_i = eq::EqClassIterator( r, &d_uequalityEngine ); + while( !ueqc_i.isFinished() ){ + TNode n = (*ueqc_i); + if( rr!=n ){ + if( firstTime ){ + Trace("thm-ee") << std::endl; + firstTime = false; + } + Trace("thm-ee") << " " << n << std::endl; + } + ++ueqc_i; + } + if( !firstTime ){ Trace("thm-ee") << " "; } + Trace("thm-ee") << "}" << std::endl; + ++ueqcs_i; + } + Trace("thm-ee") << std::endl; + } + if( Trace.isOn("sg-engine") ){ + double clSet2 = double(clock())/double(CLOCKS_PER_SEC); + Trace("sg-engine") << "Finished conjecture generator, time = " << (clSet2-clSet) << std::endl; + } + } + } +} + +unsigned ConjectureGenerator::flushWaitingConjectures( unsigned& addedLemmas, int ldepth, int rdepth ) { + if( !d_waiting_conjectures_lhs.empty() ){ + Trace("sg-proc") << "Generated " << d_waiting_conjectures_lhs.size() << " conjectures at depth " << ldepth << "/" << rdepth << "." << std::endl; + if( (int)addedLemmas<options::conjectureGenPerRound() ){ + /* + std::vector< unsigned > indices; + for( unsigned i=0; i<d_waiting_conjectures_lhs.size(); i++ ){ + indices.push_back( i ); + } + bool doSort = false; + if( doSort ){ + //sort them based on score + sortConjectureScore scs; + scs.d_scores.insert( scs.d_scores.begin(), d_waiting_conjectures_score.begin(), d_waiting_conjectures_score.end() ); + std::sort( indices.begin(), indices.end(), scs ); + } + //if( doSort && d_waiting_conjectures_score[indices[0]]<optFilterScoreThreshold() ){ + */ + unsigned prevCount = d_conj_count; + for( unsigned i=0; i<d_waiting_conjectures_lhs.size(); i++ ){ + if( d_waiting_conjectures_score[i]>=optFilterScoreThreshold() ){ + //we have determined a relevant subgoal + Node lhs = d_waiting_conjectures_lhs[i]; + Node rhs = d_waiting_conjectures_rhs[i]; + if( options::conjectureFilterCanonical() && ( getUniversalRepresentative( lhs )!=lhs || getUniversalRepresentative( rhs )!=rhs ) ){ + //skip + }else{ + Trace("sg-engine") << "*** Consider conjecture : " << lhs << " == " << rhs << std::endl; + Trace("sg-engine-debug") << " score : " << d_waiting_conjectures_score[i] << std::endl; + if( optStatsOnly() ){ + d_conj_count++; + }else{ + std::vector< Node > bvs; + for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[lhs].begin(); it != d_pattern_var_id[lhs].end(); ++it ){ + for( unsigned i=0; i<=it->second; i++ ){ + bvs.push_back( getFreeVar( it->first, i ) ); + } + } + Node rsg; + if( !bvs.empty() ){ + Node bvl = NodeManager::currentNM()->mkNode( BOUND_VAR_LIST, bvs ); + rsg = NodeManager::currentNM()->mkNode( FORALL, bvl, lhs.eqNode( rhs ) ); + }else{ + rsg = lhs.eqNode( rhs ); + } + rsg = Rewriter::rewrite( rsg ); + d_conjectures.push_back( rsg ); + d_eq_conjectures[lhs].push_back( rhs ); + d_eq_conjectures[rhs].push_back( lhs ); + + Node lem = NodeManager::currentNM()->mkNode( OR, rsg.negate(), rsg ); + d_quantEngine->addLemma( lem, false ); + d_quantEngine->addRequirePhase( rsg, false ); + addedLemmas++; + if( (int)addedLemmas>=options::conjectureGenPerRound() ){ + break; + } + } + } + } + } + Trace("sg-proc") << "...have now added " << addedLemmas << " conjecture lemmas." << std::endl; + if( optStatsOnly() ){ + Trace("sg-stats") << "Generated " << (d_conj_count-prevCount) << " conjectures at depth " << ldepth << "/" << rdepth << "." << std::endl; + } + } + d_waiting_conjectures_lhs.clear(); + d_waiting_conjectures_rhs.clear(); + d_waiting_conjectures_score.clear(); + d_waiting_conjectures.clear(); + } + return addedLemmas; +} + +void ConjectureGenerator::registerQuantifier( Node q ) { + +} + +void ConjectureGenerator::assertNode( Node n ) { + +} + +bool ConjectureGenerator::considerTermCanon( Node ln, bool genRelevant ){ + if( !ln.isNull() ){ + //do not consider if it is non-canonical, and either: + // (1) we are not generating relevant terms, or + // (2) its canonical form is a generalization. + TNode lnr = getUniversalRepresentative( ln, true ); + if( lnr==ln ){ + markReportedCanon( ln ); + }else if( !genRelevant || isGeneralization( lnr, ln ) ){ + Trace("sg-gen-consider-term") << "Do not consider term, " << ln << " is not canonical representation (which is " << lnr << ")." << std::endl; + return false; + } + } + Trace("sg-gen-tg-debug") << "Will consider term canon " << ln << std::endl; + Trace("sg-gen-consider-term-debug") << std::endl; + return true; +} + +unsigned ConjectureGenerator::collectFunctions( TNode opat, TNode pat, std::map< TNode, unsigned >& funcs, + std::map< TypeNode, unsigned >& mnvn, std::map< TypeNode, unsigned >& mxvn ){ + if( pat.hasOperator() ){ + funcs[pat.getOperator()]++; + if( !d_tge.isRelevantFunc( pat.getOperator() ) ){ + d_pattern_is_relevant[opat] = false; + } + unsigned sum = 1; + for( unsigned i=0; i<pat.getNumChildren(); i++ ){ + sum += collectFunctions( opat, pat[i], funcs, mnvn, mxvn ); + } + return sum; + }else{ + Assert( pat.getNumChildren()==0 ); + funcs[pat]++; + //for variables + if( pat.getKind()==BOUND_VARIABLE ){ + if( funcs[pat]>1 ){ + //duplicate variable + d_pattern_var_duplicate[opat]++; + }else{ + //check for max/min + TypeNode tn = pat.getType(); + unsigned vn = d_free_var_num[pat]; + std::map< TypeNode, unsigned >::iterator it = mnvn.find( tn ); + if( it!=mnvn.end() ){ + if( vn<it->second ){ + d_pattern_is_normal[opat] = false; + mnvn[tn] = vn; + }else if( vn>mxvn[tn] ){ + if( vn!=mxvn[tn]+1 ){ + d_pattern_is_normal[opat] = false; + } + mxvn[tn] = vn; + } + }else{ + //first variable of this type + mnvn[tn] = vn; + mxvn[tn] = vn; + } + } + }else{ + d_pattern_is_relevant[opat] = false; + } + return 1; + } +} + +void ConjectureGenerator::registerPattern( Node pat, TypeNode tpat ) { + if( std::find( d_patterns[tpat].begin(), d_patterns[tpat].end(), pat )==d_patterns[tpat].end() ){ + d_patterns[TypeNode::null()].push_back( pat ); + d_patterns[tpat].push_back( pat ); + + Assert( d_pattern_fun_id.find( pat )==d_pattern_fun_id.end() ); + Assert( d_pattern_var_id.find( pat )==d_pattern_var_id.end() ); + + //collect functions + std::map< TypeNode, unsigned > mnvn; + d_pattern_fun_sum[pat] = collectFunctions( pat, pat, d_pattern_fun_id[pat], mnvn, d_pattern_var_id[pat] ); + if( d_pattern_is_normal.find( pat )==d_pattern_is_normal.end() ){ + d_pattern_is_normal[pat] = true; + } + if( d_pattern_is_relevant.find( pat )==d_pattern_is_relevant.end() ){ + d_pattern_is_relevant[pat] = true; + } + } +} + +bool ConjectureGenerator::isGeneralization( TNode patg, TNode pat, std::map< TNode, TNode >& subs ) { + if( patg.getKind()==BOUND_VARIABLE ){ + std::map< TNode, TNode >::iterator it = subs.find( patg ); + if( it!=subs.end() ){ + return it->second==pat; + }else{ + subs[patg] = pat; + return true; + } + }else{ + Assert( patg.hasOperator() ); + if( !pat.hasOperator() || patg.getOperator()!=pat.getOperator() ){ + return false; + }else{ + Assert( patg.getNumChildren()==pat.getNumChildren() ); + for( unsigned i=0; i<patg.getNumChildren(); i++ ){ + if( !isGeneralization( patg[i], pat[i], subs ) ){ + return false; + } + } + return true; + } + } +} + +int ConjectureGenerator::calculateGeneralizationDepth( TNode n, std::vector< TNode >& fv ) { + if( n.getKind()==BOUND_VARIABLE ){ + if( std::find( fv.begin(), fv.end(), n )==fv.end() ){ + fv.push_back( n ); + return 0; + }else{ + return 1; + } + }else{ + int depth = 1; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + depth += calculateGeneralizationDepth( n[i], fv ); + } + return depth; + } +} + +Node ConjectureGenerator::getPredicateForType( TypeNode tn ) { + std::map< TypeNode, Node >::iterator it = d_typ_pred.find( tn ); + if( it==d_typ_pred.end() ){ + TypeNode op_tn = NodeManager::currentNM()->mkFunctionType( tn, NodeManager::currentNM()->booleanType() ); + Node op = NodeManager::currentNM()->mkSkolem( "PE", op_tn, "was created by conjecture ground term enumerator." ); + d_typ_pred[tn] = op; + return op; + }else{ + return it->second; + } +} + +void ConjectureGenerator::getEnumerateUfTerm( Node n, unsigned num, std::vector< Node >& terms ) { + if( n.getNumChildren()>0 ){ + std::vector< int > vec; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + vec.push_back( 0 ); + } + vec.pop_back(); + int size_limit = 0; + int vec_sum = -1; + unsigned index = 0; + unsigned last_size = terms.size(); + while( terms.size()<num ){ + bool success = true; + if( vec_sum==-1 ){ + vec_sum = 0; + vec.push_back( size_limit ); + }else{ + //see if we can iterate current + if( vec_sum<size_limit && !getTermDatabase()->getEnumerateTerm( n[index].getType(), vec[index]+1 ).isNull() ){ + vec[index]++; + vec_sum++; + vec.push_back( size_limit - vec_sum ); + }else{ + vec_sum -= vec[index]; + vec[index] = 0; + index++; + if( index==n.getNumChildren() ){ + success = false; + } + } + } + if( success ){ + if( vec.size()==n.getNumChildren() ){ + Node lc = getTermDatabase()->getEnumerateTerm( n[vec.size()-1].getType(), vec[vec.size()-1] ); + if( !lc.isNull() ){ + for( unsigned i=0; i<vec.size(); i++ ){ + Trace("sg-gt-enum-debug") << vec[i] << " "; + } + Trace("sg-gt-enum-debug") << " / " << size_limit << std::endl; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + Trace("sg-gt-enum-debug") << n[i].getType() << " "; + } + Trace("sg-gt-enum-debug") << std::endl; + std::vector< Node > children; + children.push_back( n.getOperator() ); + for( unsigned i=0; i<(vec.size()-1); i++ ){ + Node nn = getTermDatabase()->getEnumerateTerm( n[i].getType(), vec[i] ); + Assert( !nn.isNull() ); + Assert( nn.getType()==n[i].getType() ); + children.push_back( nn ); + } + children.push_back( lc ); + Node n = NodeManager::currentNM()->mkNode( APPLY_UF, children ); + Trace("sg-gt-enum") << "Ground term enumerate : " << n << std::endl; + terms.push_back( n ); + } + vec.pop_back(); + index = 0; + } + }else{ + if( terms.size()>last_size ){ + last_size = terms.size(); + size_limit++; + for( unsigned i=0; i<vec.size(); i++ ){ + vec[i] = 0; + } + vec_sum = -1; + }else{ + return; + } + } + } + }else{ + terms.push_back( n ); + } +} + +void ConjectureGenerator::getEnumeratePredUfTerm( Node n, unsigned num, std::vector< Node >& terms ) { + std::vector< Node > uf_terms; + getEnumerateUfTerm( n, num, uf_terms ); + Node p = getPredicateForType( n.getType() ); + for( unsigned i=0; i<uf_terms.size(); i++ ){ + terms.push_back( NodeManager::currentNM()->mkNode( APPLY_UF, p, uf_terms[i] ) ); + } +} + +void ConjectureGenerator::processCandidateConjecture( TNode lhs, TNode rhs, unsigned lhs_depth, unsigned rhs_depth ) { + int score = considerCandidateConjecture( lhs, rhs ); + if( score>0 ){ + Trace("sg-conjecture") << "* Candidate conjecture : " << lhs << " == " << rhs << std::endl; + Trace("sg-conjecture-debug") << " LHS, RHS generalization depth : " << lhs_depth << ", " << rhs_depth << std::endl; + Trace("sg-conjecture-debug") << " confirmed = " << d_subs_confirmCount << ", #witnesses range = " << d_subs_confirmWitnessRange.size() << "." << std::endl; + Trace("sg-conjecture-debug") << " #witnesses for "; + bool firstTime = true; + for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + if( !firstTime ){ + Trace("sg-conjecture-debug") << ", "; + } + Trace("sg-conjecture-debug") << it->first << " : " << it->second.size(); + //if( it->second.size()==1 ){ + // Trace("sg-conjecture-debug") << " (" << it->second[0] << ")"; + //} + Trace("sg-conjecture-debug2") << " ("; + for( unsigned j=0; j<it->second.size(); j++ ){ + if( j>0 ){ Trace("sg-conjecture-debug2") << " "; } + Trace("sg-conjecture-debug2") << d_ground_eqc_map[it->second[j]]; + } + Trace("sg-conjecture-debug2") << ")"; + firstTime = false; + } + Trace("sg-conjecture-debug") << std::endl; + Trace("sg-conjecture-debug") << " unknown = " << d_subs_unkCount << std::endl; + //Assert( getUniversalRepresentative( rhs )==rhs ); + //Assert( getUniversalRepresentative( lhs )==lhs ); + d_waiting_conjectures_lhs.push_back( lhs ); + d_waiting_conjectures_rhs.push_back( rhs ); + d_waiting_conjectures_score.push_back( score ); + d_waiting_conjectures[lhs].push_back( rhs ); + d_waiting_conjectures[rhs].push_back( lhs ); + } +} + +int ConjectureGenerator::considerCandidateConjecture( TNode lhs, TNode rhs ) { + Assert( lhs.getType()==rhs.getType() ); + + Trace("sg-cconj-debug") << "Consider candidate conjecture : " << lhs << " == " << rhs << "?" << std::endl; + if( lhs==rhs ){ + Trace("sg-cconj-debug") << " -> trivial." << std::endl; + return -1; + }else{ + if( lhs.getKind()==APPLY_CONSTRUCTOR && rhs.getKind()==APPLY_CONSTRUCTOR ){ + Trace("sg-cconj-debug") << " -> irrelevant by syntactic analysis." << std::endl; + return -1; + } + //variables of LHS must subsume variables of RHS + for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[rhs].begin(); it != d_pattern_var_id[rhs].end(); ++it ){ + std::map< TypeNode, unsigned >::iterator itl = d_pattern_var_id[lhs].find( it->first ); + if( itl!=d_pattern_var_id[lhs].end() ){ + if( itl->second<it->second ){ + Trace("sg-cconj-debug") << " -> variables of sort " << it->first << " are not subsumed." << std::endl; + return -1; + }else{ + Trace("sg-cconj-debug2") << " variables of sort " << it->first << " are : " << itl->second << " vs " << it->second << std::endl; + } + }else{ + Trace("sg-cconj-debug") << " -> has no variables of sort " << it->first << "." << std::endl; + return -1; + } + } + + //currently active conjecture? + std::map< Node, std::vector< Node > >::iterator iteq = d_eq_conjectures.find( lhs ); + if( iteq!=d_eq_conjectures.end() ){ + if( std::find( iteq->second.begin(), iteq->second.end(), rhs )!=iteq->second.end() ){ + Trace("sg-cconj-debug") << " -> this conjecture is already active." << std::endl; + return -1; + } + } + //current a waiting conjecture? + std::map< Node, std::vector< Node > >::iterator itw = d_waiting_conjectures.find( lhs ); + if( itw!=d_waiting_conjectures.end() ){ + if( std::find( itw->second.begin(), itw->second.end(), rhs )!=itw->second.end() ){ + Trace("sg-cconj-debug") << " -> already are considering this conjecture." << std::endl; + return -1; + } + } + //check if canonical representation (should be, but for efficiency this is not guarenteed) + //if( options::conjectureFilterCanonical() && ( getUniversalRepresentative( lhs )!=lhs || getUniversalRepresentative( rhs )!=rhs ) ){ + // Trace("sg-cconj") << " -> after processing, not canonical." << std::endl; + // return -1; + //} + + int score; + bool scoreSet = false; + + Trace("sg-cconj") << "Consider possible candidate conjecture : " << lhs << " == " << rhs << "?" << std::endl; + //find witness for counterexample, if possible + if( options::conjectureFilterModel() ){ + Assert( d_rel_pattern_var_sum.find( lhs )!=d_rel_pattern_var_sum.end() ); + Trace("sg-cconj-debug") << "Notify substitutions over " << d_rel_pattern_var_sum[lhs] << " variables." << std::endl; + std::map< TNode, TNode > subs; + d_subs_confirmCount = 0; + d_subs_confirmWitnessRange.clear(); + d_subs_confirmWitnessDomain.clear(); + d_subs_unkCount = 0; + if( !d_rel_pattern_subs_index[lhs].notifySubstitutions( this, subs, rhs, d_rel_pattern_var_sum[lhs] ) ){ + Trace("sg-cconj") << " -> found witness that falsifies the conjecture." << std::endl; + return -1; + } + //score is the minimum number of distinct substitutions for a variable + for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + int num = (int)it->second.size(); + if( !scoreSet || num<score ){ + score = num; + scoreSet = true; + } + } + if( !scoreSet ){ + score = 0; + } + Trace("sg-cconj") << " confirmed = " << d_subs_confirmCount << ", #witnesses range = " << d_subs_confirmWitnessRange.size() << "." << std::endl; + for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + Trace("sg-cconj") << " #witnesses for " << it->first << " : " << it->second.size() << std::endl; + } + }else{ + score = 1; + } + + Trace("sg-cconj") << " -> SUCCESS." << std::endl; + Trace("sg-cconj") << " score : " << score << std::endl; + + return score; + } +} + +bool ConjectureGenerator::notifySubstitution( TNode glhs, std::map< TNode, TNode >& subs, TNode rhs ) { + if( Trace.isOn("sg-cconj-debug") ){ + Trace("sg-cconj-debug") << "Ground eqc for LHS : " << glhs << ", based on substituion: " << std::endl; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + Assert( getRepresentative( it->second )==it->second ); + Trace("sg-cconj-debug") << " " << it->first << " -> " << it->second << std::endl; + } + } + Trace("sg-cconj-debug") << "Evaluate RHS : : " << rhs << std::endl; + //get the representative of rhs with substitution subs + TNode grhs = getTermDatabase()->evaluateTerm( rhs, subs, true ); + Trace("sg-cconj-debug") << "...done evaluating term, got : " << grhs << std::endl; + if( !grhs.isNull() ){ + if( glhs!=grhs ){ + Trace("sg-cconj-debug") << "Ground eqc for RHS : " << grhs << std::endl; + //check based on ground terms + std::map< TNode, Node >::iterator itl = d_ground_eqc_map.find( glhs ); + if( itl!=d_ground_eqc_map.end() ){ + std::map< TNode, Node >::iterator itr = d_ground_eqc_map.find( grhs ); + if( itr!=d_ground_eqc_map.end() ){ + Trace("sg-cconj-debug") << "We have ground terms " << itl->second << " and " << itr->second << "." << std::endl; + if( itl->second.isConst() && itr->second.isConst() ){ + Trace("sg-cconj-debug") << "...disequal constants." << std::endl; + Trace("sg-cconj-witness") << " Witness of falsification : " << itl->second << " != " << itr->second << ", substutition is : " << std::endl; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + Trace("sg-cconj-witness") << " " << it->first << " -> " << it->second << std::endl; + } + return false; + } + } + } + } + Trace("sg-cconj-debug") << "RHS is identical." << std::endl; + bool isGroundSubs = true; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + std::map< TNode, Node >::iterator git = d_ground_eqc_map.find( it->second ); + if( git==d_ground_eqc_map.end() ){ + isGroundSubs = false; + break; + } + } + if( isGroundSubs ){ + if( glhs==grhs ){ + Trace("sg-cconj-witness") << " Witnessed " << glhs << " == " << grhs << ", substutition is : " << std::endl; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + Trace("sg-cconj-witness") << " " << it->first << " -> " << it->second << std::endl; + if( std::find( d_subs_confirmWitnessDomain[it->first].begin(), d_subs_confirmWitnessDomain[it->first].end(), it->second )==d_subs_confirmWitnessDomain[it->first].end() ){ + d_subs_confirmWitnessDomain[it->first].push_back( it->second ); + } + } + d_subs_confirmCount++; + if( std::find( d_subs_confirmWitnessRange.begin(), d_subs_confirmWitnessRange.end(), glhs )==d_subs_confirmWitnessRange.end() ){ + d_subs_confirmWitnessRange.push_back( glhs ); + } + }else{ + if( optFilterUnknown() ){ + Trace("sg-cconj-debug") << "...ground substitution giving terms that are neither equal nor disequal." << std::endl; + return false; + } + } + } + }else{ + Trace("sg-cconj-debug") << "(could not ground eqc for RHS)." << std::endl; + } + return true; +} + + + + + + +void TermGenerator::reset( TermGenEnv * s, TypeNode tn ) { + Assert( d_children.empty() ); + d_typ = tn; + d_status = 0; + d_status_num = 0; + d_children.clear(); + Trace("sg-gen-tg-debug2") << "...add to context " << this << std::endl; + d_id = s->d_tg_id; + s->changeContext( true ); +} + +bool TermGenerator::getNextTerm( TermGenEnv * s, unsigned depth ) { + if( Trace.isOn("sg-gen-tg-debug2") ){ + Trace("sg-gen-tg-debug2") << this << " getNextTerm depth " << depth << " : status = " << d_status << ", num = " << d_status_num; + if( d_status==5 ){ + TNode f = s->getTgFunc( d_typ, d_status_num ); + Trace("sg-gen-tg-debug2") << ", f = " << f; + Trace("sg-gen-tg-debug2") << ", #args = " << s->d_func_args[f].size(); + Trace("sg-gen-tg-debug2") << ", childNum = " << d_status_child_num; + Trace("sg-gen-tg-debug2") << ", #children = " << d_children.size(); + } + Trace("sg-gen-tg-debug2") << std::endl; + } + + if( d_status==0 ){ + d_status++; + if( !d_typ.isNull() ){ + if( s->allowVar( d_typ ) ){ + //allocate variable + d_status_num = s->d_var_id[d_typ]; + s->addVar( d_typ ); + Trace("sg-gen-tg-debug2") << this << " ...return unique var #" << d_status_num << std::endl; + return s->considerCurrentTerm() ? true : getNextTerm( s, depth ); + }else{ + //check allocating new variable + d_status++; + d_status_num = -1; + if( s->d_gen_relevant_terms ){ + s->d_tg_gdepth++; + } + return getNextTerm( s, depth ); + } + }else{ + d_status = 4; + d_status_num = -1; + return getNextTerm( s, depth ); + } + }else if( d_status==2 ){ + //cleanup previous information + //if( d_status_num>=0 ){ + // s->d_var_eq_tg[d_status_num].pop_back(); + //} + //check if there is another variable + if( (d_status_num+1)<(int)s->getNumTgVars( d_typ ) ){ + d_status_num++; + //we have equated two variables + //s->d_var_eq_tg[d_status_num].push_back( d_id ); + Trace("sg-gen-tg-debug2") << this << "...consider other var #" << d_status_num << std::endl; + return s->considerCurrentTerm() ? true : getNextTerm( s, depth ); + }else{ + if( s->d_gen_relevant_terms ){ + s->d_tg_gdepth--; + } + d_status++; + return getNextTerm( s, depth ); + } + }else if( d_status==4 ){ + d_status++; + if( depth>0 && (d_status_num+1)<(int)s->getNumTgFuncs( d_typ ) ){ + d_status_num++; + d_status_child_num = 0; + Trace("sg-gen-tg-debug2") << this << "...consider function " << s->getTgFunc( d_typ, d_status_num ) << std::endl; + s->d_tg_gdepth++; + if( !s->considerCurrentTerm() ){ + s->d_tg_gdepth--; + //don't consider this function + d_status--; + }else{ + //we have decided on a function application + } + return getNextTerm( s, depth ); + }else{ + //do not choose function applications at depth 0 + d_status++; + return getNextTerm( s, depth ); + } + }else if( d_status==5 ){ + //iterating over arguments + TNode f = s->getTgFunc( d_typ, d_status_num ); + if( d_status_child_num<0 ){ + //no more arguments + s->d_tg_gdepth--; + d_status--; + return getNextTerm( s, depth ); + }else if( d_status_child_num==(int)s->d_func_args[f].size() ){ + d_status_child_num--; + return s->considerCurrentTermCanon( d_id ) ? true : getNextTerm( s, depth ); + //return true; + }else{ + Assert( d_status_child_num<(int)s->d_func_args[f].size() ); + if( d_status_child_num==(int)d_children.size() ){ + d_children.push_back( s->d_tg_id ); + Assert( s->d_tg_alloc.find( s->d_tg_id )==s->d_tg_alloc.end() ); + s->d_tg_alloc[d_children[d_status_child_num]].reset( s, s->d_func_args[f][d_status_child_num] ); + return getNextTerm( s, depth ); + }else{ + Assert( d_status_child_num+1==(int)d_children.size() ); + if( s->d_tg_alloc[d_children[d_status_child_num]].getNextTerm( s, depth-1 ) ){ + d_status_child_num++; + return getNextTerm( s, depth ); + }else{ + d_children.pop_back(); + d_status_child_num--; + return getNextTerm( s, depth ); + } + } + } + }else if( d_status==1 || d_status==3 ){ + if( d_status==1 ){ + s->removeVar( d_typ ); + Assert( d_status_num==(int)s->d_var_id[d_typ] ); + //check if there is only one feasible equivalence class. if so, don't make pattern any more specific. + //unsigned i = s->d_ccand_eqc[0].size()-1; + //if( s->d_ccand_eqc[0][i].size()==1 && s->d_ccand_eqc[1][i].empty() ){ + // d_status = 6; + // return getNextTerm( s, depth ); + //} + s->d_tg_gdepth++; + } + d_status++; + d_status_num = -1; + return getNextTerm( s, depth ); + }else{ + //clean up + Assert( d_children.empty() ); + Trace("sg-gen-tg-debug2") << "...remove from context " << this << std::endl; + s->changeContext( false ); + Assert( d_id==s->d_tg_id ); + return false; + } +} + +void TermGenerator::resetMatching( TermGenEnv * s, TNode eqc, unsigned mode ) { + d_match_status = 0; + d_match_status_child_num = 0; + d_match_children.clear(); + d_match_children_end.clear(); + d_match_mode = mode; + //if this term generalizes, it must generalize a non-ground term + //if( (d_match_mode & ( 1 << 2 ))!=0 && s->isGroundEqc( eqc ) && d_status==5 ){ + // d_match_status = -1; + //} +} + +bool TermGenerator::getNextMatch( TermGenEnv * s, TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ) { + if( d_match_status<0 ){ + return false; + } + if( Trace.isOn("sg-gen-tg-match") ){ + Trace("sg-gen-tg-match") << "Matching "; + debugPrint( s, "sg-gen-tg-match", "sg-gen-tg-match" ); + Trace("sg-gen-tg-match") << " with eqc e" << s->d_cg->d_em[eqc] << "..." << std::endl; + Trace("sg-gen-tg-match") << " mstatus = " << d_match_status; + if( d_status==5 ){ + TNode f = s->getTgFunc( d_typ, d_status_num ); + Trace("sg-gen-tg-debug2") << ", f = " << f; + Trace("sg-gen-tg-debug2") << ", #args = " << s->d_func_args[f].size(); + Trace("sg-gen-tg-debug2") << ", mchildNum = " << d_match_status_child_num; + Trace("sg-gen-tg-debug2") << ", #mchildren = " << d_match_children.size(); + } + Trace("sg-gen-tg-debug2") << ", current substitution : {"; + for( std::map< TypeNode, std::map< unsigned, TNode > >::iterator itt = subs.begin(); itt != subs.end(); ++itt ){ + for( std::map< unsigned, TNode >::iterator it = itt->second.begin(); it != itt->second.end(); ++it ){ + Trace("sg-gen-tg-debug2") << " " << it->first << " -> e" << s->d_cg->d_em[it->second]; + } + } + Trace("sg-gen-tg-debug2") << " } " << std::endl; + } + if( d_status==1 ){ + //a variable + if( d_match_status==0 ){ + d_match_status++; + if( (d_match_mode & ( 1 << 1 ))!=0 ){ + //only ground terms + if( !s->isGroundEqc( eqc ) ){ + return false; + } + }else if( (d_match_mode & ( 1 << 2 ))!=0 ){ + //only non-ground terms + //if( s->isGroundEqc( eqc ) ){ + // return false; + //} + } + //store the match : restricted if match_mode.0 = 1 + if( (d_match_mode & ( 1 << 0 ))!=0 ){ + std::map< TNode, bool >::iterator it = rev_subs.find( eqc ); + if( it==rev_subs.end() ){ + rev_subs[eqc] = true; + }else{ + return false; + } + } + Assert( subs[d_typ].find( d_status_num )==subs[d_typ].end() ); + subs[d_typ][d_status_num] = eqc; + return true; + }else{ + //clean up + subs[d_typ].erase( d_status_num ); + if( (d_match_mode & ( 1 << 0 ))!=0 ){ + rev_subs.erase( eqc ); + } + return false; + } + }else if( d_status==2 ){ + if( d_match_status==0 ){ + d_match_status++; + Assert( d_status_num<(int)s->getNumTgVars( d_typ ) ); + std::map< unsigned, TNode >::iterator it = subs[d_typ].find( d_status_num ); + Assert( it!=subs[d_typ].end() ); + return it->second==eqc; + }else{ + return false; + } + }else if( d_status==5 ){ + //Assert( d_match_children.size()<=d_children.size() ); + //enumerating over f-applications in eqc + if( d_match_status_child_num<0 ){ + return false; + }else if( d_match_status==0 ){ + //set up next binding + if( d_match_status_child_num==(int)d_match_children.size() ){ + if( d_match_status_child_num==0 ){ + //initial binding + TNode f = s->getTgFunc( d_typ, d_status_num ); + std::map< TNode, TermArgTrie >::iterator it = s->getTermDatabase()->d_func_map_eqc_trie[f].d_data.find( eqc ); + if( it!=s->getTermDatabase()->d_func_map_eqc_trie[f].d_data.end() ){ + d_match_children.push_back( it->second.d_data.begin() ); + d_match_children_end.push_back( it->second.d_data.end() ); + }else{ + d_match_status++; + d_match_status_child_num--; + return getNextMatch( s, eqc, subs, rev_subs ); + } + }else{ + d_match_children.push_back( d_match_children[d_match_status_child_num-1]->second.d_data.begin() ); + d_match_children_end.push_back( d_match_children[d_match_status_child_num-1]->second.d_data.end() ); + } + } + d_match_status++; + Assert( d_match_status_child_num+1==(int)d_match_children.size() ); + if( d_match_children[d_match_status_child_num]==d_match_children_end[d_match_status_child_num] ){ + //no more arguments to bind + d_match_children.pop_back(); + d_match_children_end.pop_back(); + d_match_status_child_num--; + return getNextMatch( s, eqc, subs, rev_subs ); + }else{ + if( d_match_status_child_num==(int)d_children.size() ){ + //successfully matched all children + d_match_children.pop_back(); + d_match_children_end.pop_back(); + d_match_status_child_num--; + return true;//return d_match_children[d_match_status]!=d_match_children_end[d_match_status]; + }else{ + //do next binding + s->d_tg_alloc[d_children[d_match_status_child_num]].resetMatching( s, d_match_children[d_match_status_child_num]->first, d_match_mode ); + return getNextMatch( s, eqc, subs, rev_subs ); + } + } + }else{ + Assert( d_match_status==1 ); + Assert( d_match_status_child_num+1==(int)d_match_children.size() ); + Assert( d_match_children[d_match_status_child_num]!=d_match_children_end[d_match_status_child_num] ); + d_match_status--; + if( s->d_tg_alloc[d_children[d_match_status_child_num]].getNextMatch( s, d_match_children[d_match_status_child_num]->first, subs, rev_subs ) ){ + d_match_status_child_num++; + return getNextMatch( s, eqc, subs, rev_subs ); + }else{ + //iterate + d_match_children[d_match_status_child_num]++; + return getNextMatch( s, eqc, subs, rev_subs ); + } + } + } + Assert( false ); + return false; +} + +unsigned TermGenerator::getDepth( TermGenEnv * s ) { + if( d_status==5 ){ + unsigned maxd = 0; + for( unsigned i=0; i<d_children.size(); i++ ){ + unsigned d = s->d_tg_alloc[d_children[i]].getDepth( s ); + if( d>maxd ){ + maxd = d; + } + } + return 1+maxd; + }else{ + return 0; + } +} + +unsigned TermGenerator::calculateGeneralizationDepth( TermGenEnv * s, std::map< TypeNode, std::vector< int > >& fvs ) { + if( d_status==5 ){ + unsigned sum = 1; + for( unsigned i=0; i<d_children.size(); i++ ){ + sum += s->d_tg_alloc[d_children[i]].calculateGeneralizationDepth( s, fvs ); + } + return sum; + }else{ + Assert( d_status==2 || d_status==1 ); + std::map< TypeNode, std::vector< int > >::iterator it = fvs.find( d_typ ); + if( it!=fvs.end() ){ + if( std::find( it->second.begin(), it->second.end(), d_status_num )!=it->second.end() ){ + return 1; + } + } + fvs[d_typ].push_back( d_status_num ); + return 0; + } +} + +unsigned TermGenerator::getGeneralizationDepth( TermGenEnv * s ) { + //if( s->d_gen_relevant_terms ){ + // return s->d_tg_gdepth; + //}else{ + std::map< TypeNode, std::vector< int > > fvs; + return calculateGeneralizationDepth( s, fvs ); + //} +} + +Node TermGenerator::getTerm( TermGenEnv * s ) { + if( d_status==1 || d_status==2 ){ + Assert( !d_typ.isNull() ); + return s->getFreeVar( d_typ, d_status_num ); + }else if( d_status==5 ){ + Node f = s->getTgFunc( d_typ, d_status_num ); + if( d_children.size()==s->d_func_args[f].size() ){ + std::vector< Node > children; + if( s->d_tg_func_param[f] ){ + children.push_back( f ); + } + for( unsigned i=0; i<d_children.size(); i++ ){ + Node nc = s->d_tg_alloc[d_children[i]].getTerm( s ); + if( nc.isNull() ){ + return Node::null(); + }else{ + //Assert( nc.getType()==s->d_func_args[f][i] ); + children.push_back( nc ); + } + } + return NodeManager::currentNM()->mkNode( s->d_func_kind[f], children ); + } + }else{ + Assert( false ); + } + return Node::null(); +} + +void TermGenerator::debugPrint( TermGenEnv * s, const char * c, const char * cd ) { + Trace(cd) << "[*" << d_id << "," << d_status << "]:"; + if( d_status==1 || d_status==2 ){ + Trace(c) << s->getFreeVar( d_typ, d_status_num ); + }else if( d_status==5 ){ + TNode f = s->getTgFunc( d_typ, d_status_num ); + Trace(c) << "(" << f; + for( unsigned i=0; i<d_children.size(); i++ ){ + Trace(c) << " "; + s->d_tg_alloc[d_children[i]].debugPrint( s, c, cd ); + } + if( d_children.size()<s->d_func_args[f].size() ){ + Trace(c) << " ..."; + } + Trace(c) << ")"; + }else{ + Trace(c) << "???"; + } +} + +void TermGenEnv::collectSignatureInformation() { + d_typ_tg_funcs.clear(); + d_funcs.clear(); + d_func_kind.clear(); + d_func_args.clear(); + TypeNode tnull; + for( std::map< Node, TermArgTrie >::iterator it = getTermDatabase()->d_func_map_trie.begin(); it != getTermDatabase()->d_func_map_trie.end(); ++it ){ + if( !getTermDatabase()->d_op_map[it->first].empty() ){ + Node nn = getTermDatabase()->d_op_map[it->first][0]; + if( d_cg->isHandledTerm( nn ) && nn.getKind()!=APPLY_SELECTOR_TOTAL && !nn.getType().isBoolean() ){ + bool do_enum = true; + //check if we have enumerated ground terms + if( nn.getKind()==APPLY_UF ){ + if( !d_cg->hasEnumeratedUf( nn ) ){ + do_enum = false; + } + } + if( do_enum ){ + d_funcs.push_back( it->first ); + for( unsigned i=0; i<nn.getNumChildren(); i++ ){ + d_func_args[it->first].push_back( nn[i].getType() ); + } + d_func_kind[it->first] = nn.getKind(); + d_typ_tg_funcs[tnull].push_back( it->first ); + d_typ_tg_funcs[nn.getType()].push_back( it->first ); + d_tg_func_param[it->first] = ( nn.getMetaKind() == kind::metakind::PARAMETERIZED ); + Trace("sg-rel-sig") << "Will enumerate function applications of : " << it->first << ", #args = " << d_func_args[it->first].size() << ", kind = " << nn.getKind() << std::endl; + getTermDatabase()->computeUfEqcTerms( it->first ); + } + } + } + } + //shuffle functions + for( std::map< TypeNode, std::vector< TNode > >::iterator it = d_typ_tg_funcs.begin(); it != d_typ_tg_funcs.end(); ++it ){ + std::random_shuffle( it->second.begin(), it->second.end() ); + if( it->first.isNull() ){ + Trace("sg-gen-tg-debug") << "In this order : "; + for( unsigned i=0; i<it->second.size(); i++ ){ + Trace("sg-gen-tg-debug") << it->second[i] << " "; + } + Trace("sg-gen-tg-debug") << std::endl; + } + } +} + +void TermGenEnv::reset( unsigned depth, bool genRelevant, TypeNode tn ) { + Assert( d_tg_alloc.empty() ); + d_tg_alloc.clear(); + + if( genRelevant ){ + for( unsigned i=0; i<2; i++ ){ + d_ccand_eqc[i].clear(); + d_ccand_eqc[i].push_back( d_relevant_eqc[i] ); + } + } + + d_tg_id = 0; + d_tg_gdepth = 0; + d_tg_gdepth_limit = depth; + d_gen_relevant_terms = genRelevant; + d_tg_alloc[0].reset( this, tn ); +} + +bool TermGenEnv::getNextTerm() { + if( d_tg_alloc[0].getNextTerm( this, d_tg_gdepth_limit ) ){ + Assert( (int)d_tg_alloc[0].getGeneralizationDepth( this )<=d_tg_gdepth_limit ); + if( (int)d_tg_alloc[0].getGeneralizationDepth( this )!=d_tg_gdepth_limit ){ + return getNextTerm(); + }else{ + return true; + } + }else{ + return false; + } +} + +//reset matching +void TermGenEnv::resetMatching( TNode eqc, unsigned mode ) { + d_tg_alloc[0].resetMatching( this, eqc, mode ); +} + +//get next match +bool TermGenEnv::getNextMatch( TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ) { + return d_tg_alloc[0].getNextMatch( this, eqc, subs, rev_subs ); +} + +//get term +Node TermGenEnv::getTerm() { + return d_tg_alloc[0].getTerm( this ); +} + +void TermGenEnv::debugPrint( const char * c, const char * cd ) { + d_tg_alloc[0].debugPrint( this, c, cd ); +} + +unsigned TermGenEnv::getNumTgVars( TypeNode tn ) { + return d_var_id[tn]; +} + +bool TermGenEnv::allowVar( TypeNode tn ) { + std::map< TypeNode, unsigned >::iterator it = d_var_limit.find( tn ); + if( it==d_var_limit.end() ){ + return true; + }else{ + return d_var_id[tn]<it->second; + } +} + +void TermGenEnv::addVar( TypeNode tn ) { + d_var_id[tn]++; +} + +void TermGenEnv::removeVar( TypeNode tn ) { + d_var_id[tn]--; + //d_var_eq_tg.pop_back(); + //d_var_tg.pop_back(); +} + +unsigned TermGenEnv::getNumTgFuncs( TypeNode tn ) { + return d_typ_tg_funcs[tn].size(); +} + +TNode TermGenEnv::getTgFunc( TypeNode tn, unsigned i ) { + return d_typ_tg_funcs[tn][i]; +} + +Node TermGenEnv::getFreeVar( TypeNode tn, unsigned i ) { + return d_cg->getFreeVar( tn, i ); +} + +bool TermGenEnv::considerCurrentTerm() { + Assert( !d_tg_alloc.empty() ); + + //if generalization depth is too large, don't consider it + unsigned i = d_tg_alloc.size(); + Trace("sg-gen-tg-debug") << "Consider term "; + d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" ); + Trace("sg-gen-tg-debug") << "? curr term size = " << d_tg_alloc.size() << ", last status = " << d_tg_alloc[i-1].d_status; + Trace("sg-gen-tg-debug") << std::endl; + + if( d_tg_gdepth_limit>=0 && d_tg_alloc[0].getGeneralizationDepth( this )>(unsigned)d_tg_gdepth_limit ){ + Trace("sg-gen-consider-term") << "-> generalization depth of "; + d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-tg-debug" ); + Trace("sg-gen-consider-term") << " is too high " << d_tg_gdepth << " " << d_tg_alloc[0].getGeneralizationDepth( this ) << ", do not consider." << std::endl; + return false; + } + + //----optimizations + /* + if( d_tg_alloc[i-1].d_status==1 ){ + }else if( d_tg_alloc[i-1].d_status==2 ){ + }else if( d_tg_alloc[i-1].d_status==5 ){ + }else{ + Trace("sg-gen-tg-debug") << "Bad tg: " << &d_tg_alloc[i-1] << std::endl; + Assert( false ); + } + */ + //if equated two variables, first check if context-independent TODO + //----end optimizations + + + //check based on which candidate equivalence classes match + if( d_gen_relevant_terms ){ + Trace("sg-gen-tg-debug") << "Filter based on relevant ground EQC"; + Trace("sg-gen-tg-debug") << ", #eqc to try = " << d_ccand_eqc[0][i-1].size() << "/" << d_ccand_eqc[1][i-1].size() << std::endl; + + Assert( d_ccand_eqc[0].size()>=2 ); + Assert( d_ccand_eqc[0].size()==d_ccand_eqc[1].size() ); + Assert( d_ccand_eqc[0].size()==d_tg_id+1 ); + Assert( d_tg_id==d_tg_alloc.size() ); + for( unsigned r=0; r<2; r++ ){ + d_ccand_eqc[r][i].clear(); + } + + //re-check feasibility of EQC + for( unsigned r=0; r<2; r++ ){ + for( unsigned j=0; j<d_ccand_eqc[r][i-1].size(); j++ ){ + std::map< TypeNode, std::map< unsigned, TNode > > subs; + std::map< TNode, bool > rev_subs; + unsigned mode; + if( r==0 ){ + mode = d_cg->optReqDistinctVarPatterns() ? ( 1 << 0 ) : 0; + mode = mode | (1 << 2 ); + }else{ + mode = 1 << 1; + } + d_tg_alloc[0].resetMatching( this, d_ccand_eqc[r][i-1][j], mode ); + if( d_tg_alloc[0].getNextMatch( this, d_ccand_eqc[r][i-1][j], subs, rev_subs ) ){ + d_ccand_eqc[r][i].push_back( d_ccand_eqc[r][i-1][j] ); + } + } + } + for( unsigned r=0; r<2; r++ ){ + Trace("sg-gen-tg-debug") << "Current eqc of type " << r << " : "; + for( unsigned j=0; j<d_ccand_eqc[r][i].size(); j++ ){ + Trace("sg-gen-tg-debug") << "e" << d_cg->d_em[d_ccand_eqc[r][i][j]] << " "; + } + Trace("sg-gen-tg-debug") << std::endl; + } + if( options::conjectureFilterActiveTerms() && d_ccand_eqc[0][i].empty() ){ + Trace("sg-gen-consider-term") << "Do not consider term of form "; + d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-consider-term-debug" ); + Trace("sg-gen-consider-term") << " since no relevant EQC matches it." << std::endl; + return false; + } + if( options::conjectureFilterModel() && d_ccand_eqc[1][i].empty() ){ + Trace("sg-gen-consider-term") << "Do not consider term of form "; + d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-consider-term-debug" ); + Trace("sg-gen-consider-term") << " since no ground EQC matches it." << std::endl; + return false; + } + } + Trace("sg-gen-tg-debug") << "Will consider term "; + d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" ); + Trace("sg-gen-tg-debug") << std::endl; + Trace("sg-gen-consider-term-debug") << std::endl; + return true; +} + +void TermGenEnv::changeContext( bool add ) { + if( add ){ + for( unsigned r=0; r<2; r++ ){ + d_ccand_eqc[r].push_back( std::vector< TNode >() ); + } + d_tg_id++; + }else{ + for( unsigned r=0; r<2; r++ ){ + d_ccand_eqc[r].pop_back(); + } + d_tg_id--; + Assert( d_tg_alloc.find( d_tg_id )!=d_tg_alloc.end() ); + d_tg_alloc.erase( d_tg_id ); + } +} + +bool TermGenEnv::considerCurrentTermCanon( unsigned tg_id ){ + Assert( tg_id<d_tg_alloc.size() ); + if( options::conjectureFilterCanonical() ){ + //check based on a canonicity of the term (if there is one) + Trace("sg-gen-tg-debug") << "Consider term canon "; + d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" ); + Trace("sg-gen-tg-debug") << ", tg is [" << tg_id << "]..." << std::endl; + + Node ln = d_tg_alloc[tg_id].getTerm( this ); + Trace("sg-gen-tg-debug") << "Term is " << ln << std::endl; + return d_cg->considerTermCanon( ln, d_gen_relevant_terms ); + } + return true; +} + +bool TermGenEnv::isRelevantFunc( Node f ) { + return std::find( d_funcs.begin(), d_funcs.end(), f )!=d_funcs.end(); +} +TermDb * TermGenEnv::getTermDatabase() { + return d_cg->getTermDatabase(); +} +Node TermGenEnv::getGroundEqc( TNode r ) { + return d_cg->getGroundEqc( r ); +} +bool TermGenEnv::isGroundEqc( TNode r ){ + return d_cg->isGroundEqc( r ); +} +bool TermGenEnv::isGroundTerm( TNode n ){ + return d_cg->isGroundTerm( n ); +} + + +void SubstitutionIndex::addSubstitution( TNode eqc, std::vector< TNode >& vars, std::vector< TNode >& terms, unsigned i ) { + if( i==vars.size() ){ + d_var = eqc; + }else{ + Assert( d_var.isNull() || d_var==vars[i] ); + d_var = vars[i]; + d_children[terms[i]].addSubstitution( eqc, vars, terms, i+1 ); + } +} + +bool SubstitutionIndex::notifySubstitutions( ConjectureGenerator * s, std::map< TNode, TNode >& subs, TNode rhs, unsigned numVars, unsigned i ) { + if( i==numVars ){ + Assert( d_children.empty() ); + return s->notifySubstitution( d_var, subs, rhs ); + }else{ + Assert( i==0 || !d_children.empty() ); + for( std::map< TNode, SubstitutionIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){ + Trace("sg-cconj-debug2") << "Try " << d_var << " -> " << it->first << " (" << i << "/" << numVars << ")" << std::endl; + subs[d_var] = it->first; + if( !it->second.notifySubstitutions( s, subs, rhs, numVars, i+1 ) ){ + return false; + } + } + return true; + } +} + + +void TheoremIndex::addTheorem( std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ){ + if( lhs_v.empty() ){ + if( std::find( d_terms.begin(), d_terms.end(), rhs )==d_terms.end() ){ + d_terms.push_back( rhs ); + } + }else{ + unsigned index = lhs_v.size()-1; + if( lhs_arg[index]==lhs_v[index].getNumChildren() ){ + lhs_v.pop_back(); + lhs_arg.pop_back(); + addTheorem( lhs_v, lhs_arg, rhs ); + }else{ + lhs_arg[index]++; + addTheoremNode( lhs_v[index][lhs_arg[index]-1], lhs_v, lhs_arg, rhs ); + } + } +} + +void TheoremIndex::addTheoremNode( TNode curr, std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ){ + Trace("thm-db-debug") << "Adding conjecture for subterm " << curr << "..." << std::endl; + if( curr.hasOperator() ){ + lhs_v.push_back( curr ); + lhs_arg.push_back( 0 ); + d_children[curr.getOperator()].addTheorem( lhs_v, lhs_arg, rhs ); + }else{ + Assert( curr.getKind()==kind::BOUND_VARIABLE ); + TypeNode tn = curr.getType(); + Assert( d_var[tn].isNull() || d_var[tn]==curr ); + d_var[tn] = curr; + d_children[curr].addTheorem( lhs_v, lhs_arg, rhs ); + } +} + +void TheoremIndex::getEquivalentTerms( std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ) { + Trace("thm-db-debug") << "Get equivalent terms " << n_v.size() << " " << n_arg.size() << std::endl; + if( n_v.empty() ){ + Trace("thm-db-debug") << "Number of terms : " << d_terms.size() << std::endl; + //apply substutitions to RHS's + for( unsigned i=0; i<d_terms.size(); i++ ){ + Node n = d_terms[i].substitute( vars.begin(), vars.end(), subs.begin(), subs.end() ); + terms.push_back( n ); + } + }else{ + unsigned index = n_v.size()-1; + if( n_arg[index]==n_v[index].getNumChildren() ){ + n_v.pop_back(); + n_arg.pop_back(); + getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms ); + }else{ + n_arg[index]++; + getEquivalentTermsNode( n_v[index][n_arg[index]-1], n_v, n_arg, smap, vars, subs, terms ); + } + } +} + +void TheoremIndex::getEquivalentTermsNode( Node curr, std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ) { + Trace("thm-db-debug") << "Get equivalent based on subterm " << curr << "..." << std::endl; + if( curr.hasOperator() ){ + Trace("thm-db-debug") << "Check based on operator..." << std::endl; + std::map< TNode, TheoremIndex >::iterator it = d_children.find( curr.getOperator() ); + if( it!=d_children.end() ){ + n_v.push_back( curr ); + n_arg.push_back( 0 ); + it->second.getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms ); + } + Trace("thm-db-debug") << "...done check based on operator" << std::endl; + } + TypeNode tn = curr.getType(); + std::map< TypeNode, TNode >::iterator itt = d_var.find( tn ); + if( itt!=d_var.end() ){ + Trace("thm-db-debug") << "Check for substitution with " << itt->second << "..." << std::endl; + Assert( curr.getType()==itt->second.getType() ); + //add to substitution if possible + bool success = false; + std::map< TNode, TNode >::iterator it = smap.find( itt->second ); + if( it==smap.end() ){ + smap[itt->second] = curr; + vars.push_back( itt->second ); + subs.push_back( curr ); + success = true; + }else if( it->second==curr ){ + success = true; + }else{ + //also check modulo equality (in universal equality engine) + } + Trace("thm-db-debug") << "...check for substitution with " << itt->second << ", success = " << success << "." << std::endl; + if( success ){ + d_children[itt->second].getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms ); + } + } +} + +void TheoremIndex::debugPrint( const char * c, unsigned ind ) { + for( std::map< TNode, TheoremIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){ + for( unsigned i=0; i<ind; i++ ){ Trace(c) << " "; } + Trace(c) << it->first << std::endl; + it->second.debugPrint( c, ind+1 ); + } + if( !d_terms.empty() ){ + for( unsigned i=0; i<ind; i++ ){ Trace(c) << " "; } + Trace(c) << "{"; + for( unsigned i=0; i<d_terms.size(); i++ ){ + Trace(c) << " " << d_terms[i]; + } + Trace(c) << " }" << std::endl; + } + //if( !d_var.isNull() ){ + // for( unsigned i=0; i<ind; i++ ){ Trace(c) << " "; } + // Trace(c) << "var:" << d_var << std::endl; + //} +} + +bool ConjectureGenerator::optReqDistinctVarPatterns() { return false; } +bool ConjectureGenerator::optFilterUnknown() { return true; } //may change +int ConjectureGenerator::optFilterScoreThreshold() { return 1; } +unsigned ConjectureGenerator::optFullCheckFrequency() { return 1; } + +bool ConjectureGenerator::optStatsOnly() { return false; } + +} diff --git a/src/theory/quantifiers/conjecture_generator.h b/src/theory/quantifiers/conjecture_generator.h index 48694c99a..6f99777f4 100644 --- a/src/theory/quantifiers/conjecture_generator.h +++ b/src/theory/quantifiers/conjecture_generator.h @@ -1,437 +1,437 @@ -/********************* */
-/*! \file conjecture_generator.h
- ** \verbatim
- ** Original author: Andrew Reynolds
- ** Major contributors: none
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief conjecture generator class
- **/
-
-#include "cvc4_private.h"
-
-#ifndef CONJECTURE_GENERATOR_H
-#define CONJECTURE_GENERATOR_H
-
-#include "context/cdhashmap.h"
-#include "context/cdchunk_list.h"
-#include "theory/quantifiers_engine.h"
-#include "theory/type_enumerator.h"
-
-namespace CVC4 {
-namespace theory {
-namespace quantifiers {
-
-class TermArgTrie;
-
-//algorithm for computing candidate subgoals
-
-class ConjectureGenerator;
-
-// operator independent index of arguments for an EQC
-class OpArgIndex
-{
-public:
- std::map< TNode, OpArgIndex > d_child;
- std::vector< TNode > d_ops;
- std::vector< TNode > d_op_terms;
- void addTerm( ConjectureGenerator * s, TNode n, unsigned index = 0 );
- Node getGroundTerm( ConjectureGenerator * s, std::vector< TNode >& args );
- void getGroundTerms( ConjectureGenerator * s, std::vector< TNode >& terms );
-};
-
-class PatternTypIndex
-{
-public:
- std::vector< TNode > d_terms;
- std::map< TypeNode, std::map< unsigned, PatternTypIndex > > d_children;
- void clear() {
- d_terms.clear();
- d_children.clear();
- }
-};
-
-class SubstitutionIndex
-{
-public:
- //current variable, or ground EQC if d_children.empty()
- TNode d_var;
- std::map< TNode, SubstitutionIndex > d_children;
- //add substitution
- void addSubstitution( TNode eqc, std::vector< TNode >& vars, std::vector< TNode >& terms, unsigned i = 0 );
- //notify substitutions
- bool notifySubstitutions( ConjectureGenerator * s, std::map< TNode, TNode >& subs, TNode rhs, unsigned numVars, unsigned i = 0 );
-};
-
-class TermGenEnv;
-
-class TermGenerator
-{
-private:
- unsigned calculateGeneralizationDepth( TermGenEnv * s, std::map< TypeNode, std::vector< int > >& fvs );
-public:
- TermGenerator(){}
- TypeNode d_typ;
- unsigned d_id;
- //1 : consider as unique variable
- //2 : consider equal to another variable
- //5 : consider a function application
- unsigned d_status;
- int d_status_num;
- //for function applications: the number of children you have built
- int d_status_child_num;
- //children (pointers to TermGenerators)
- std::vector< unsigned > d_children;
-
- //match status
- int d_match_status;
- int d_match_status_child_num;
- //match mode bits
- //0 : different variables must have different matches
- //1 : variables must map to ground terms
- //2 : variables must map to non-ground terms
- unsigned d_match_mode;
- //children
- std::vector< std::map< TNode, TermArgTrie >::iterator > d_match_children;
- std::vector< std::map< TNode, TermArgTrie >::iterator > d_match_children_end;
-
- void reset( TermGenEnv * s, TypeNode tn );
- bool getNextTerm( TermGenEnv * s, unsigned depth );
- void resetMatching( TermGenEnv * s, TNode eqc, unsigned mode );
- bool getNextMatch( TermGenEnv * s, TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs );
-
- unsigned getDepth( TermGenEnv * s );
- unsigned getGeneralizationDepth( TermGenEnv * s );
- Node getTerm( TermGenEnv * s );
-
- void debugPrint( TermGenEnv * s, const char * c, const char * cd );
-};
-
-
-class TermGenEnv
-{
-public:
- //collect signature information
- void collectSignatureInformation();
- //reset function
- void reset( unsigned gdepth, bool genRelevant, TypeNode tgen );
- //get next term
- bool getNextTerm();
- //reset matching
- void resetMatching( TNode eqc, unsigned mode );
- //get next match
- bool getNextMatch( TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs );
- //get term
- Node getTerm();
- //debug print
- void debugPrint( const char * c, const char * cd );
-
- //conjecture generation
- ConjectureGenerator * d_cg;
- //the current number of enumerated variables per type
- std::map< TypeNode, unsigned > d_var_id;
- //the limit of number of variables per type to enumerate
- std::map< TypeNode, unsigned > d_var_limit;
- //the functions we can currently generate
- std::map< TypeNode, std::vector< TNode > > d_typ_tg_funcs;
- // whether functions must add operators
- std::map< TNode, bool > d_tg_func_param;
- //the equivalence classes (if applicable) that match the currently generated term
- bool d_gen_relevant_terms;
- //relevant equivalence classes
- std::vector< TNode > d_relevant_eqc[2];
- //candidate equivalence classes
- std::vector< std::vector< TNode > > d_ccand_eqc[2];
- //the term generation objects
- unsigned d_tg_id;
- std::map< unsigned, TermGenerator > d_tg_alloc;
- unsigned d_tg_gdepth;
- int d_tg_gdepth_limit;
-
- //all functions
- std::vector< TNode > d_funcs;
- //function to kind map
- std::map< TNode, Kind > d_func_kind;
- //type of each argument of the function
- std::map< TNode, std::vector< TypeNode > > d_func_args;
-
- //access functions
- unsigned getNumTgVars( TypeNode tn );
- bool allowVar( TypeNode tn );
- void addVar( TypeNode tn );
- void removeVar( TypeNode tn );
- unsigned getNumTgFuncs( TypeNode tn );
- TNode getTgFunc( TypeNode tn, unsigned i );
- Node getFreeVar( TypeNode tn, unsigned i );
- bool considerCurrentTerm();
- bool considerCurrentTermCanon( unsigned tg_id );
- void changeContext( bool add );
- bool isRelevantFunc( Node f );
- //carry
- TermDb * getTermDatabase();
- Node getGroundEqc( TNode r );
- bool isGroundEqc( TNode r );
- bool isGroundTerm( TNode n );
-};
-
-
-
-class TheoremIndex
-{
-private:
- void addTheorem( std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs );
- void addTheoremNode( TNode curr, std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs );
- void getEquivalentTerms( std::vector< TNode >& n_v, std::vector< unsigned >& n_arg,
- std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs,
- std::vector< Node >& terms );
- void getEquivalentTermsNode( Node curr, std::vector< TNode >& n_v, std::vector< unsigned >& n_arg,
- std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs,
- std::vector< Node >& terms );
-public:
- std::map< TypeNode, TNode > d_var;
- std::map< TNode, TheoremIndex > d_children;
- std::vector< Node > d_terms;
-
- void addTheorem( TNode lhs, TNode rhs ) {
- std::vector< TNode > v;
- std::vector< unsigned > a;
- addTheoremNode( lhs, v, a, rhs );
- }
- void getEquivalentTerms( TNode n, std::vector< Node >& terms ) {
- std::vector< TNode > nv;
- std::vector< unsigned > na;
- std::map< TNode, TNode > smap;
- std::vector< TNode > vars;
- std::vector< TNode > subs;
- getEquivalentTermsNode( n, nv, na, smap, vars, subs, terms );
- }
- void clear(){
- d_var.clear();
- d_children.clear();
- d_terms.clear();
- }
- void debugPrint( const char * c, unsigned ind = 0 );
-};
-
-
-
-class ConjectureGenerator : public QuantifiersModule
-{
- friend class OpArgIndex;
- friend class PatGen;
- friend class PatternGenEqc;
- friend class PatternGen;
- friend class SubsEqcIndex;
- friend class TermGenerator;
- friend class TermGenEnv;
- typedef context::CDChunkList<Node> NodeList;
- typedef context::CDHashMap< Node, Node, NodeHashFunction > NodeMap;
- typedef context::CDHashMap< Node, bool, NodeHashFunction > BoolMap;
-//this class maintains a congruence closure for *universal* facts
-private:
- //notification class for equality engine
- class NotifyClass : public eq::EqualityEngineNotify {
- ConjectureGenerator& d_sg;
- public:
- NotifyClass(ConjectureGenerator& sg): d_sg(sg) {}
- bool eqNotifyTriggerEquality(TNode equality, bool value) { return true; }
- bool eqNotifyTriggerPredicate(TNode predicate, bool value) { return true; }
- bool eqNotifyTriggerTermEquality(TheoryId tag, TNode t1, TNode t2, bool value) { return true; }
- void eqNotifyConstantTermMerge(TNode t1, TNode t2) { }
- void eqNotifyNewClass(TNode t) { d_sg.eqNotifyNewClass(t); }
- void eqNotifyPreMerge(TNode t1, TNode t2) { d_sg.eqNotifyPreMerge(t1, t2); }
- void eqNotifyPostMerge(TNode t1, TNode t2) { d_sg.eqNotifyPostMerge(t1, t2); }
- void eqNotifyDisequal(TNode t1, TNode t2, TNode reason) {d_sg.eqNotifyDisequal(t1, t2, reason); }
- };/* class ConjectureGenerator::NotifyClass */
- /** The notify class */
- NotifyClass d_notify;
- class EqcInfo{
- public:
- EqcInfo( context::Context* c );
- //representative
- context::CDO< Node > d_rep;
- };
- /** get or make eqc info */
- EqcInfo* getOrMakeEqcInfo( TNode n, bool doMake = false );
- /** (universal) equaltity engine */
- eq::EqualityEngine d_uequalityEngine;
- /** pending adds */
- std::vector< Node > d_upendingAdds;
- /** relevant terms */
- std::map< Node, bool > d_urelevant_terms;
- /** information necessary for equivalence classes */
- std::map< Node, EqcInfo* > d_eqc_info;
- /** called when a new equivalance class is created */
- void eqNotifyNewClass(TNode t);
- /** called when two equivalance classes will merge */
- void eqNotifyPreMerge(TNode t1, TNode t2);
- /** called when two equivalance classes have merged */
- void eqNotifyPostMerge(TNode t1, TNode t2);
- /** called when two equivalence classes are made disequal */
- void eqNotifyDisequal(TNode t1, TNode t2, TNode reason);
- /** are universal equal */
- bool areUniversalEqual( TNode n1, TNode n2 );
- /** are universal disequal */
- bool areUniversalDisequal( TNode n1, TNode n2 );
- /** get universal representative */
- TNode getUniversalRepresentative( TNode n, bool add = false );
- /** set relevant */
- void setUniversalRelevant( TNode n );
- /** ordering for universal terms */
- bool isUniversalLessThan( TNode rt1, TNode rt2 );
-
- /** the nodes we have reported as canonical representative */
- std::vector< TNode > d_ue_canon;
- /** is reported canon */
- bool isReportedCanon( TNode n );
- /** mark that term has been reported as canonical rep */
- void markReportedCanon( TNode n );
-
-private: //information regarding the conjectures
- /** list of all conjectures */
- std::vector< Node > d_conjectures;
- /** list of all waiting conjectures */
- std::vector< Node > d_waiting_conjectures_lhs;
- std::vector< Node > d_waiting_conjectures_rhs;
- std::vector< int > d_waiting_conjectures_score;
- /** map of currently considered equality conjectures */
- std::map< Node, std::vector< Node > > d_waiting_conjectures;
- /** map of equality conjectures */
- std::map< Node, std::vector< Node > > d_eq_conjectures;
- /** currently existing conjectures in equality engine */
- BoolMap d_ee_conjectures;
- /** conjecture index */
- TheoremIndex d_thm_index;
-private: //free variable list
- //free variables
- std::map< TypeNode, std::vector< Node > > d_free_var;
- //map from free variable to FV#
- std::map< TNode, unsigned > d_free_var_num;
- // get canonical free variable #i of type tn
- Node getFreeVar( TypeNode tn, unsigned i );
- // get canonical term, return null if it contains a term apart from handled signature
- Node getCanonicalTerm( TNode n, std::map< TypeNode, unsigned >& var_count, std::map< TNode, TNode >& subs );
-private: //information regarding the terms
- //relevant patterns (the LHS's)
- std::map< TypeNode, std::vector< Node > > d_rel_patterns;
- //total number of unique variables
- std::map< TNode, unsigned > d_rel_pattern_var_sum;
- //by types
- PatternTypIndex d_rel_pattern_typ_index;
- // substitution to ground EQC index
- std::map< TNode, SubstitutionIndex > d_rel_pattern_subs_index;
- //patterns (the RHS's)
- std::map< TypeNode, std::vector< Node > > d_patterns;
- //patterns to # variables per type
- std::map< TNode, std::map< TypeNode, unsigned > > d_pattern_var_id;
- // # duplicated variables
- std::map< TNode, unsigned > d_pattern_var_duplicate;
- // is normal pattern? (variables allocated in canonical way left to right)
- std::map< TNode, int > d_pattern_is_normal;
- std::map< TNode, int > d_pattern_is_relevant;
- // patterns to a count of # operators (variables and functions)
- std::map< TNode, std::map< TNode, unsigned > > d_pattern_fun_id;
- // term size
- std::map< TNode, unsigned > d_pattern_fun_sum;
- // collect functions
- unsigned collectFunctions( TNode opat, TNode pat, std::map< TNode, unsigned >& funcs,
- std::map< TypeNode, unsigned >& mnvn, std::map< TypeNode, unsigned >& mxvn );
- // add pattern
- void registerPattern( Node pat, TypeNode tpat );
-private: //for debugging
- std::map< TNode, unsigned > d_em;
- unsigned d_conj_count;
-public:
- //term generation environment
- TermGenEnv d_tge;
- //consider term canon
- bool considerTermCanon( Node ln, bool genRelevant );
-public: //for generalization
- //generalizations
- bool isGeneralization( TNode patg, TNode pat ) {
- std::map< TNode, TNode > subs;
- return isGeneralization( patg, pat, subs );
- }
- bool isGeneralization( TNode patg, TNode pat, std::map< TNode, TNode >& subs );
- // get generalization depth
- int calculateGeneralizationDepth( TNode n, std::vector< TNode >& fv );
-private:
- //predicate for type
- std::map< TypeNode, Node > d_typ_pred;
- //get predicate for type
- Node getPredicateForType( TypeNode tn );
- //
- void getEnumerateUfTerm( Node n, unsigned num, std::vector< Node >& terms );
- //
- void getEnumeratePredUfTerm( Node n, unsigned num, std::vector< Node >& terms );
- // uf operators enumerated
- std::map< Node, bool > d_uf_enum;
-public: //for property enumeration
- //process this candidate conjecture
- void processCandidateConjecture( TNode lhs, TNode rhs, unsigned lhs_depth, unsigned rhs_depth );
- //whether it should be considered, negative : no, positive returns score
- int considerCandidateConjecture( TNode lhs, TNode rhs );
- //notified of a substitution
- bool notifySubstitution( TNode glhs, std::map< TNode, TNode >& subs, TNode rhs );
- //confirmation count
- unsigned d_subs_confirmCount;
- //individual witnesses (for range)
- std::vector< TNode > d_subs_confirmWitnessRange;
- //individual witnesses (for domain)
- std::map< TNode, std::vector< TNode > > d_subs_confirmWitnessDomain;
- //number of ground substitutions whose equality is unknown
- unsigned d_subs_unkCount;
-private: //information about ground equivalence classes
- TNode d_bool_eqc[2];
- std::map< TNode, Node > d_ground_eqc_map;
- std::vector< TNode > d_ground_terms;
- //operator independent term index
- std::map< TNode, OpArgIndex > d_op_arg_index;
- //is handled term
- bool isHandledTerm( TNode n );
- Node getGroundEqc( TNode r );
- bool isGroundEqc( TNode r );
- bool isGroundTerm( TNode n );
- //has enumerated UF
- bool hasEnumeratedUf( Node n );
- // count of full effort checks
- unsigned d_fullEffortCount;
- // has added lemma
- bool d_hasAddedLemma;
- //flush the waiting conjectures
- unsigned flushWaitingConjectures( unsigned& addedLemmas, int ldepth, int rdepth );
-public:
- ConjectureGenerator( QuantifiersEngine * qe, context::Context* c );
- ~ConjectureGenerator() throw() {}
- /* needs check */
- bool needsCheck( Theory::Effort e );
- /* reset at a round */
- void reset_round( Theory::Effort e );
- /* Call during quantifier engine's check */
- void check( Theory::Effort e, unsigned quant_e );
- /* Called for new quantifiers */
- void registerQuantifier( Node q );
- void assertNode( Node n );
- /** Identify this module (for debugging, dynamic configuration, etc..) */
- std::string identify() const { return "ConjectureGenerator"; }
-//options
-private:
- bool optReqDistinctVarPatterns();
- bool optFilterUnknown();
- int optFilterScoreThreshold();
- unsigned optFullCheckFrequency();
- unsigned optFullCheckConjectures();
-
- bool optStatsOnly();
-};
-
-
-}
-}
-}
-
-#endif
+/********************* */ +/*! \file conjecture_generator.h + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief conjecture generator class + **/ + +#include "cvc4_private.h" + +#ifndef CONJECTURE_GENERATOR_H +#define CONJECTURE_GENERATOR_H + +#include "context/cdhashmap.h" +#include "context/cdchunk_list.h" +#include "theory/quantifiers_engine.h" +#include "theory/type_enumerator.h" + +namespace CVC4 { +namespace theory { +namespace quantifiers { + +class TermArgTrie; + +//algorithm for computing candidate subgoals + +class ConjectureGenerator; + +// operator independent index of arguments for an EQC +class OpArgIndex +{ +public: + std::map< TNode, OpArgIndex > d_child; + std::vector< TNode > d_ops; + std::vector< TNode > d_op_terms; + void addTerm( ConjectureGenerator * s, TNode n, unsigned index = 0 ); + Node getGroundTerm( ConjectureGenerator * s, std::vector< TNode >& args ); + void getGroundTerms( ConjectureGenerator * s, std::vector< TNode >& terms ); +}; + +class PatternTypIndex +{ +public: + std::vector< TNode > d_terms; + std::map< TypeNode, std::map< unsigned, PatternTypIndex > > d_children; + void clear() { + d_terms.clear(); + d_children.clear(); + } +}; + +class SubstitutionIndex +{ +public: + //current variable, or ground EQC if d_children.empty() + TNode d_var; + std::map< TNode, SubstitutionIndex > d_children; + //add substitution + void addSubstitution( TNode eqc, std::vector< TNode >& vars, std::vector< TNode >& terms, unsigned i = 0 ); + //notify substitutions + bool notifySubstitutions( ConjectureGenerator * s, std::map< TNode, TNode >& subs, TNode rhs, unsigned numVars, unsigned i = 0 ); +}; + +class TermGenEnv; + +class TermGenerator +{ +private: + unsigned calculateGeneralizationDepth( TermGenEnv * s, std::map< TypeNode, std::vector< int > >& fvs ); +public: + TermGenerator(){} + TypeNode d_typ; + unsigned d_id; + //1 : consider as unique variable + //2 : consider equal to another variable + //5 : consider a function application + unsigned d_status; + int d_status_num; + //for function applications: the number of children you have built + int d_status_child_num; + //children (pointers to TermGenerators) + std::vector< unsigned > d_children; + + //match status + int d_match_status; + int d_match_status_child_num; + //match mode bits + //0 : different variables must have different matches + //1 : variables must map to ground terms + //2 : variables must map to non-ground terms + unsigned d_match_mode; + //children + std::vector< std::map< TNode, TermArgTrie >::iterator > d_match_children; + std::vector< std::map< TNode, TermArgTrie >::iterator > d_match_children_end; + + void reset( TermGenEnv * s, TypeNode tn ); + bool getNextTerm( TermGenEnv * s, unsigned depth ); + void resetMatching( TermGenEnv * s, TNode eqc, unsigned mode ); + bool getNextMatch( TermGenEnv * s, TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ); + + unsigned getDepth( TermGenEnv * s ); + unsigned getGeneralizationDepth( TermGenEnv * s ); + Node getTerm( TermGenEnv * s ); + + void debugPrint( TermGenEnv * s, const char * c, const char * cd ); +}; + + +class TermGenEnv +{ +public: + //collect signature information + void collectSignatureInformation(); + //reset function + void reset( unsigned gdepth, bool genRelevant, TypeNode tgen ); + //get next term + bool getNextTerm(); + //reset matching + void resetMatching( TNode eqc, unsigned mode ); + //get next match + bool getNextMatch( TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ); + //get term + Node getTerm(); + //debug print + void debugPrint( const char * c, const char * cd ); + + //conjecture generation + ConjectureGenerator * d_cg; + //the current number of enumerated variables per type + std::map< TypeNode, unsigned > d_var_id; + //the limit of number of variables per type to enumerate + std::map< TypeNode, unsigned > d_var_limit; + //the functions we can currently generate + std::map< TypeNode, std::vector< TNode > > d_typ_tg_funcs; + // whether functions must add operators + std::map< TNode, bool > d_tg_func_param; + //the equivalence classes (if applicable) that match the currently generated term + bool d_gen_relevant_terms; + //relevant equivalence classes + std::vector< TNode > d_relevant_eqc[2]; + //candidate equivalence classes + std::vector< std::vector< TNode > > d_ccand_eqc[2]; + //the term generation objects + unsigned d_tg_id; + std::map< unsigned, TermGenerator > d_tg_alloc; + unsigned d_tg_gdepth; + int d_tg_gdepth_limit; + + //all functions + std::vector< TNode > d_funcs; + //function to kind map + std::map< TNode, Kind > d_func_kind; + //type of each argument of the function + std::map< TNode, std::vector< TypeNode > > d_func_args; + + //access functions + unsigned getNumTgVars( TypeNode tn ); + bool allowVar( TypeNode tn ); + void addVar( TypeNode tn ); + void removeVar( TypeNode tn ); + unsigned getNumTgFuncs( TypeNode tn ); + TNode getTgFunc( TypeNode tn, unsigned i ); + Node getFreeVar( TypeNode tn, unsigned i ); + bool considerCurrentTerm(); + bool considerCurrentTermCanon( unsigned tg_id ); + void changeContext( bool add ); + bool isRelevantFunc( Node f ); + //carry + TermDb * getTermDatabase(); + Node getGroundEqc( TNode r ); + bool isGroundEqc( TNode r ); + bool isGroundTerm( TNode n ); +}; + + + +class TheoremIndex +{ +private: + void addTheorem( std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ); + void addTheoremNode( TNode curr, std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ); + void getEquivalentTerms( std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ); + void getEquivalentTermsNode( Node curr, std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ); +public: + std::map< TypeNode, TNode > d_var; + std::map< TNode, TheoremIndex > d_children; + std::vector< Node > d_terms; + + void addTheorem( TNode lhs, TNode rhs ) { + std::vector< TNode > v; + std::vector< unsigned > a; + addTheoremNode( lhs, v, a, rhs ); + } + void getEquivalentTerms( TNode n, std::vector< Node >& terms ) { + std::vector< TNode > nv; + std::vector< unsigned > na; + std::map< TNode, TNode > smap; + std::vector< TNode > vars; + std::vector< TNode > subs; + getEquivalentTermsNode( n, nv, na, smap, vars, subs, terms ); + } + void clear(){ + d_var.clear(); + d_children.clear(); + d_terms.clear(); + } + void debugPrint( const char * c, unsigned ind = 0 ); +}; + + + +class ConjectureGenerator : public QuantifiersModule +{ + friend class OpArgIndex; + friend class PatGen; + friend class PatternGenEqc; + friend class PatternGen; + friend class SubsEqcIndex; + friend class TermGenerator; + friend class TermGenEnv; + typedef context::CDChunkList<Node> NodeList; + typedef context::CDHashMap< Node, Node, NodeHashFunction > NodeMap; + typedef context::CDHashMap< Node, bool, NodeHashFunction > BoolMap; +//this class maintains a congruence closure for *universal* facts +private: + //notification class for equality engine + class NotifyClass : public eq::EqualityEngineNotify { + ConjectureGenerator& d_sg; + public: + NotifyClass(ConjectureGenerator& sg): d_sg(sg) {} + bool eqNotifyTriggerEquality(TNode equality, bool value) { return true; } + bool eqNotifyTriggerPredicate(TNode predicate, bool value) { return true; } + bool eqNotifyTriggerTermEquality(TheoryId tag, TNode t1, TNode t2, bool value) { return true; } + void eqNotifyConstantTermMerge(TNode t1, TNode t2) { } + void eqNotifyNewClass(TNode t) { d_sg.eqNotifyNewClass(t); } + void eqNotifyPreMerge(TNode t1, TNode t2) { d_sg.eqNotifyPreMerge(t1, t2); } + void eqNotifyPostMerge(TNode t1, TNode t2) { d_sg.eqNotifyPostMerge(t1, t2); } + void eqNotifyDisequal(TNode t1, TNode t2, TNode reason) {d_sg.eqNotifyDisequal(t1, t2, reason); } + };/* class ConjectureGenerator::NotifyClass */ + /** The notify class */ + NotifyClass d_notify; + class EqcInfo{ + public: + EqcInfo( context::Context* c ); + //representative + context::CDO< Node > d_rep; + }; + /** get or make eqc info */ + EqcInfo* getOrMakeEqcInfo( TNode n, bool doMake = false ); + /** (universal) equaltity engine */ + eq::EqualityEngine d_uequalityEngine; + /** pending adds */ + std::vector< Node > d_upendingAdds; + /** relevant terms */ + std::map< Node, bool > d_urelevant_terms; + /** information necessary for equivalence classes */ + std::map< Node, EqcInfo* > d_eqc_info; + /** called when a new equivalance class is created */ + void eqNotifyNewClass(TNode t); + /** called when two equivalance classes will merge */ + void eqNotifyPreMerge(TNode t1, TNode t2); + /** called when two equivalance classes have merged */ + void eqNotifyPostMerge(TNode t1, TNode t2); + /** called when two equivalence classes are made disequal */ + void eqNotifyDisequal(TNode t1, TNode t2, TNode reason); + /** are universal equal */ + bool areUniversalEqual( TNode n1, TNode n2 ); + /** are universal disequal */ + bool areUniversalDisequal( TNode n1, TNode n2 ); + /** get universal representative */ + TNode getUniversalRepresentative( TNode n, bool add = false ); + /** set relevant */ + void setUniversalRelevant( TNode n ); + /** ordering for universal terms */ + bool isUniversalLessThan( TNode rt1, TNode rt2 ); + + /** the nodes we have reported as canonical representative */ + std::vector< TNode > d_ue_canon; + /** is reported canon */ + bool isReportedCanon( TNode n ); + /** mark that term has been reported as canonical rep */ + void markReportedCanon( TNode n ); + +private: //information regarding the conjectures + /** list of all conjectures */ + std::vector< Node > d_conjectures; + /** list of all waiting conjectures */ + std::vector< Node > d_waiting_conjectures_lhs; + std::vector< Node > d_waiting_conjectures_rhs; + std::vector< int > d_waiting_conjectures_score; + /** map of currently considered equality conjectures */ + std::map< Node, std::vector< Node > > d_waiting_conjectures; + /** map of equality conjectures */ + std::map< Node, std::vector< Node > > d_eq_conjectures; + /** currently existing conjectures in equality engine */ + BoolMap d_ee_conjectures; + /** conjecture index */ + TheoremIndex d_thm_index; +private: //free variable list + //free variables + std::map< TypeNode, std::vector< Node > > d_free_var; + //map from free variable to FV# + std::map< TNode, unsigned > d_free_var_num; + // get canonical free variable #i of type tn + Node getFreeVar( TypeNode tn, unsigned i ); + // get canonical term, return null if it contains a term apart from handled signature + Node getCanonicalTerm( TNode n, std::map< TypeNode, unsigned >& var_count, std::map< TNode, TNode >& subs ); +private: //information regarding the terms + //relevant patterns (the LHS's) + std::map< TypeNode, std::vector< Node > > d_rel_patterns; + //total number of unique variables + std::map< TNode, unsigned > d_rel_pattern_var_sum; + //by types + PatternTypIndex d_rel_pattern_typ_index; + // substitution to ground EQC index + std::map< TNode, SubstitutionIndex > d_rel_pattern_subs_index; + //patterns (the RHS's) + std::map< TypeNode, std::vector< Node > > d_patterns; + //patterns to # variables per type + std::map< TNode, std::map< TypeNode, unsigned > > d_pattern_var_id; + // # duplicated variables + std::map< TNode, unsigned > d_pattern_var_duplicate; + // is normal pattern? (variables allocated in canonical way left to right) + std::map< TNode, int > d_pattern_is_normal; + std::map< TNode, int > d_pattern_is_relevant; + // patterns to a count of # operators (variables and functions) + std::map< TNode, std::map< TNode, unsigned > > d_pattern_fun_id; + // term size + std::map< TNode, unsigned > d_pattern_fun_sum; + // collect functions + unsigned collectFunctions( TNode opat, TNode pat, std::map< TNode, unsigned >& funcs, + std::map< TypeNode, unsigned >& mnvn, std::map< TypeNode, unsigned >& mxvn ); + // add pattern + void registerPattern( Node pat, TypeNode tpat ); +private: //for debugging + std::map< TNode, unsigned > d_em; + unsigned d_conj_count; +public: + //term generation environment + TermGenEnv d_tge; + //consider term canon + bool considerTermCanon( Node ln, bool genRelevant ); +public: //for generalization + //generalizations + bool isGeneralization( TNode patg, TNode pat ) { + std::map< TNode, TNode > subs; + return isGeneralization( patg, pat, subs ); + } + bool isGeneralization( TNode patg, TNode pat, std::map< TNode, TNode >& subs ); + // get generalization depth + int calculateGeneralizationDepth( TNode n, std::vector< TNode >& fv ); +private: + //predicate for type + std::map< TypeNode, Node > d_typ_pred; + //get predicate for type + Node getPredicateForType( TypeNode tn ); + // + void getEnumerateUfTerm( Node n, unsigned num, std::vector< Node >& terms ); + // + void getEnumeratePredUfTerm( Node n, unsigned num, std::vector< Node >& terms ); + // uf operators enumerated + std::map< Node, bool > d_uf_enum; +public: //for property enumeration + //process this candidate conjecture + void processCandidateConjecture( TNode lhs, TNode rhs, unsigned lhs_depth, unsigned rhs_depth ); + //whether it should be considered, negative : no, positive returns score + int considerCandidateConjecture( TNode lhs, TNode rhs ); + //notified of a substitution + bool notifySubstitution( TNode glhs, std::map< TNode, TNode >& subs, TNode rhs ); + //confirmation count + unsigned d_subs_confirmCount; + //individual witnesses (for range) + std::vector< TNode > d_subs_confirmWitnessRange; + //individual witnesses (for domain) + std::map< TNode, std::vector< TNode > > d_subs_confirmWitnessDomain; + //number of ground substitutions whose equality is unknown + unsigned d_subs_unkCount; +private: //information about ground equivalence classes + TNode d_bool_eqc[2]; + std::map< TNode, Node > d_ground_eqc_map; + std::vector< TNode > d_ground_terms; + //operator independent term index + std::map< TNode, OpArgIndex > d_op_arg_index; + //is handled term + bool isHandledTerm( TNode n ); + Node getGroundEqc( TNode r ); + bool isGroundEqc( TNode r ); + bool isGroundTerm( TNode n ); + //has enumerated UF + bool hasEnumeratedUf( Node n ); + // count of full effort checks + unsigned d_fullEffortCount; + // has added lemma + bool d_hasAddedLemma; + //flush the waiting conjectures + unsigned flushWaitingConjectures( unsigned& addedLemmas, int ldepth, int rdepth ); +public: + ConjectureGenerator( QuantifiersEngine * qe, context::Context* c ); + ~ConjectureGenerator() throw() {} + /* needs check */ + bool needsCheck( Theory::Effort e ); + /* reset at a round */ + void reset_round( Theory::Effort e ); + /* Call during quantifier engine's check */ + void check( Theory::Effort e, unsigned quant_e ); + /* Called for new quantifiers */ + void registerQuantifier( Node q ); + void assertNode( Node n ); + /** Identify this module (for debugging, dynamic configuration, etc..) */ + std::string identify() const { return "ConjectureGenerator"; } +//options +private: + bool optReqDistinctVarPatterns(); + bool optFilterUnknown(); + int optFilterScoreThreshold(); + unsigned optFullCheckFrequency(); + unsigned optFullCheckConjectures(); + + bool optStatsOnly(); +}; + + +} +} +} + +#endif diff --git a/src/theory/quantifiers/quant_conflict_find.cpp b/src/theory/quantifiers/quant_conflict_find.cpp index d465df4c0..18bffe908 100644 --- a/src/theory/quantifiers/quant_conflict_find.cpp +++ b/src/theory/quantifiers/quant_conflict_find.cpp @@ -1,2227 +1,2227 @@ -/********************* */
-/*! \file quant_conflict_find.cpp
- ** \verbatim
- ** Original author: Andrew Reynolds
- ** Major contributors: none
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief quant conflict find class
- **
- **/
-
-#include <vector>
-
-#include "theory/quantifiers/quant_conflict_find.h"
-#include "theory/quantifiers/quant_util.h"
-#include "theory/theory_engine.h"
-#include "theory/quantifiers/options.h"
-#include "theory/quantifiers/term_database.h"
-#include "theory/quantifiers/trigger.h"
-
-using namespace CVC4;
-using namespace CVC4::kind;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
-using namespace std;
-
-namespace CVC4 {
-
-
-
-void QuantInfo::initialize( Node q, Node qn ) {
- d_q = q;
- for( unsigned i=0; i<q[0].getNumChildren(); i++ ){
- d_match.push_back( TNode::null() );
- d_match_term.push_back( TNode::null() );
- }
-
- //register the variables
- for( unsigned i=0; i<q[0].getNumChildren(); i++ ){
- d_var_num[q[0][i]] = i;
- d_vars.push_back( q[0][i] );
- d_var_types.push_back( q[0][i].getType() );
- }
-
- registerNode( qn, true, true );
-
-
- Trace("qcf-qregister") << "- Make match gen structure..." << std::endl;
- d_mg = new MatchGen( this, qn );
-
- if( d_mg->isValid() ){
- /*
- for( unsigned j=0; j<q[0].getNumChildren(); j++ ){
- if( d_inMatchConstraint.find( q[0][j] )==d_inMatchConstraint.end() ){
- Trace("qcf-invalid") << "QCF invalid : variable " << q[0][j] << " does not exist in a matching constraint." << std::endl;
- d_mg->setInvalid();
- break;
- }
- }
- */
- if( d_mg->isValid() ){
- for( unsigned j=q[0].getNumChildren(); j<d_vars.size(); j++ ){
- if( d_vars[j].getKind()!=BOUND_VARIABLE ){
- d_var_mg[j] = NULL;
- bool is_tsym = false;
- if( !MatchGen::isHandledUfTerm( d_vars[j] ) && d_vars[j].getKind()!=ITE ){
- is_tsym = true;
- d_tsym_vars.push_back( j );
- }
- if( !is_tsym || options::qcfTConstraint() ){
- d_var_mg[j] = new MatchGen( this, d_vars[j], true );
- }
- if( !d_var_mg[j] || !d_var_mg[j]->isValid() ){
- Trace("qcf-invalid") << "QCF invalid : cannot match for " << d_vars[j] << std::endl;
- d_mg->setInvalid();
- break;
- }else{
- std::vector< int > bvars;
- d_var_mg[j]->determineVariableOrder( this, bvars );
- }
- }
- }
- if( d_mg->isValid() ){
- std::vector< int > bvars;
- d_mg->determineVariableOrder( this, bvars );
- }
- }
- }else{
- Trace("qcf-invalid") << "QCF invalid : body of formula cannot be processed." << std::endl;
- }
- Trace("qcf-qregister-summary") << "QCF register : " << ( d_mg->isValid() ? "VALID " : "INVALID" ) << " : " << q << std::endl;
-}
-
-void QuantInfo::registerNode( Node n, bool hasPol, bool pol, bool beneathQuant ) {
- Trace("qcf-qregister-debug2") << "Register : " << n << std::endl;
- if( n.getKind()==FORALL ){
- registerNode( n[1], hasPol, pol, true );
- }else{
- if( !MatchGen::isHandledBoolConnective( n ) ){
- if( n.hasBoundVar() ){
- //literals
- if( n.getKind()==EQUAL ){
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- flatten( n[i], beneathQuant );
- }
- }else if( MatchGen::isHandledUfTerm( n ) ){
- flatten( n, beneathQuant );
- }else if( n.getKind()==ITE ){
- for( unsigned i=1; i<=2; i++ ){
- flatten( n[i], beneathQuant );
- }
- registerNode( n[0], false, pol, beneathQuant );
- }else if( options::qcfTConstraint() ){
- //a theory-specific predicate
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- flatten( n[i], beneathQuant );
- }
- }
- }
- }else{
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- bool newHasPol;
- bool newPol;
- QuantPhaseReq::getPolarity( n, i, hasPol, pol, newHasPol, newPol );
- //QcfNode * qcfc = new QcfNode( d_c );
- //qcfc->d_parent = qcf;
- //qcf->d_child[i] = qcfc;
- registerNode( n[i], newHasPol, newPol, beneathQuant );
- }
- }
- }
-}
-
-void QuantInfo::flatten( Node n, bool beneathQuant ) {
- Trace("qcf-qregister-debug2") << "Flatten : " << n << std::endl;
- if( n.hasBoundVar() ){
- if( n.getKind()==BOUND_VARIABLE ){
- d_inMatchConstraint[n] = true;
- }
- //if( MatchGen::isHandledUfTerm( n ) || n.getKind()==ITE ){
- if( d_var_num.find( n )==d_var_num.end() ){
- Trace("qcf-qregister-debug2") << "Add FLATTEN VAR : " << n << std::endl;
- d_var_num[n] = d_vars.size();
- d_vars.push_back( n );
- d_var_types.push_back( n.getType() );
- d_match.push_back( TNode::null() );
- d_match_term.push_back( TNode::null() );
- if( n.getKind()==ITE ){
- registerNode( n, false, false );
- }else{
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- flatten( n[i], beneathQuant );
- }
- }
- }else{
- Trace("qcf-qregister-debug2") << "...already processed" << std::endl;
- }
- }else{
- Trace("qcf-qregister-debug2") << "...is ground." << std::endl;
- }
-}
-
-
-void QuantInfo::reset_round( QuantConflictFind * p ) {
- for( unsigned i=0; i<d_match.size(); i++ ){
- d_match[i] = TNode::null();
- d_match_term[i] = TNode::null();
- }
- d_curr_var_deq.clear();
- d_tconstraints.clear();
- //add built-in variable constraints
- for( unsigned r=0; r<2; r++ ){
- for( std::map< int, std::vector< Node > >::iterator it = d_var_constraint[r].begin();
- it != d_var_constraint[r].end(); ++it ){
- for( unsigned j=0; j<it->second.size(); j++ ){
- Node rr = it->second[j];
- if( !isVar( rr ) ){
- rr = p->getRepresentative( rr );
- }
- if( addConstraint( p, it->first, rr, r==0 )==-1 ){
- d_var_constraint[0].clear();
- d_var_constraint[1].clear();
- //quantified formula is actually equivalent to true
- Trace("qcf-qregister") << "Quantifier is equivalent to true!!!" << std::endl;
- d_mg->d_children.clear();
- d_mg->d_n = NodeManager::currentNM()->mkConst( true );
- d_mg->d_type = MatchGen::typ_ground;
- return;
- }
- }
- }
- }
- d_mg->reset_round( p );
- for( std::map< int, MatchGen * >::iterator it = d_var_mg.begin(); it != d_var_mg.end(); ++it ){
- it->second->reset_round( p );
- }
- //now, reset for matching
- d_mg->reset( p, false, this );
-}
-
-int QuantInfo::getCurrentRepVar( int v ) {
- if( v!=-1 && !d_match[v].isNull() ){
- int vn = getVarNum( d_match[v] );
- if( vn!=-1 ){
- //int vr = getCurrentRepVar( vn );
- //d_match[v] = d_vars[vr];
- //return vr;
- return getCurrentRepVar( vn );
- }
- }
- return v;
-}
-
-TNode QuantInfo::getCurrentValue( TNode n ) {
- int v = getVarNum( n );
- if( v==-1 ){
- return n;
- }else{
- if( d_match[v].isNull() ){
- return n;
- }else{
- Assert( getVarNum( d_match[v] )!=v );
- return getCurrentValue( d_match[v] );
- }
- }
-}
-
-TNode QuantInfo::getCurrentExpValue( TNode n ) {
- int v = getVarNum( n );
- if( v==-1 ){
- return n;
- }else{
- if( d_match[v].isNull() ){
- return n;
- }else{
- Assert( getVarNum( d_match[v] )!=v );
- if( d_match_term[v].isNull() ){
- return getCurrentValue( d_match[v] );
- }else{
- return d_match_term[v];
- }
- }
- }
-}
-
-bool QuantInfo::getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq ) {
- //check disequalities
- std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v );
- if( itd!=d_curr_var_deq.end() ){
- for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){
- Node cv = getCurrentValue( it->first );
- Debug("qcf-ccbe") << "compare " << cv << " " << n << std::endl;
- if( cv==n ){
- return false;
- }else if( chDiseq && !isVar( n ) && !isVar( cv ) ){
- //they must actually be disequal if we are looking for conflicts
- if( !p->areDisequal( n, cv ) ){
- //TODO : check for entailed disequal
-
- return false;
- }
- }
- }
- }
- return true;
-}
-
-int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ) {
- v = getCurrentRepVar( v );
- int vn = getVarNum( n );
- vn = vn==-1 ? -1 : getCurrentRepVar( vn );
- n = getCurrentValue( n );
- return addConstraint( p, v, n, vn, polarity, false );
-}
-
-int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ) {
- //for handling equalities between variables, and disequalities involving variables
- Debug("qcf-match-debug") << "- " << (doRemove ? "un" : "" ) << "constrain : " << v << " -> " << n << " (cv=" << getCurrentValue( n ) << ")";
- Debug("qcf-match-debug") << ", (vn=" << vn << "), polarity = " << polarity << std::endl;
- Assert( doRemove || n==getCurrentValue( n ) );
- Assert( doRemove || v==getCurrentRepVar( v ) );
- Assert( doRemove || vn==getCurrentRepVar( getVarNum( n ) ) );
- if( polarity ){
- if( vn!=v ){
- if( doRemove ){
- if( vn!=-1 ){
- //if set to this in the opposite direction, clean up opposite instead
- // std::map< int, TNode >::iterator itmn = d_match.find( vn );
- if( d_match[vn]==d_vars[v] ){
- return addConstraint( p, vn, d_vars[v], v, true, true );
- }else{
- //unsetting variables equal
- std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( vn );
- if( itd!=d_curr_var_deq.end() ){
- //remove disequalities owned by this
- std::vector< TNode > remDeq;
- for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){
- if( it->second==v ){
- remDeq.push_back( it->first );
- }
- }
- for( unsigned i=0; i<remDeq.size(); i++ ){
- d_curr_var_deq[vn].erase( remDeq[i] );
- }
- }
- }
- }
- d_match[v] = TNode::null();
- return 1;
- }else{
- //std::map< int, TNode >::iterator itm = d_match.find( v );
-
- if( vn!=-1 ){
- Debug("qcf-match-debug") << " ...Variable bound to variable" << std::endl;
- //std::map< int, TNode >::iterator itmn = d_match.find( vn );
- if( d_match[v].isNull() ){
- //setting variables equal
- bool alreadySet = false;
- if( !d_match[vn].isNull() ){
- alreadySet = true;
- Assert( !isVar( d_match[vn] ) );
- }
-
- //copy or check disequalities
- std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v );
- if( itd!=d_curr_var_deq.end() ){
- for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){
- Node dv = getCurrentValue( it->first );
- if( !alreadySet ){
- if( d_curr_var_deq[vn].find( dv )==d_curr_var_deq[vn].end() ){
- d_curr_var_deq[vn][dv] = v;
- }
- }else{
- if( !p->areMatchDisequal( d_match[vn], dv ) ){
- Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl;
- return -1;
- }
- }
- }
- }
- if( alreadySet ){
- n = getCurrentValue( n );
- }
- }else{
- if( d_match[vn].isNull() ){
- Debug("qcf-match-debug") << " ...Reverse direction" << std::endl;
- //set the opposite direction
- return addConstraint( p, vn, d_vars[v], v, true, false );
- }else{
- Debug("qcf-match-debug") << " -> Both variables bound, compare" << std::endl;
- //are they currently equal
- return p->areMatchEqual( d_match[v], d_match[vn] ) ? 0 : -1;
- }
- }
- }else{
- Debug("qcf-match-debug") << " ...Variable bound to ground" << std::endl;
- if( d_match[v].isNull() ){
- }else{
- //compare ground values
- Debug("qcf-match-debug") << " -> Ground value, compare " << d_match[v] << " "<< n << std::endl;
- return p->areMatchEqual( d_match[v], n ) ? 0 : -1;
- }
- }
- if( setMatch( p, v, n ) ){
- Debug("qcf-match-debug") << " -> success" << std::endl;
- return 1;
- }else{
- Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl;
- return -1;
- }
- }
- }else{
- Debug("qcf-match-debug") << " -> redundant, variable identity" << std::endl;
- return 0;
- }
- }else{
- if( vn==v ){
- Debug("qcf-match-debug") << " -> fail, variable identity" << std::endl;
- return -1;
- }else{
- if( doRemove ){
- Assert( d_curr_var_deq[v].find( n )!=d_curr_var_deq[v].end() );
- d_curr_var_deq[v].erase( n );
- return 1;
- }else{
- if( d_curr_var_deq[v].find( n )==d_curr_var_deq[v].end() ){
- //check if it respects equality
- //std::map< int, TNode >::iterator itm = d_match.find( v );
- if( !d_match[v].isNull() ){
- TNode nv = getCurrentValue( n );
- if( !p->areMatchDisequal( nv, d_match[v] ) ){
- Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl;
- return -1;
- }
- }
- d_curr_var_deq[v][n] = v;
- Debug("qcf-match-debug") << " -> success" << std::endl;
- return 1;
- }else{
- Debug("qcf-match-debug") << " -> redundant disequality" << std::endl;
- return 0;
- }
- }
- }
- }
-}
-
-bool QuantInfo::isConstrainedVar( int v ) {
- if( d_curr_var_deq.find( v )!=d_curr_var_deq.end() && !d_curr_var_deq[v].empty() ){
- return true;
- }else{
- Node vv = getVar( v );
- //for( std::map< int, TNode >::iterator it = d_match.begin(); it != d_match.end(); ++it ){
- for( unsigned i=0; i<d_match.size(); i++ ){
- if( d_match[i]==vv ){
- return true;
- }
- }
- for( std::map< int, std::map< TNode, int > >::iterator it = d_curr_var_deq.begin(); it != d_curr_var_deq.end(); ++it ){
- for( std::map< TNode, int >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){
- if( it2->first==vv ){
- return true;
- }
- }
- }
- return false;
- }
-}
-
-bool QuantInfo::setMatch( QuantConflictFind * p, int v, TNode n ) {
- if( getCurrentCanBeEqual( p, v, n ) ){
- Debug("qcf-match-debug") << "-- bind : " << v << " -> " << n << ", checked " << d_curr_var_deq[v].size() << " disequalities" << std::endl;
- d_match[v] = n;
- return true;
- }else{
- return false;
- }
-}
-
-bool QuantInfo::isMatchSpurious( QuantConflictFind * p ) {
- for( int i=0; i<getNumVars(); i++ ){
- //std::map< int, TNode >::iterator it = d_match.find( i );
- if( !d_match[i].isNull() ){
- if( !getCurrentCanBeEqual( p, i, d_match[i], p->d_effort==QuantConflictFind::effort_conflict ) ){
- return true;
- }
- }
- }
- return false;
-}
-
-bool QuantInfo::isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ) {
- if( !d_tconstraints.empty() ){
- //check constraints
- for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){
- //apply substitution to the tconstraint
- Node cons = it->first.substitute( p->getTermDatabase()->d_vars[d_q].begin(),
- p->getTermDatabase()->d_vars[d_q].end(),
- terms.begin(), terms.end() );
- cons = it->second ? cons : cons.negate();
- if( !entailmentTest( p, cons, p->d_effort==QuantConflictFind::effort_conflict ) ){
- return true;
- }
- }
- }
- return false;
-}
-
-bool QuantInfo::entailmentTest( QuantConflictFind * p, Node lit, bool chEnt ) {
- Trace("qcf-tconstraint-debug") << "Check : " << lit << std::endl;
- Node rew = Rewriter::rewrite( lit );
- if( rew==p->d_false ){
- Trace("qcf-tconstraint-debug") << "...constraint " << lit << " is disentailed (rewrites to false)." << std::endl;
- return false;
- }else if( rew!=p->d_true ){
- //if checking for conflicts, we must be sure that the constraint is entailed
- if( chEnt ){
- //check if it is entailed
- Trace("qcf-tconstraint-debug") << "Check entailment of " << rew << "..." << std::endl;
- std::pair<bool, Node> et = p->getQuantifiersEngine()->getTheoryEngine()->entailmentCheck(THEORY_OF_TYPE_BASED, rew );
- ++(p->d_statistics.d_entailment_checks);
- Trace("qcf-tconstraint-debug") << "ET result : " << et.first << " " << et.second << std::endl;
- if( !et.first ){
- Trace("qcf-tconstraint-debug") << "...cannot show entailment of " << rew << "." << std::endl;
- return false;
- }else{
- return true;
- }
- }else{
- Trace("qcf-tconstraint-debug") << "...does not need to be entailed." << std::endl;
- return true;
- }
- }else{
- Trace("qcf-tconstraint-debug") << "...rewrites to true." << std::endl;
- return true;
- }
-}
-
-bool QuantInfo::completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue ) {
- //assign values for variables that were unassigned (usually not necessary, but handles corner cases)
- bool doFail = false;
- bool success = true;
- if( doContinue ){
- doFail = true;
- success = false;
- }else{
- //solve for interpreted symbol matches
- // this breaks the invariant that all introduced constraints are over existing terms
- for( int i=(int)(d_tsym_vars.size()-1); i>=0; i-- ){
- int index = d_tsym_vars[i];
- TNode v = getCurrentValue( d_vars[index] );
- int slv_v = -1;
- if( v==d_vars[index] ){
- slv_v = index;
- }
- Trace("qcf-tconstraint-debug") << "Solve " << d_vars[index] << " = " << v << " " << d_vars[index].getKind() << std::endl;
- if( d_vars[index].getKind()==PLUS || d_vars[index].getKind()==MULT ){
- Kind k = d_vars[index].getKind();
- std::vector< TNode > children;
- for( unsigned j=0; j<d_vars[index].getNumChildren(); j++ ){
- int vn = getVarNum( d_vars[index][j] );
- if( vn!=-1 ){
- TNode vv = getCurrentValue( d_vars[index][j] );
- if( vv==d_vars[index][j] ){
- //we will assign this
- if( slv_v==-1 ){
- Trace("qcf-tconstraint-debug") << "...will solve for var #" << vn << std::endl;
- slv_v = vn;
- if( p->d_effort!=QuantConflictFind::effort_conflict ){
- break;
- }
- }else{
- Node z = p->getZero( k );
- if( !z.isNull() ){
- Trace("qcf-tconstraint-debug") << "...set " << d_vars[vn] << " = " << z << std::endl;
- assigned.push_back( vn );
- if( !setMatch( p, vn, z ) ){
- success = false;
- break;
- }
- }
- }
- }else{
- Trace("qcf-tconstraint-debug") << "...sum value " << vv << std::endl;
- children.push_back( vv );
- }
- }else{
- Trace("qcf-tconstraint-debug") << "...sum " << d_vars[index][j] << std::endl;
- children.push_back( d_vars[index][j] );
- }
- }
- if( success ){
- if( slv_v!=-1 ){
- Node lhs;
- if( children.empty() ){
- lhs = p->getZero( k );
- }else if( children.size()==1 ){
- lhs = children[0];
- }else{
- lhs = NodeManager::currentNM()->mkNode( k, children );
- }
- Node sum;
- if( v==d_vars[index] ){
- sum = lhs;
- }else{
- if( p->d_effort==QuantConflictFind::effort_conflict ){
- Kind kn = k;
- if( d_vars[index].getKind()==PLUS ){
- kn = MINUS;
- }
- if( kn!=k ){
- sum = NodeManager::currentNM()->mkNode( kn, v, lhs );
- }
- }
- }
- if( !sum.isNull() ){
- assigned.push_back( slv_v );
- Trace("qcf-tconstraint-debug") << "...set " << d_vars[slv_v] << " = " << sum << std::endl;
- if( !setMatch( p, slv_v, sum ) ){
- success = false;
- }
- p->d_tempCache.push_back( sum );
- }
- }else{
- //must show that constraint is met
- Node sum = NodeManager::currentNM()->mkNode( k, children );
- Node eq = sum.eqNode( v );
- if( !entailmentTest( p, eq ) ){
- success = false;
- }
- p->d_tempCache.push_back( sum );
- }
- }
- }
-
- if( !success ){
- break;
- }
- }
- if( success ){
- //check what is left to assign
- d_unassigned.clear();
- d_unassigned_tn.clear();
- std::vector< int > unassigned[2];
- std::vector< TypeNode > unassigned_tn[2];
- for( int i=0; i<getNumVars(); i++ ){
- if( d_match[i].isNull() ){
- int rindex = d_var_mg.find( i )==d_var_mg.end() ? 1 : 0;
- unassigned[rindex].push_back( i );
- unassigned_tn[rindex].push_back( getVar( i ).getType() );
- assigned.push_back( i );
- }
- }
- d_unassigned_nvar = unassigned[0].size();
- for( unsigned i=0; i<2; i++ ){
- d_unassigned.insert( d_unassigned.end(), unassigned[i].begin(), unassigned[i].end() );
- d_unassigned_tn.insert( d_unassigned_tn.end(), unassigned_tn[i].begin(), unassigned_tn[i].end() );
- }
- d_una_eqc_count.clear();
- d_una_index = 0;
- }
- }
-
- if( !d_unassigned.empty() && ( success || doContinue ) ){
- Trace("qcf-check") << "Assign to unassigned..." << std::endl;
- do {
- if( doFail ){
- Trace("qcf-check-unassign") << "Failure, try again..." << std::endl;
- }
- bool invalidMatch = false;
- while( ( d_una_index>=0 && (int)d_una_index<(int)d_unassigned.size() ) || invalidMatch || doFail ){
- invalidMatch = false;
- if( !doFail && d_una_index==(int)d_una_eqc_count.size() ){
- //check if it has now been assigned
- if( d_una_index<d_unassigned_nvar ){
- if( !isConstrainedVar( d_unassigned[d_una_index] ) ){
- d_una_eqc_count.push_back( -1 );
- }else{
- d_var_mg[ d_unassigned[d_una_index] ]->reset( p, true, this );
- d_una_eqc_count.push_back( 0 );
- }
- }else{
- d_una_eqc_count.push_back( 0 );
- }
- }else{
- bool failed = false;
- if( !doFail ){
- if( d_una_index<d_unassigned_nvar ){
- if( !isConstrainedVar( d_unassigned[d_una_index] ) ){
- Trace("qcf-check-unassign") << "Succeeded, variable unconstrained at " << d_una_index << std::endl;
- d_una_index++;
- }else if( d_var_mg[d_unassigned[d_una_index]]->getNextMatch( p, this ) ){
- Trace("qcf-check-unassign") << "Succeeded match with mg at " << d_una_index << std::endl;
- d_una_index++;
- }else{
- failed = true;
- Trace("qcf-check-unassign") << "Failed match with mg at " << d_una_index << std::endl;
- }
- }else{
- Assert( doFail || d_una_index==(int)d_una_eqc_count.size()-1 );
- if( d_una_eqc_count[d_una_index]<(int)p->d_eqcs[d_unassigned_tn[d_una_index]].size() ){
- int currIndex = d_una_eqc_count[d_una_index];
- d_una_eqc_count[d_una_index]++;
- Trace("qcf-check-unassign") << d_unassigned[d_una_index] << "->" << p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] << std::endl;
- if( setMatch( p, d_unassigned[d_una_index], p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] ) ){
- d_match_term[d_unassigned[d_una_index]] = TNode::null();
- Trace("qcf-check-unassign") << "Succeeded match " << d_una_index << std::endl;
- d_una_index++;
- }else{
- Trace("qcf-check-unassign") << "Failed match " << d_una_index << std::endl;
- invalidMatch = true;
- }
- }else{
- failed = true;
- Trace("qcf-check-unassign") << "No more matches " << d_una_index << std::endl;
- }
- }
- }
- if( doFail || failed ){
- do{
- if( !doFail ){
- d_una_eqc_count.pop_back();
- }else{
- doFail = false;
- }
- d_una_index--;
- }while( d_una_index>=0 && d_una_eqc_count[d_una_index]==-1 );
- }
- }
- }
- success = d_una_index>=0;
- if( success ){
- doFail = true;
- Trace("qcf-check-unassign") << " Try: " << std::endl;
- for( unsigned i=0; i<d_unassigned.size(); i++ ){
- int ui = d_unassigned[i];
- if( !d_match[ui].isNull() ){
- Trace("qcf-check-unassign") << " Assigned #" << ui << " : " << d_vars[ui] << " -> " << d_match[ui] << std::endl;
- }
- }
- }
- }while( success && isMatchSpurious( p ) );
- }
- if( success ){
- for( unsigned i=0; i<d_unassigned.size(); i++ ){
- int ui = d_unassigned[i];
- if( !d_match[ui].isNull() ){
- Trace("qcf-check") << " Assigned #" << ui << " : " << d_vars[ui] << " -> " << d_match[ui] << std::endl;
- }
- }
- return true;
- }else{
- for( unsigned i=0; i<assigned.size(); i++ ){
- d_match[ assigned[i] ] = TNode::null();
- }
- assigned.clear();
- return false;
- }
-}
-
-void QuantInfo::getMatch( std::vector< Node >& terms ){
- for( unsigned i=0; i<d_q[0].getNumChildren(); i++ ){
- //Node cv = qi->getCurrentValue( qi->d_match[i] );
- int repVar = getCurrentRepVar( i );
- Node cv;
- //std::map< int, TNode >::iterator itmt = qi->d_match_term.find( repVar );
- if( !d_match_term[repVar].isNull() ){
- cv = d_match_term[repVar];
- }else{
- cv = d_match[repVar];
- }
- Debug("qcf-check-inst") << "INST : " << i << " -> " << cv << ", from " << d_match[i] << std::endl;
- terms.push_back( cv );
- }
-}
-
-void QuantInfo::revertMatch( std::vector< int >& assigned ) {
- for( unsigned i=0; i<assigned.size(); i++ ){
- d_match[ assigned[i] ] = TNode::null();
- }
-}
-
-void QuantInfo::debugPrintMatch( const char * c ) {
- for( int i=0; i<getNumVars(); i++ ){
- Trace(c) << " " << d_vars[i] << " -> ";
- if( !d_match[i].isNull() ){
- Trace(c) << d_match[i];
- }else{
- Trace(c) << "(unassigned) ";
- }
- if( !d_curr_var_deq[i].empty() ){
- Trace(c) << ", DEQ{ ";
- for( std::map< TNode, int >::iterator it = d_curr_var_deq[i].begin(); it != d_curr_var_deq[i].end(); ++it ){
- Trace(c) << it->first << " ";
- }
- Trace(c) << "}";
- }
- if( !d_match_term[i].isNull() && d_match_term[i]!=d_match[i] ){
- Trace(c) << ", EXP : " << d_match_term[i];
- }
- Trace(c) << std::endl;
- }
- if( !d_tconstraints.empty() ){
- Trace(c) << "ADDITIONAL CONSTRAINTS : " << std::endl;
- for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){
- Trace(c) << " " << it->first << " -> " << it->second << std::endl;
- }
- }
-}
-
-MatchGen::MatchGen( QuantInfo * qi, Node n, bool isVar ){
- Trace("qcf-qregister-debug") << "Make match gen for " << n << ", isVar = " << isVar << std::endl;
- std::vector< Node > qni_apps;
- d_qni_size = 0;
- if( isVar ){
- Assert( qi->d_var_num.find( n )!=qi->d_var_num.end() );
- if( n.getKind()==ITE ){
- d_type = typ_ite_var;
- d_type_not = false;
- d_n = n;
- d_children.push_back( MatchGen( qi, d_n[0] ) );
- if( d_children[0].isValid() ){
- d_type = typ_ite_var;
- for( unsigned i=1; i<=2; i++ ){
- Node nn = n.eqNode( n[i] );
- d_children.push_back( MatchGen( qi, nn ) );
- d_children[d_children.size()-1].d_qni_bound_except.push_back( 0 );
- if( !d_children[d_children.size()-1].isValid() ){
- setInvalid();
- break;
- }
- }
- }else{
- d_type = typ_invalid;
- }
- }else{
- d_type = isHandledUfTerm( n ) ? typ_var : typ_tsym;
- d_qni_var_num[0] = qi->getVarNum( n );
- d_qni_size++;
- d_type_not = false;
- d_n = n;
- //Node f = getOperator( n );
- for( unsigned j=0; j<d_n.getNumChildren(); j++ ){
- Node nn = d_n[j];
- Trace("qcf-qregister-debug") << " " << d_qni_size;
- if( qi->isVar( nn ) ){
- int v = qi->d_var_num[nn];
- Trace("qcf-qregister-debug") << " is var #" << v << std::endl;
- d_qni_var_num[d_qni_size] = v;
- //qi->addFuncParent( v, f, j );
- }else{
- Trace("qcf-qregister-debug") << " is gterm " << nn << std::endl;
- d_qni_gterm[d_qni_size] = nn;
- }
- d_qni_size++;
- }
- }
- }else{
- if( n.hasBoundVar() ){
- d_type_not = false;
- d_n = n;
- if( d_n.getKind()==NOT ){
- d_n = d_n[0];
- d_type_not = !d_type_not;
- }
-
- if( isHandledBoolConnective( d_n ) ){
- //non-literals
- d_type = typ_formula;
- for( unsigned i=0; i<d_n.getNumChildren(); i++ ){
- if( d_n.getKind()!=FORALL || i==1 ){
- d_children.push_back( MatchGen( qi, d_n[i], false ) );
- if( !d_children[d_children.size()-1].isValid() ){
- setInvalid();
- break;
- }
- }
- /*
- else if( isTop && n.getKind()==OR && d_children[d_children.size()-1].d_type==typ_var_eq ){
- Trace("qcf-qregister-debug") << "Remove child, make built-in constraint" << std::endl;
- //if variable equality/disequality at top level, remove immediately
- bool cIsNot = d_children[d_children.size()-1].d_type_not;
- Node cn = d_children[d_children.size()-1].d_n;
- Assert( cn.getKind()==EQUAL );
- Assert( p->d_qinfo[q].isVar( cn[0] ) || p->d_qinfo[q].isVar( cn[1] ) );
- //make it a built-in constraint instead
- for( unsigned i=0; i<2; i++ ){
- if( p->d_qinfo[q].isVar( cn[i] ) ){
- int v = p->d_qinfo[q].getVarNum( cn[i] );
- Node cno = cn[i==0 ? 1 : 0];
- p->d_qinfo[q].d_var_constraint[ cIsNot ? 0 : 1 ][v].push_back( cno );
- break;
- }
- }
- d_children.pop_back();
- }
- */
- }
- }else{
- d_type = typ_invalid;
- //literals
- if( isHandledUfTerm( d_n ) ){
- Assert( qi->isVar( d_n ) );
- d_type = typ_pred;
- }else if( d_n.getKind()==BOUND_VARIABLE ){
- Assert( d_n.getType().isBoolean() );
- d_type = typ_bool_var;
- }else if( d_n.getKind()==EQUAL || options::qcfTConstraint() ){
- for( unsigned i=0; i<d_n.getNumChildren(); i++ ){
- if( d_n[i].hasBoundVar() ){
- if( !qi->isVar( d_n[i] ) ){
- Trace("qcf-qregister-debug") << "ERROR : not var " << d_n[i] << std::endl;
- }
- Assert( qi->isVar( d_n[i] ) );
- if( d_n.getKind()!=EQUAL && qi->isVar( d_n[i] ) ){
- d_qni_var_num[i+1] = qi->d_var_num[d_n[i]];
- }
- }else{
- d_qni_gterm[i] = d_n[i];
- }
- }
- d_type = d_n.getKind()==EQUAL ? typ_eq : typ_tconstraint;
- Trace("qcf-tconstraint") << "T-Constraint : " << d_n << std::endl;
- }
- }
- }else{
- //we will just evaluate
- d_n = n;
- d_type = typ_ground;
- }
- //if( d_type!=typ_invalid ){
- //determine an efficient children ordering
- //if( !d_children.empty() ){
- //for( unsigned i=0; i<d_children.size(); i++ ){
- // d_children_order.push_back( i );
- //}
- //if( !d_n.isNull() && ( d_n.getKind()==OR || d_n.getKind()==AND || d_n.getKind()==IFF ) ){
- //sort based on the type of the constraint : ground comes first, then literals, then others
- //MatchGenSort mgs;
- //mgs.d_mg = this;
- //std::sort( d_children_order.begin(), d_children_order.end(), mgs );
- //}
- //}
- //}
- }
- Trace("qcf-qregister-debug") << "Done make match gen " << n << ", type = ";
- debugPrintType( "qcf-qregister-debug", d_type, true );
- Trace("qcf-qregister-debug") << std::endl;
- //Assert( d_children.size()==d_children_order.size() );
-
-}
-
-void MatchGen::collectBoundVar( QuantInfo * qi, Node n, std::vector< int >& cbvars ) {
- int v = qi->getVarNum( n );
- if( v!=-1 && std::find( cbvars.begin(), cbvars.end(), v )==cbvars.end() ){
- cbvars.push_back( v );
- }
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- collectBoundVar( qi, n[i], cbvars );
- }
-}
-
-void MatchGen::determineVariableOrder( QuantInfo * qi, std::vector< int >& bvars ) {
- Trace("qcf-qregister-debug") << "Determine variable order " << d_n << std::endl;
- bool isCom = d_type==typ_formula && ( d_n.getKind()==OR || d_n.getKind()==AND || d_n.getKind()==IFF );
- std::map< int, std::vector< int > > c_to_vars;
- std::map< int, std::vector< int > > vars_to_c;
- std::map< int, int > vb_count;
- std::map< int, int > vu_count;
- std::vector< bool > assigned;
- Trace("qcf-qregister-debug") << "Calculate bound variables..." << std::endl;
- for( unsigned i=0; i<d_children.size(); i++ ){
- collectBoundVar( qi, d_children[i].d_n, c_to_vars[i] );
- assigned.push_back( false );
- vb_count[i] = 0;
- vu_count[i] = 0;
- for( unsigned j=0; j<c_to_vars[i].size(); j++ ){
- int v = c_to_vars[i][j];
- vars_to_c[v].push_back( i );
- if( std::find( bvars.begin(), bvars.end(), v )==bvars.end() ){
- vu_count[i]++;
- if( !isCom ){
- bvars.push_back( v );
- }
- }else{
- vb_count[i]++;
- }
- }
- }
- if( isCom ){
- //children that bind the least number of unbound variables go first
- do {
- int min_score = -1;
- int min_score_index = -1;
- for( unsigned i=0; i<d_children.size(); i++ ){
- if( !assigned[i] ){
- int score = vu_count[i];
- if( min_score==-1 || score<min_score ){
- min_score = score;
- min_score_index = i;
- }
- }
- }
- Trace("qcf-qregister-debug") << "...assign child " << min_score_index << "/" << d_children.size() << std::endl;
- Assert( min_score_index!=-1 );
- //add to children order
- d_children_order.push_back( min_score_index );
- assigned[min_score_index] = true;
- //if( vb_count[min_score_index]==0 ){
- // d_independent.push_back( min_score_index );
- //}
- //determine order internal to children
- d_children[min_score_index].determineVariableOrder( qi, bvars );
- Trace("qcf-qregister-debug") << "...bind variables" << std::endl;
- //now, make it a bound variable
- for( unsigned i=0; i<c_to_vars[min_score_index].size(); i++ ){
- int v = c_to_vars[min_score_index][i];
- if( std::find( bvars.begin(), bvars.end(), v )==bvars.end() ){
- for( unsigned j=0; j<vars_to_c[v].size(); j++ ){
- int vc = vars_to_c[v][j];
- vu_count[vc]--;
- vb_count[vc]++;
- }
- bvars.push_back( v );
- }
- }
- Trace("qcf-qregister-debug") << "...done assign child " << min_score_index << std::endl;
- }while( d_children_order.size()!=d_children.size() );
- Trace("qcf-qregister-debug") << "Done assign variable ordering for " << d_n << std::endl;
- }else{
- for( unsigned i=0; i<d_children.size(); i++ ){
- d_children_order.push_back( i );
- d_children[i].determineVariableOrder( qi, bvars );
- }
- }
-}
-
-
-void MatchGen::reset_round( QuantConflictFind * p ) {
- d_wasSet = false;
- for( unsigned i=0; i<d_children.size(); i++ ){
- d_children[i].reset_round( p );
- }
- for( std::map< int, TNode >::iterator it = d_qni_gterm.begin(); it != d_qni_gterm.end(); ++it ){
- d_qni_gterm_rep[it->first] = p->getRepresentative( it->second );
- }
- if( d_type==typ_ground ){
- int e = p->evaluate( d_n );
- if( e==1 ){
- d_ground_eval[0] = p->d_true;
- }else if( e==-1 ){
- d_ground_eval[0] = p->d_false;
- }
- }else if( d_type==typ_eq ){
- for( unsigned i=0; i<d_n.getNumChildren(); i++ ){
- if( !d_n[i].hasBoundVar() ){
- d_ground_eval[i] = p->evaluateTerm( d_n[i] );
- }
- }
- }
- d_qni_bound_cons.clear();
- d_qni_bound_cons_var.clear();
- d_qni_bound.clear();
-}
-
-void MatchGen::reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ) {
- d_tgt = d_type_not ? !tgt : tgt;
- Debug("qcf-match") << " Reset for : " << d_n << ", type : ";
- debugPrintType( "qcf-match", d_type );
- Debug("qcf-match") << ", tgt = " << d_tgt << ", children = " << d_children.size() << " " << d_children_order.size() << std::endl;
- d_qn.clear();
- d_qni.clear();
- d_qni_bound.clear();
- d_child_counter = -1;
- d_tgt_orig = d_tgt;
-
- //set up processing matches
- if( d_type==typ_invalid ){
- //do nothing
- }else if( d_type==typ_ground ){
- if( d_ground_eval[0]==( d_tgt ? p->d_true : p->d_false ) ){
- d_child_counter = 0;
- }
- }else if( d_type==typ_bool_var ){
- //get current value of the variable
- TNode n = qi->getCurrentValue( d_n );
- int vn = qi->getCurrentRepVar( qi->getVarNum( n ) );
- if( vn==-1 ){
- //evaluate the value, see if it is compatible
- int e = p->evaluate( n );
- if( ( e==1 && d_tgt ) || ( e==0 && !d_tgt ) ){
- d_child_counter = 0;
- }
- }else{
- //unassigned, set match to true/false
- d_qni_bound[0] = vn;
- qi->setMatch( p, vn, d_tgt ? p->d_true : p->d_false );
- d_child_counter = 0;
- }
- if( d_child_counter==0 ){
- d_qn.push_back( NULL );
- }
- }else if( d_type==typ_var ){
- Assert( isHandledUfTerm( d_n ) );
- Node f = getOperator( p, d_n );
- Debug("qcf-match-debug") << " reset: Var will match operators of " << f << std::endl;
- TermArgTrie * qni = p->getTermDatabase()->getTermArgTrie( Node::null(), f );
- if( qni!=NULL ){
- d_qn.push_back( qni );
- }
- d_matched_basis = false;
- }else if( d_type==typ_tsym || d_type==typ_tconstraint ){
- for( std::map< int, int >::iterator it = d_qni_var_num.begin(); it != d_qni_var_num.end(); ++it ){
- int repVar = qi->getCurrentRepVar( it->second );
- if( qi->d_match[repVar].isNull() ){
- Debug("qcf-match-debug") << "Force matching on child #" << it->first << ", which is var #" << repVar << std::endl;
- d_qni_bound[it->first] = repVar;
- }
- }
- d_qn.push_back( NULL );
- }else if( d_type==typ_pred || d_type==typ_eq ){
- //add initial constraint
- Node nn[2];
- int vn[2];
- if( d_type==typ_pred ){
- nn[0] = qi->getCurrentValue( d_n );
- vn[0] = qi->getCurrentRepVar( qi->getVarNum( nn[0] ) );
- nn[1] = p->getRepresentative( d_tgt ? p->d_true : p->d_false );
- vn[1] = -1;
- d_tgt = true;
- }else{
- for( unsigned i=0; i<2; i++ ){
- TNode nc;
- std::map< int, TNode >::iterator it = d_qni_gterm_rep.find( i );
- if( it!=d_qni_gterm_rep.end() ){
- nc = it->second;
- }else{
- nc = d_n[i];
- }
- nn[i] = qi->getCurrentValue( nc );
- vn[i] = qi->getCurrentRepVar( qi->getVarNum( nn[i] ) );
- }
- }
- bool success;
- if( vn[0]==-1 && vn[1]==-1 ){
- //Trace("qcf-explain") << " reset : " << d_n << " check ground values " << nn[0] << " " << nn[1] << " (tgt=" << d_tgt << ")" << std::endl;
- Debug("qcf-match-debug") << " reset: check ground values " << nn[0] << " " << nn[1] << " (" << d_tgt << ")" << std::endl;
- //just compare values
- if( d_tgt ){
- success = p->areMatchEqual( nn[0], nn[1] );
- }else{
- if( p->d_effort==QuantConflictFind::effort_conflict ){
- success = p->areDisequal( nn[0], nn[1] );
- }else{
- success = p->areMatchDisequal( nn[0], nn[1] );
- }
- }
- }else{
- //otherwise, add a constraint to a variable
- if( vn[1]!=-1 && vn[0]==-1 ){
- //swap
- Node t = nn[1];
- nn[1] = nn[0];
- nn[0] = t;
- vn[0] = vn[1];
- vn[1] = -1;
- }
- Debug("qcf-match-debug") << " reset: add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << std::endl;
- //add some constraint
- int addc = qi->addConstraint( p, vn[0], nn[1], vn[1], d_tgt, false );
- success = addc!=-1;
- //if successful and non-redundant, store that we need to cleanup this
- if( addc==1 ){
- //Trace("qcf-explain") << " reset: " << d_n << " add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << ", d_tgt = " << d_tgt << std::endl;
- for( unsigned i=0; i<2; i++ ){
- if( vn[i]!=-1 && std::find( d_qni_bound_except.begin(), d_qni_bound_except.end(), i )==d_qni_bound_except.end() ){
- d_qni_bound[vn[i]] = vn[i];
- }
- }
- d_qni_bound_cons[vn[0]] = nn[1];
- d_qni_bound_cons_var[vn[0]] = vn[1];
- }
- }
- //if successful, we will bind values to variables
- if( success ){
- d_qn.push_back( NULL );
- }
- }else{
- if( d_children.empty() ){
- //add dummy
- d_qn.push_back( NULL );
- }else{
- if( d_tgt && d_n.getKind()==FORALL ){
- //do nothing
- }else{
- //reset the first child to d_tgt
- d_child_counter = 0;
- getChild( d_child_counter )->reset( p, d_tgt, qi );
- }
- }
- }
- d_binding = false;
- d_wasSet = true;
- Debug("qcf-match") << " reset: Finished reset for " << d_n << ", success = " << ( !d_qn.empty() || d_child_counter!=-1 ) << std::endl;
-}
-
-bool MatchGen::getNextMatch( QuantConflictFind * p, QuantInfo * qi ) {
- Debug("qcf-match") << " Get next match for : " << d_n << ", type = ";
- debugPrintType( "qcf-match", d_type );
- Debug("qcf-match") << ", children = " << d_children.size() << ", binding = " << d_binding << std::endl;
- if( d_type==typ_invalid || d_type==typ_ground ){
- if( d_child_counter==0 ){
- d_child_counter = -1;
- return true;
- }else{
- d_wasSet = false;
- return false;
- }
- }else if( d_type==typ_var || d_type==typ_eq || d_type==typ_pred || d_type==typ_bool_var || d_type==typ_tconstraint || d_type==typ_tsym ){
- bool success = false;
- bool terminate = false;
- do {
- bool doReset = false;
- bool doFail = false;
- if( !d_binding ){
- if( doMatching( p, qi ) ){
- Debug("qcf-match-debug") << " - Matching succeeded" << std::endl;
- d_binding = true;
- d_binding_it = d_qni_bound.begin();
- doReset = true;
- //for tconstraint, add constraint
- if( d_type==typ_tconstraint ){
- std::map< Node, bool >::iterator it = qi->d_tconstraints.find( d_n );
- if( it==qi->d_tconstraints.end() ){
- qi->d_tconstraints[d_n] = d_tgt;
- //store that we added this constraint
- d_qni_bound_cons[0] = d_n;
- }else if( d_tgt!=it->second ){
- success = false;
- terminate = true;
- }
- }
- }else{
- Debug("qcf-match-debug") << " - Matching failed" << std::endl;
- success = false;
- terminate = true;
- }
- }else{
- doFail = true;
- }
- if( d_binding ){
- //also need to create match for each variable we bound
- success = true;
- Debug("qcf-match-debug") << " Produce matches for bound variables by " << d_n << ", type = ";
- debugPrintType( "qcf-match-debug", d_type );
- Debug("qcf-match-debug") << "..." << std::endl;
-
- while( ( success && d_binding_it!=d_qni_bound.end() ) || doFail ){
- std::map< int, MatchGen * >::iterator itm;
- if( !doFail ){
- Debug("qcf-match-debug") << " check variable " << d_binding_it->second << std::endl;
- itm = qi->d_var_mg.find( d_binding_it->second );
- }
- if( doFail || ( d_binding_it->first!=0 && itm!=qi->d_var_mg.end() ) ){
- Debug("qcf-match-debug") << " we had bound variable " << d_binding_it->second << ", reset = " << doReset << std::endl;
- if( doReset ){
- itm->second->reset( p, true, qi );
- }
- if( doFail || !itm->second->getNextMatch( p, qi ) ){
- do {
- if( d_binding_it==d_qni_bound.begin() ){
- Debug("qcf-match-debug") << " failed." << std::endl;
- success = false;
- }else{
- --d_binding_it;
- Debug("qcf-match-debug") << " decrement..." << std::endl;
- }
- }while( success && ( d_binding_it->first==0 || qi->d_var_mg.find( d_binding_it->second )==qi->d_var_mg.end() ) );
- doReset = false;
- doFail = false;
- }else{
- Debug("qcf-match-debug") << " increment..." << std::endl;
- ++d_binding_it;
- doReset = true;
- }
- }else{
- Debug("qcf-match-debug") << " skip..." << d_binding_it->second << std::endl;
- ++d_binding_it;
- doReset = true;
- }
- }
- if( !success ){
- d_binding = false;
- }else{
- terminate = true;
- if( d_binding_it==d_qni_bound.begin() ){
- d_binding = false;
- }
- }
- }
- }while( !terminate );
- //if not successful, clean up the variables you bound
- if( !success ){
- if( d_type==typ_eq || d_type==typ_pred ){
- //clean up the constraints you added
- for( std::map< int, TNode >::iterator it = d_qni_bound_cons.begin(); it != d_qni_bound_cons.end(); ++it ){
- if( !it->second.isNull() ){
- Debug("qcf-match") << " Clean up bound var " << it->first << (d_tgt ? "!" : "") << " = " << it->second << std::endl;
- std::map< int, int >::iterator itb = d_qni_bound_cons_var.find( it->first );
- int vn = itb!=d_qni_bound_cons_var.end() ? itb->second : -1;
- //Trace("qcf-explain") << " cleanup: " << d_n << " remove constraint " << it->first << " -> " << it->second << " (vn=" << vn << ")" << ", d_tgt = " << d_tgt << std::endl;
- qi->addConstraint( p, it->first, it->second, vn, d_tgt, true );
- }
- }
- d_qni_bound_cons.clear();
- d_qni_bound_cons_var.clear();
- d_qni_bound.clear();
- }else{
- //clean up the matches you set
- for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){
- Debug("qcf-match") << " Clean up bound var " << it->second << std::endl;
- Assert( it->second<qi->getNumVars() );
- qi->d_match[ it->second ] = TNode::null();
- qi->d_match_term[ it->second ] = TNode::null();
- }
- d_qni_bound.clear();
- }
- if( d_type==typ_tconstraint ){
- //remove constraint if applicable
- if( d_qni_bound_cons.find( 0 )!=d_qni_bound_cons.end() ){
- qi->d_tconstraints.erase( d_n );
- d_qni_bound_cons.clear();
- }
- }
- /*
- if( d_type==typ_var && p->d_effort==QuantConflictFind::effort_mc && !d_matched_basis ){
- d_matched_basis = true;
- Node f = getOperator( d_n );
- TNode mbo = p->getTermDatabase()->getModelBasisOpTerm( f );
- if( qi->setMatch( p, d_qni_var_num[0], mbo ) ){
- success = true;
- d_qni_bound[0] = d_qni_var_num[0];
- }
- }
- */
- }
- Debug("qcf-match") << " ...finished matching for " << d_n << ", success = " << success << std::endl;
- d_wasSet = success;
- return success;
- }else if( d_type==typ_formula || d_type==typ_ite_var ){
- bool success = false;
- if( d_child_counter<0 ){
- if( d_child_counter<-1 ){
- success = true;
- d_child_counter = -1;
- }
- }else{
- while( !success && d_child_counter>=0 ){
- //transition system based on d_child_counter
- if( d_n.getKind()==OR || d_n.getKind()==AND ){
- if( (d_n.getKind()==AND)==d_tgt ){
- //all children must match simultaneously
- if( getChild( d_child_counter )->getNextMatch( p, qi ) ){
- if( d_child_counter<(int)(getNumChildren()-1) ){
- d_child_counter++;
- Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << std::endl;
- getChild( d_child_counter )->reset( p, d_tgt, qi );
- }else{
- success = true;
- }
- }else{
- //if( std::find( d_independent.begin(), d_independent.end(), d_child_counter )!=d_independent.end() ){
- // d_child_counter--;
- //}else{
- d_child_counter--;
- //}
- }
- }else{
- //one child must match
- if( !getChild( d_child_counter )->getNextMatch( p, qi ) ){
- if( d_child_counter<(int)(getNumChildren()-1) ){
- d_child_counter++;
- Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << ", one match" << std::endl;
- getChild( d_child_counter )->reset( p, d_tgt, qi );
- }else{
- d_child_counter = -1;
- }
- }else{
- success = true;
- }
- }
- }else if( d_n.getKind()==IFF ){
- //construct match based on both children
- if( d_child_counter%2==0 ){
- if( getChild( 0 )->getNextMatch( p, qi ) ){
- d_child_counter++;
- getChild( 1 )->reset( p, d_child_counter==1, qi );
- }else{
- if( d_child_counter==0 ){
- d_child_counter = 2;
- getChild( 0 )->reset( p, !d_tgt, qi );
- }else{
- d_child_counter = -1;
- }
- }
- }
- if( d_child_counter>=0 && d_child_counter%2==1 ){
- if( getChild( 1 )->getNextMatch( p, qi ) ){
- success = true;
- }else{
- d_child_counter--;
- }
- }
- }else if( d_n.getKind()==ITE ){
- if( d_child_counter%2==0 ){
- int index1 = d_child_counter==4 ? 1 : 0;
- if( getChild( index1 )->getNextMatch( p, qi ) ){
- d_child_counter++;
- getChild( d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2) )->reset( p, d_tgt, qi );
- }else{
- if( d_child_counter==4 || ( d_type==typ_ite_var && d_child_counter==2 ) ){
- d_child_counter = -1;
- }else{
- d_child_counter +=2;
- getChild( d_child_counter==2 ? 0 : 1 )->reset( p, d_child_counter==2 ? !d_tgt : d_tgt, qi );
- }
- }
- }
- if( d_child_counter>=0 && d_child_counter%2==1 ){
- int index2 = d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2);
- if( getChild( index2 )->getNextMatch( p, qi ) ){
- success = true;
- }else{
- d_child_counter--;
- }
- }
- }else if( d_n.getKind()==FORALL ){
- if( getChild( d_child_counter )->getNextMatch( p, qi ) ){
- success = true;
- }else{
- d_child_counter = -1;
- }
- }
- }
- d_wasSet = success;
- Debug("qcf-match") << " ...finished construct match for " << d_n << ", success = " << success << std::endl;
- return success;
- }
- }
- Debug("qcf-match") << " ...already finished for " << d_n << std::endl;
- return false;
-}
-
-bool MatchGen::getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ) {
- if( d_type==typ_eq ){
- Node n[2];
- for( unsigned i=0; i<2; i++ ){
- Trace("qcf-explain") << "Explain term " << d_n[i] << "..." << std::endl;
- n[i] = getExplanationTerm( p, qi, d_n[i], exp );
- }
- Node eq = n[0].eqNode( n[1] );
- if( !d_tgt_orig ){
- eq = eq.negate();
- }
- exp.push_back( eq );
- Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << eq << ", set = " << d_wasSet << std::endl;
- return true;
- }else if( d_type==typ_pred ){
- Trace("qcf-explain") << "Explain term " << d_n << "..." << std::endl;
- Node n = getExplanationTerm( p, qi, d_n, exp );
- if( !d_tgt_orig ){
- n = n.negate();
- }
- exp.push_back( n );
- Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << n << ", set = " << d_wasSet << std::endl;
- return true;
- }else if( d_type==typ_formula ){
- Trace("qcf-explain") << "Explanation get for " << d_n << ", counter = " << d_child_counter << ", tgt = " << d_tgt_orig << ", set = " << d_wasSet << std::endl;
- if( d_n.getKind()==OR || d_n.getKind()==AND ){
- if( (d_n.getKind()==AND)==d_tgt ){
- for( unsigned i=0; i<getNumChildren(); i++ ){
- if( !getChild( i )->getExplanation( p, qi, exp ) ){
- return false;
- }
- }
- }else{
- return getChild( d_child_counter )->getExplanation( p, qi, exp );
- }
- }else if( d_n.getKind()==IFF ){
- for( unsigned i=0; i<2; i++ ){
- if( !getChild( i )->getExplanation( p, qi, exp ) ){
- return false;
- }
- }
- }else if( d_n.getKind()==ITE ){
- for( unsigned i=0; i<3; i++ ){
- bool isActive = ( ( i==0 && d_child_counter!=5 ) ||
- ( i==1 && d_child_counter!=( d_tgt ? 3 : 1 ) ) ||
- ( i==2 && d_child_counter!=( d_tgt ? 1 : 3 ) ) );
- if( isActive ){
- if( !getChild( i )->getExplanation( p, qi, exp ) ){
- return false;
- }
- }
- }
- }else{
- return false;
- }
- return true;
- }else{
- return false;
- }
-}
-
-Node MatchGen::getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ) {
- Node v = qi->getCurrentExpValue( t );
- if( isHandledUfTerm( t ) ){
- for( unsigned i=0; i<t.getNumChildren(); i++ ){
- Node vi = getExplanationTerm( p, qi, t[i], exp );
- if( vi!=v[i] ){
- Node eq = vi.eqNode( v[i] );
- if( std::find( exp.begin(), exp.end(), eq )==exp.end() ){
- Trace("qcf-explain") << " add : " << eq << "." << std::endl;
- exp.push_back( eq );
- }
- }
- }
- }
- return v;
-}
-
-bool MatchGen::doMatching( QuantConflictFind * p, QuantInfo * qi ) {
- if( !d_qn.empty() ){
- if( d_qn[0]==NULL ){
- d_qn.clear();
- return true;
- }else{
- Assert( d_type==typ_var );
- Assert( d_qni_size>0 );
- bool invalidMatch;
- do {
- invalidMatch = false;
- Debug("qcf-match-debug") << " Do matching " << d_n << " " << d_qn.size() << " " << d_qni.size() << std::endl;
- if( d_qn.size()==d_qni.size()+1 ) {
- int index = (int)d_qni.size();
- //initialize
- TNode val;
- std::map< int, int >::iterator itv = d_qni_var_num.find( index );
- if( itv!=d_qni_var_num.end() ){
- //get the representative variable this variable is equal to
- int repVar = qi->getCurrentRepVar( itv->second );
- Debug("qcf-match-debug") << " Match " << index << " is a variable " << itv->second << ", which is repVar " << repVar << std::endl;
- //get the value the rep variable
- //std::map< int, TNode >::iterator itm = qi->d_match.find( repVar );
- if( !qi->d_match[repVar].isNull() ){
- val = qi->d_match[repVar];
- Debug("qcf-match-debug") << " Variable is already bound to " << val << std::endl;
- }else{
- //binding a variable
- d_qni_bound[index] = repVar;
- std::map< TNode, TermArgTrie >::iterator it = d_qn[index]->d_data.begin();
- if( it != d_qn[index]->d_data.end() ) {
- d_qni.push_back( it );
- //set the match
- if( it->first.getType().isSubtypeOf( qi->d_var_types[repVar] ) && qi->setMatch( p, d_qni_bound[index], it->first ) ){
- Debug("qcf-match-debug") << " Binding variable" << std::endl;
- if( d_qn.size()<d_qni_size ){
- d_qn.push_back( &it->second );
- }
- }else{
- Debug("qcf-match") << " Binding variable, currently fail." << std::endl;
- invalidMatch = true;
- }
- }else{
- Debug("qcf-match-debug") << " Binding variable, fail, no more variables to bind" << std::endl;
- d_qn.pop_back();
- }
- }
- }else{
- Debug("qcf-match-debug") << " Match " << index << " is ground term" << std::endl;
- Assert( d_qni_gterm.find( index )!=d_qni_gterm.end() );
- Assert( d_qni_gterm_rep.find( index )!=d_qni_gterm_rep.end() );
- val = d_qni_gterm_rep[index];
- Assert( !val.isNull() );
- }
- if( !val.isNull() ){
- //constrained by val
- std::map< TNode, TermArgTrie >::iterator it = d_qn[index]->d_data.find( val );
- if( it!=d_qn[index]->d_data.end() ){
- Debug("qcf-match-debug") << " Match" << std::endl;
- d_qni.push_back( it );
- if( d_qn.size()<d_qni_size ){
- d_qn.push_back( &it->second );
- }
- }else{
- Debug("qcf-match-debug") << " Failed to match" << std::endl;
- d_qn.pop_back();
- }
- }
- }else{
- Assert( d_qn.size()==d_qni.size() );
- int index = d_qni.size()-1;
- //increment if binding this variable
- bool success = false;
- std::map< int, int >::iterator itb = d_qni_bound.find( index );
- if( itb!=d_qni_bound.end() ){
- d_qni[index]++;
- if( d_qni[index]!=d_qn[index]->d_data.end() ){
- success = true;
- if( qi->setMatch( p, itb->second, d_qni[index]->first ) ){
- Debug("qcf-match-debug") << " Bind next variable" << std::endl;
- if( d_qn.size()<d_qni_size ){
- d_qn.push_back( &d_qni[index]->second );
- }
- }else{
- Debug("qcf-match-debug") << " Bind next variable, currently fail" << std::endl;
- invalidMatch = true;
- }
- }else{
- qi->d_match[ itb->second ] = TNode::null();
- qi->d_match_term[ itb->second ] = TNode::null();
- Debug("qcf-match-debug") << " Bind next variable, no more variables to bind" << std::endl;
- }
- }else{
- //TODO : if it equal to something else, also try that
- }
- //if not incrementing, move to next
- if( !success ){
- d_qn.pop_back();
- d_qni.pop_back();
- }
- }
- }while( ( !d_qn.empty() && d_qni.size()!=d_qni_size ) || invalidMatch );
- if( d_qni.size()==d_qni_size ){
- //Assert( !d_qni[d_qni.size()-1]->second.d_data.empty() );
- //Debug("qcf-match-debug") << " We matched " << d_qni[d_qni.size()-1]->second.d_children.begin()->first << std::endl;
- Assert( !d_qni[d_qni.size()-1]->second.d_data.empty() );
- TNode t = d_qni[d_qni.size()-1]->second.d_data.begin()->first;
- Debug("qcf-match-debug") << " " << d_n << " matched " << t << std::endl;
- qi->d_match_term[d_qni_var_num[0]] = t;
- //set the match terms
- for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){
- Debug("qcf-match-debug") << " position " << it->first << " bounded " << it->second << " / " << qi->d_q[0].getNumChildren() << std::endl;
- //if( it->second<(int)qi->d_q[0].getNumChildren() ){ //if it is an actual variable, we are interested in knowing the actual term
- if( it->first>0 ){
- Assert( !qi->d_match[ it->second ].isNull() );
- Assert( p->areEqual( t[it->first-1], qi->d_match[ it->second ] ) );
- qi->d_match_term[it->second] = t[it->first-1];
- }
- //}
- }
- }
- }
- }
- return !d_qn.empty();
-}
-
-void MatchGen::debugPrintType( const char * c, short typ, bool isTrace ) {
- if( isTrace ){
- switch( typ ){
- case typ_invalid: Trace(c) << "invalid";break;
- case typ_ground: Trace(c) << "ground";break;
- case typ_eq: Trace(c) << "eq";break;
- case typ_pred: Trace(c) << "pred";break;
- case typ_formula: Trace(c) << "formula";break;
- case typ_var: Trace(c) << "var";break;
- case typ_ite_var: Trace(c) << "ite_var";break;
- case typ_bool_var: Trace(c) << "bool_var";break;
- }
- }else{
- switch( typ ){
- case typ_invalid: Debug(c) << "invalid";break;
- case typ_ground: Debug(c) << "ground";break;
- case typ_eq: Debug(c) << "eq";break;
- case typ_pred: Debug(c) << "pred";break;
- case typ_formula: Debug(c) << "formula";break;
- case typ_var: Debug(c) << "var";break;
- case typ_ite_var: Debug(c) << "ite_var";break;
- case typ_bool_var: Debug(c) << "bool_var";break;
- }
- }
-}
-
-void MatchGen::setInvalid() {
- d_type = typ_invalid;
- d_children.clear();
-}
-
-bool MatchGen::isHandledBoolConnective( TNode n ) {
- return n.getType().isBoolean() && ( n.getKind()==OR || n.getKind()==AND || n.getKind()==IFF || n.getKind()==ITE || n.getKind()==FORALL || n.getKind()==NOT );
-}
-
-bool MatchGen::isHandledUfTerm( TNode n ) {
- //return n.getKind()==APPLY_UF || n.getKind()==STORE || n.getKind()==SELECT ||
- // n.getKind()==APPLY_CONSTRUCTOR || n.getKind()==APPLY_SELECTOR_TOTAL || n.getKind()==APPLY_TESTER;
- return inst::Trigger::isAtomicTriggerKind( n.getKind() );
-}
-
-Node MatchGen::getOperator( QuantConflictFind * p, Node n ) {
- if( isHandledUfTerm( n ) ){
- return p->getTermDatabase()->getOperator( n );
- }else{
- return Node::null();
- }
-}
-
-bool MatchGen::isHandled( TNode n ) {
- if( n.getKind()!=BOUND_VARIABLE && n.hasBoundVar() ){
- if( !isHandledBoolConnective( n ) && !isHandledUfTerm( n ) && n.getKind()!=EQUAL && n.getKind()!=ITE ){
- return false;
- }
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- if( !isHandled( n[i] ) ){
- return false;
- }
- }
- }
- return true;
-}
-
-
-QuantConflictFind::QuantConflictFind( QuantifiersEngine * qe, context::Context* c ) :
-QuantifiersModule( qe ),
-d_conflict( c, false ),
-d_qassert( c ) {
- d_fid_count = 0;
- d_true = NodeManager::currentNM()->mkConst<bool>(true);
- d_false = NodeManager::currentNM()->mkConst<bool>(false);
-}
-
-Node QuantConflictFind::mkEqNode( Node a, Node b ) {
- if( a.getType().isBoolean() ){
- return a.iffNode( b );
- }else{
- return a.eqNode( b );
- }
-}
-
-//-------------------------------------------------- registration
-
-void QuantConflictFind::registerQuantifier( Node q ) {
- if( d_quantEngine->hasOwnership( q, this ) ){
- d_quants.push_back( q );
- d_quant_id[q] = d_quants.size();
- Trace("qcf-qregister") << "Register ";
- debugPrintQuant( "qcf-qregister", q );
- Trace("qcf-qregister") << " : " << q << std::endl;
- //make QcfNode structure
- Trace("qcf-qregister") << "- Get relevant equality/disequality pairs, calculate flattening..." << std::endl;
- d_qinfo[q].initialize( q, q[1] );
-
- //debug print
- Trace("qcf-qregister") << "- Flattened structure is :" << std::endl;
- Trace("qcf-qregister") << " ";
- debugPrintQuantBody( "qcf-qregister", q, q[1] );
- Trace("qcf-qregister") << std::endl;
- if( d_qinfo[q].d_vars.size()>q[0].getNumChildren() ){
- Trace("qcf-qregister") << " with additional constraints : " << std::endl;
- for( unsigned j=q[0].getNumChildren(); j<d_qinfo[q].d_vars.size(); j++ ){
- Trace("qcf-qregister") << " ?x" << j << " = ";
- debugPrintQuantBody( "qcf-qregister", q, d_qinfo[q].d_vars[j], false );
- Trace("qcf-qregister") << std::endl;
- }
- }
-
- Trace("qcf-qregister") << "Done registering quantifier." << std::endl;
- }
-}
-
-int QuantConflictFind::evaluate( Node n, bool pref, bool hasPref ) {
- int ret = 0;
- if( n.getKind()==EQUAL ){
- Node n1 = evaluateTerm( n[0] );
- Node n2 = evaluateTerm( n[1] );
- Debug("qcf-eval") << "Evaluate : Normalize " << n << " to " << n1 << " = " << n2 << std::endl;
- if( areEqual( n1, n2 ) ){
- ret = 1;
- }else if( areDisequal( n1, n2 ) ){
- ret = -1;
- }
- //else if( d_effort>QuantConflictFind::effort_conflict ){
- // ret = -1;
- //}
- }else if( MatchGen::isHandledUfTerm( n ) ){ //predicate
- Node nn = evaluateTerm( n );
- Debug("qcf-eval") << "Evaluate : Normalize " << nn << " to " << n << std::endl;
- if( areEqual( nn, d_true ) ){
- ret = 1;
- }else if( areEqual( nn, d_false ) ){
- ret = -1;
- }
- //else if( d_effort>QuantConflictFind::effort_conflict ){
- // ret = -1;
- //}
- }else if( n.getKind()==NOT ){
- return -evaluate( n[0] );
- }else if( n.getKind()==ITE ){
- int cev1 = evaluate( n[0] );
- int cevc[2] = { 0, 0 };
- for( unsigned i=0; i<2; i++ ){
- if( ( i==0 && cev1!=-1 ) || ( i==1 && cev1!=1 ) ){
- cevc[i] = evaluate( n[i+1] );
- if( cev1!=0 ){
- ret = cevc[i];
- break;
- }else if( cevc[i]==0 ){
- break;
- }
- }
- }
- if( ret==0 && cevc[0]!=0 && cevc[0]==cevc[1] ){
- ret = cevc[0];
- }
- }else if( n.getKind()==IFF ){
- int cev1 = evaluate( n[0] );
- if( cev1!=0 ){
- int cev2 = evaluate( n[1] );
- if( cev2!=0 ){
- ret = cev1==cev2 ? 1 : -1;
- }
- }
-
- }else{
- int ssval = 0;
- if( n.getKind()==OR ){
- ssval = 1;
- }else if( n.getKind()==AND ){
- ssval = -1;
- }
- bool isUnk = false;
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- int cev = evaluate( n[i] );
- if( cev==ssval ){
- ret = ssval;
- break;
- }else if( cev==0 ){
- isUnk = true;
- }
- }
- if( ret==0 && !isUnk ){
- ret = -ssval;
- }
- }
- Debug("qcf-eval") << "Evaluate " << n << " to " << ret << std::endl;
- return ret;
-}
-
-short QuantConflictFind::getMaxQcfEffort() {
- if( options::qcfMode()==QCF_CONFLICT_ONLY ){
- return effort_conflict;
- }else if( options::qcfMode()==QCF_PROP_EQ ){
- return effort_prop_eq;
- }else if( options::qcfMode()==QCF_MC ){
- return effort_mc;
- }else{
- return 0;
- }
-}
-
-bool QuantConflictFind::areMatchEqual( TNode n1, TNode n2 ) {
- //if( d_effort==QuantConflictFind::effort_mc ){
- // return n1==n2 || !areDisequal( n1, n2 );
- //}else{
- return n1==n2;
- //}
-}
-
-bool QuantConflictFind::areMatchDisequal( TNode n1, TNode n2 ) {
- //if( d_effort==QuantConflictFind::effort_conflict ){
- // return areDisequal( n1, n2 );
- //}else{
- return n1!=n2;
- //}
-}
-
-//-------------------------------------------------- handling assertions / eqc
-
-void QuantConflictFind::assertNode( Node q ) {
- if( d_quantEngine->hasOwnership( q, this ) ){
- Trace("qcf-proc") << "QCF : assertQuantifier : ";
- debugPrintQuant("qcf-proc", q);
- Trace("qcf-proc") << std::endl;
- d_qassert.push_back( q );
- //set the eqRegistries that this depends on to true
- //for( std::map< EqRegistry *, bool >::iterator it = d_qinfo[q].d_rel_eqr.begin(); it != d_qinfo[q].d_rel_eqr.end(); ++it ){
- // it->first->d_active.set( true );
- //}
- }
-}
-
-Node QuantConflictFind::evaluateTerm( Node n ) {
- if( MatchGen::isHandledUfTerm( n ) ){
- Node f = MatchGen::getOperator( this, n );
- Node nn;
- if( getEqualityEngine()->hasTerm( n ) ){
- nn = getTermDatabase()->existsTerm( f, n );
- }else{
- std::vector< TNode > args;
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- Node c = evaluateTerm( n[i] );
- args.push_back( c );
- }
- nn = getTermDatabase()->d_func_map_trie[f].existsTerm( args );
- }
- if( !nn.isNull() ){
- Debug("qcf-eval") << "GT: Term " << nn << " for " << n << " hasTerm = " << getEqualityEngine()->hasTerm( n ) << std::endl;
- return getRepresentative( nn );
- }else{
- Debug("qcf-eval") << "GT: No term for " << n << " hasTerm = " << getEqualityEngine()->hasTerm( n ) << std::endl;
- return n;
- }
- }else if( n.getKind()==ITE ){
- int v = evaluate( n[0], false, false );
- if( v==1 ){
- return evaluateTerm( n[1] );
- }else if( v==-1 ){
- return evaluateTerm( n[2] );
- }
- }
- return getRepresentative( n );
-}
-
-/** new node */
-void QuantConflictFind::newEqClass( Node n ) {
-
-}
-
-/** merge */
-void QuantConflictFind::merge( Node a, Node b ) {
-
-}
-
-/** assert disequal */
-void QuantConflictFind::assertDisequal( Node a, Node b ) {
-
-}
-
-//-------------------------------------------------- check function
-
-bool QuantConflictFind::needsCheck( Theory::Effort level ) {
- bool performCheck = false;
- if( options::quantConflictFind() && !d_conflict ){
- if( level==Theory::EFFORT_LAST_CALL ){
- performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_LAST_CALL;
- }else if( level==Theory::EFFORT_FULL ){
- performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_DEFAULT;
- }else if( level==Theory::EFFORT_STANDARD ){
- performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_STD;
- }
- }
- return performCheck;
-}
-
-void QuantConflictFind::reset_round( Theory::Effort level ) {
- d_needs_computeRelEqr = true;
-}
-
-/** check */
-void QuantConflictFind::check( Theory::Effort level, unsigned quant_e ) {
- if( quant_e==QuantifiersEngine::QEFFORT_CONFLICT ){
- Trace("qcf-check") << "QCF : check : " << level << std::endl;
- if( d_conflict ){
- Trace("qcf-check2") << "QCF : finished check : already in conflict." << std::endl;
- if( level>=Theory::EFFORT_FULL ){
- Trace("qcf-warn") << "ALREADY IN CONFLICT? " << level << std::endl;
- //Assert( false );
- }
- }else{
- int addedLemmas = 0;
- ++(d_statistics.d_inst_rounds);
- double clSet = 0;
- int prevEt = 0;
- if( Trace.isOn("qcf-engine") ){
- prevEt = d_statistics.d_entailment_checks.getData();
- clSet = double(clock())/double(CLOCKS_PER_SEC);
- Trace("qcf-engine") << "---Conflict Find Engine Round, effort = " << level << "---" << std::endl;
- }
- computeRelevantEqr();
-
- //determine order for quantified formulas
- std::vector< Node > qorder;
- std::map< Node, bool > qassert;
- //mark which are asserted
- for( unsigned i=0; i<d_qassert.size(); i++ ){
- qassert[d_qassert[i]] = true;
- }
- //add which ones are specified in the order
- for( unsigned i=0; i<d_quant_order.size(); i++ ){
- Node n = d_quant_order[i];
- if( std::find( qorder.begin(), qorder.end(), n )==qorder.end() && qassert.find( n )!=qassert.end() ){
- qorder.push_back( n );
- }
- }
- d_quant_order.clear();
- d_quant_order.insert( d_quant_order.begin(), qorder.begin(), qorder.end() );
- //add remaining
- for( unsigned i=0; i<d_qassert.size(); i++ ){
- Node n = d_qassert[i];
- if( std::find( qorder.begin(), qorder.end(), n )==qorder.end() ){
- qorder.push_back( n );
- }
- }
-
- if( Trace.isOn("qcf-debug") ){
- Trace("qcf-debug") << std::endl;
- debugPrint("qcf-debug");
- Trace("qcf-debug") << std::endl;
- }
- short end_e = getMaxQcfEffort();
- for( short e = effort_conflict; e<=end_e; e++ ){
- d_effort = e;
- Trace("qcf-check") << "Checking quantified formulas at effort " << e << "..." << std::endl;
- for( unsigned j=0; j<qorder.size(); j++ ){
- Node q = qorder[j];
- QuantInfo * qi = &d_qinfo[q];
-
- Assert( d_qinfo.find( q )!=d_qinfo.end() );
- if( qi->d_mg->isValid() ){
- Trace("qcf-check") << "Check quantified formula ";
- debugPrintQuant("qcf-check", q);
- Trace("qcf-check") << " : " << q << "..." << std::endl;
-
- Trace("qcf-check-debug") << "Reset round..." << std::endl;
- qi->reset_round( this );
- //try to make a matches making the body false
- Trace("qcf-check-debug") << "Get next match..." << std::endl;
- while( qi->d_mg->getNextMatch( this, qi ) ){
- Trace("qcf-inst") << "*** Produced match at effort " << e << " : " << std::endl;
- qi->debugPrintMatch("qcf-inst");
- Trace("qcf-inst") << std::endl;
- std::vector< int > assigned;
- if( !qi->isMatchSpurious( this ) ){
- if( qi->completeMatch( this, assigned ) ){
- std::vector< Node > terms;
- qi->getMatch( terms );
- if( !qi->isTConstraintSpurious( this, terms ) ){
- if( Debug.isOn("qcf-check-inst") ){
- //if( e==effort_conflict ){
- Node inst = d_quantEngine->getInstantiation( q, terms );
- Debug("qcf-check-inst") << "Check instantiation " << inst << "..." << std::endl;
- Assert( evaluate( inst )!=1 );
- Assert( evaluate( inst )==-1 || e>effort_conflict );
- //}
- }
- if( d_quantEngine->addInstantiation( q, terms, false ) ){
- Trace("qcf-check") << " ... Added instantiation" << std::endl;
- Trace("qcf-inst") << "*** Was from effort " << e << " : " << std::endl;
- qi->debugPrintMatch("qcf-inst");
- Trace("qcf-inst") << std::endl;
- ++addedLemmas;
- if( e==effort_conflict ){
- d_quant_order.insert( d_quant_order.begin(), q );
- d_conflict.set( true );
- ++(d_statistics.d_conflict_inst);
- break;
- }else if( e==effort_prop_eq ){
- ++(d_statistics.d_prop_inst);
- }
- }else{
- Trace("qcf-inst") << " ... Failed to add instantiation" << std::endl;
- //Assert( false );
- }
- }
- //clean up assigned
- qi->revertMatch( assigned );
- d_tempCache.clear();
- }else{
- Trace("qcf-inst") << " ... Spurious instantiation (cannot assign unassigned variables)" << std::endl;
- }
- }else{
- Trace("qcf-inst") << " ... Spurious instantiation (match is inconsistent)" << std::endl;
- }
- }
- if( d_conflict ){
- break;
- }
- }
- }
- if( addedLemmas>0 ){
- break;
- }
- }
- if( Trace.isOn("qcf-engine") ){
- double clSet2 = double(clock())/double(CLOCKS_PER_SEC);
- Trace("qcf-engine") << "Finished conflict find engine, time = " << (clSet2-clSet);
- if( addedLemmas>0 ){
- Trace("qcf-engine") << ", effort = " << ( d_effort==effort_conflict ? "conflict" : ( d_effort==effort_prop_eq ? "prop_eq" : "mc" ) );
- Trace("qcf-engine") << ", addedLemmas = " << addedLemmas;
- }
- Trace("qcf-engine") << std::endl;
- int currEt = d_statistics.d_entailment_checks.getData();
- if( currEt!=prevEt ){
- Trace("qcf-engine") << " Entailment checks = " << ( currEt - prevEt ) << std::endl;
- }
- }
- Trace("qcf-check2") << "QCF : finished check : " << level << std::endl;
- }
- }
-}
-
-void QuantConflictFind::computeRelevantEqr() {
- if( d_needs_computeRelEqr ){
- d_needs_computeRelEqr = false;
- Trace("qcf-check") << "Compute relevant equalities..." << std::endl;
- //d_uf_terms.clear();
- //d_eqc_uf_terms.clear();
- d_eqcs.clear();
- d_model_basis.clear();
- //d_arg_reps.clear();
- //double clSet = 0;
- //if( Trace.isOn("qcf-opt") ){
- // clSet = double(clock())/double(CLOCKS_PER_SEC);
- //}
-
- //long nTermst = 0;
- //long nTerms = 0;
- //long nEqc = 0;
-
- //which nodes are irrelevant for disequality matches
- std::map< TNode, bool > irrelevant_dnode;
- //now, store matches
- eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() );
- while( !eqcs_i.isFinished() ){
- //nEqc++;
- Node r = (*eqcs_i);
- if( getTermDatabase()->hasTermCurrent( r ) ){
- TypeNode rtn = r.getType();
- if( options::qcfMode()==QCF_MC ){
- std::map< TypeNode, std::vector< TNode > >::iterator itt = d_eqcs.find( rtn );
- if( itt==d_eqcs.end() ){
- Node mb = getTermDatabase()->getModelBasisTerm( rtn );
- if( !getEqualityEngine()->hasTerm( mb ) ){
- Trace("qcf-warn") << "WARNING: Model basis term does not exist!" << std::endl;
- Assert( false );
- }
- Node mbr = getRepresentative( mb );
- if( mbr!=r ){
- d_eqcs[rtn].push_back( mbr );
- }
- d_eqcs[rtn].push_back( r );
- d_model_basis[rtn] = mb;
- }else{
- itt->second.push_back( r );
- }
- }else{
- d_eqcs[rtn].push_back( r );
- }
- }
- ++eqcs_i;
- }
- /*
- if( Trace.isOn("qcf-opt") ){
- double clSet2 = double(clock())/double(CLOCKS_PER_SEC);
- Trace("qcf-opt") << "Compute rel eqc : " << std::endl;
- Trace("qcf-opt") << " " << nEqc << " equivalence classes. " << std::endl;
- Trace("qcf-opt") << " " << nTerms << " / " << nTermst << " terms." << std::endl;
- Trace("qcf-opt") << " Time : " << (clSet2-clSet) << std::endl;
- }
- */
- }
-}
-
-
-//-------------------------------------------------- debugging
-
-
-void QuantConflictFind::debugPrint( const char * c ) {
- //print the equivalance classes
- Trace(c) << "----------EQ classes" << std::endl;
- eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() );
- while( !eqcs_i.isFinished() ){
- Node n = (*eqcs_i);
- //if( !n.getType().isInteger() ){
- Trace(c) << " - " << n << " : {";
- eq::EqClassIterator eqc_i = eq::EqClassIterator( n, getEqualityEngine() );
- bool pr = false;
- while( !eqc_i.isFinished() ){
- Node nn = (*eqc_i);
- if( nn.getKind()!=EQUAL && nn!=n ){
- Trace(c) << (pr ? "," : "" ) << " " << nn;
- pr = true;
- }
- ++eqc_i;
- }
- Trace(c) << (pr ? " " : "" ) << "}" << std::endl;
- /*
- EqcInfo * eqcn = getEqcInfo( n, false );
- if( eqcn ){
- Trace(c) << " DEQ : {";
- pr = false;
- for( NodeBoolMap::iterator it = eqcn->d_diseq.begin(); it != eqcn->d_diseq.end(); ++it ){
- if( (*it).second ){
- Trace(c) << (pr ? "," : "" ) << " " << (*it).first;
- pr = true;
- }
- }
- Trace(c) << (pr ? " " : "" ) << "}" << std::endl;
- }
- //}
- */
- ++eqcs_i;
- }
-}
-
-void QuantConflictFind::debugPrintQuant( const char * c, Node q ) {
- Trace(c) << "Q" << d_quant_id[q];
-}
-
-void QuantConflictFind::debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum ) {
- if( n.getNumChildren()==0 ){
- Trace(c) << n;
- }else if( doVarNum && d_qinfo[q].d_var_num.find( n )!=d_qinfo[q].d_var_num.end() ){
- Trace(c) << "?x" << d_qinfo[q].d_var_num[n];
- }else{
- Trace(c) << "(";
- if( n.getKind()==APPLY_UF ){
- Trace(c) << n.getOperator();
- }else{
- Trace(c) << n.getKind();
- }
- for( unsigned i=0; i<n.getNumChildren(); i++ ){
- Trace(c) << " ";
- debugPrintQuantBody( c, q, n[i] );
- }
- Trace(c) << ")";
- }
-}
-
-QuantConflictFind::Statistics::Statistics():
- d_inst_rounds("QuantConflictFind::Inst_Rounds", 0),
- d_conflict_inst("QuantConflictFind::Instantiations_Conflict_Find", 0 ),
- d_prop_inst("QuantConflictFind::Instantiations_Prop", 0 ),
- d_entailment_checks("QuantConflictFind::Entailment_Checks",0)
-{
- StatisticsRegistry::registerStat(&d_inst_rounds);
- StatisticsRegistry::registerStat(&d_conflict_inst);
- StatisticsRegistry::registerStat(&d_prop_inst);
- StatisticsRegistry::registerStat(&d_entailment_checks);
-}
-
-QuantConflictFind::Statistics::~Statistics(){
- StatisticsRegistry::unregisterStat(&d_inst_rounds);
- StatisticsRegistry::unregisterStat(&d_conflict_inst);
- StatisticsRegistry::unregisterStat(&d_prop_inst);
- StatisticsRegistry::unregisterStat(&d_entailment_checks);
-}
-
-TNode QuantConflictFind::getZero( Kind k ) {
- std::map< Kind, Node >::iterator it = d_zero.find( k );
- if( it==d_zero.end() ){
- Node nn;
- if( k==PLUS ){
- nn = NodeManager::currentNM()->mkConst( Rational(0) );
- }
- d_zero[k] = nn;
- return nn;
- }else{
- return it->second;
- }
-}
-
-
-}
+/********************* */ +/*! \file quant_conflict_find.cpp + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief quant conflict find class + ** + **/ + +#include <vector> + +#include "theory/quantifiers/quant_conflict_find.h" +#include "theory/quantifiers/quant_util.h" +#include "theory/theory_engine.h" +#include "theory/quantifiers/options.h" +#include "theory/quantifiers/term_database.h" +#include "theory/quantifiers/trigger.h" + +using namespace CVC4; +using namespace CVC4::kind; +using namespace CVC4::theory; +using namespace CVC4::theory::quantifiers; +using namespace std; + +namespace CVC4 { + + + +void QuantInfo::initialize( Node q, Node qn ) { + d_q = q; + for( unsigned i=0; i<q[0].getNumChildren(); i++ ){ + d_match.push_back( TNode::null() ); + d_match_term.push_back( TNode::null() ); + } + + //register the variables + for( unsigned i=0; i<q[0].getNumChildren(); i++ ){ + d_var_num[q[0][i]] = i; + d_vars.push_back( q[0][i] ); + d_var_types.push_back( q[0][i].getType() ); + } + + registerNode( qn, true, true ); + + + Trace("qcf-qregister") << "- Make match gen structure..." << std::endl; + d_mg = new MatchGen( this, qn ); + + if( d_mg->isValid() ){ + /* + for( unsigned j=0; j<q[0].getNumChildren(); j++ ){ + if( d_inMatchConstraint.find( q[0][j] )==d_inMatchConstraint.end() ){ + Trace("qcf-invalid") << "QCF invalid : variable " << q[0][j] << " does not exist in a matching constraint." << std::endl; + d_mg->setInvalid(); + break; + } + } + */ + if( d_mg->isValid() ){ + for( unsigned j=q[0].getNumChildren(); j<d_vars.size(); j++ ){ + if( d_vars[j].getKind()!=BOUND_VARIABLE ){ + d_var_mg[j] = NULL; + bool is_tsym = false; + if( !MatchGen::isHandledUfTerm( d_vars[j] ) && d_vars[j].getKind()!=ITE ){ + is_tsym = true; + d_tsym_vars.push_back( j ); + } + if( !is_tsym || options::qcfTConstraint() ){ + d_var_mg[j] = new MatchGen( this, d_vars[j], true ); + } + if( !d_var_mg[j] || !d_var_mg[j]->isValid() ){ + Trace("qcf-invalid") << "QCF invalid : cannot match for " << d_vars[j] << std::endl; + d_mg->setInvalid(); + break; + }else{ + std::vector< int > bvars; + d_var_mg[j]->determineVariableOrder( this, bvars ); + } + } + } + if( d_mg->isValid() ){ + std::vector< int > bvars; + d_mg->determineVariableOrder( this, bvars ); + } + } + }else{ + Trace("qcf-invalid") << "QCF invalid : body of formula cannot be processed." << std::endl; + } + Trace("qcf-qregister-summary") << "QCF register : " << ( d_mg->isValid() ? "VALID " : "INVALID" ) << " : " << q << std::endl; +} + +void QuantInfo::registerNode( Node n, bool hasPol, bool pol, bool beneathQuant ) { + Trace("qcf-qregister-debug2") << "Register : " << n << std::endl; + if( n.getKind()==FORALL ){ + registerNode( n[1], hasPol, pol, true ); + }else{ + if( !MatchGen::isHandledBoolConnective( n ) ){ + if( n.hasBoundVar() ){ + //literals + if( n.getKind()==EQUAL ){ + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + flatten( n[i], beneathQuant ); + } + }else if( MatchGen::isHandledUfTerm( n ) ){ + flatten( n, beneathQuant ); + }else if( n.getKind()==ITE ){ + for( unsigned i=1; i<=2; i++ ){ + flatten( n[i], beneathQuant ); + } + registerNode( n[0], false, pol, beneathQuant ); + }else if( options::qcfTConstraint() ){ + //a theory-specific predicate + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + flatten( n[i], beneathQuant ); + } + } + } + }else{ + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + bool newHasPol; + bool newPol; + QuantPhaseReq::getPolarity( n, i, hasPol, pol, newHasPol, newPol ); + //QcfNode * qcfc = new QcfNode( d_c ); + //qcfc->d_parent = qcf; + //qcf->d_child[i] = qcfc; + registerNode( n[i], newHasPol, newPol, beneathQuant ); + } + } + } +} + +void QuantInfo::flatten( Node n, bool beneathQuant ) { + Trace("qcf-qregister-debug2") << "Flatten : " << n << std::endl; + if( n.hasBoundVar() ){ + if( n.getKind()==BOUND_VARIABLE ){ + d_inMatchConstraint[n] = true; + } + //if( MatchGen::isHandledUfTerm( n ) || n.getKind()==ITE ){ + if( d_var_num.find( n )==d_var_num.end() ){ + Trace("qcf-qregister-debug2") << "Add FLATTEN VAR : " << n << std::endl; + d_var_num[n] = d_vars.size(); + d_vars.push_back( n ); + d_var_types.push_back( n.getType() ); + d_match.push_back( TNode::null() ); + d_match_term.push_back( TNode::null() ); + if( n.getKind()==ITE ){ + registerNode( n, false, false ); + }else{ + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + flatten( n[i], beneathQuant ); + } + } + }else{ + Trace("qcf-qregister-debug2") << "...already processed" << std::endl; + } + }else{ + Trace("qcf-qregister-debug2") << "...is ground." << std::endl; + } +} + + +void QuantInfo::reset_round( QuantConflictFind * p ) { + for( unsigned i=0; i<d_match.size(); i++ ){ + d_match[i] = TNode::null(); + d_match_term[i] = TNode::null(); + } + d_curr_var_deq.clear(); + d_tconstraints.clear(); + //add built-in variable constraints + for( unsigned r=0; r<2; r++ ){ + for( std::map< int, std::vector< Node > >::iterator it = d_var_constraint[r].begin(); + it != d_var_constraint[r].end(); ++it ){ + for( unsigned j=0; j<it->second.size(); j++ ){ + Node rr = it->second[j]; + if( !isVar( rr ) ){ + rr = p->getRepresentative( rr ); + } + if( addConstraint( p, it->first, rr, r==0 )==-1 ){ + d_var_constraint[0].clear(); + d_var_constraint[1].clear(); + //quantified formula is actually equivalent to true + Trace("qcf-qregister") << "Quantifier is equivalent to true!!!" << std::endl; + d_mg->d_children.clear(); + d_mg->d_n = NodeManager::currentNM()->mkConst( true ); + d_mg->d_type = MatchGen::typ_ground; + return; + } + } + } + } + d_mg->reset_round( p ); + for( std::map< int, MatchGen * >::iterator it = d_var_mg.begin(); it != d_var_mg.end(); ++it ){ + it->second->reset_round( p ); + } + //now, reset for matching + d_mg->reset( p, false, this ); +} + +int QuantInfo::getCurrentRepVar( int v ) { + if( v!=-1 && !d_match[v].isNull() ){ + int vn = getVarNum( d_match[v] ); + if( vn!=-1 ){ + //int vr = getCurrentRepVar( vn ); + //d_match[v] = d_vars[vr]; + //return vr; + return getCurrentRepVar( vn ); + } + } + return v; +} + +TNode QuantInfo::getCurrentValue( TNode n ) { + int v = getVarNum( n ); + if( v==-1 ){ + return n; + }else{ + if( d_match[v].isNull() ){ + return n; + }else{ + Assert( getVarNum( d_match[v] )!=v ); + return getCurrentValue( d_match[v] ); + } + } +} + +TNode QuantInfo::getCurrentExpValue( TNode n ) { + int v = getVarNum( n ); + if( v==-1 ){ + return n; + }else{ + if( d_match[v].isNull() ){ + return n; + }else{ + Assert( getVarNum( d_match[v] )!=v ); + if( d_match_term[v].isNull() ){ + return getCurrentValue( d_match[v] ); + }else{ + return d_match_term[v]; + } + } + } +} + +bool QuantInfo::getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq ) { + //check disequalities + std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v ); + if( itd!=d_curr_var_deq.end() ){ + for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ + Node cv = getCurrentValue( it->first ); + Debug("qcf-ccbe") << "compare " << cv << " " << n << std::endl; + if( cv==n ){ + return false; + }else if( chDiseq && !isVar( n ) && !isVar( cv ) ){ + //they must actually be disequal if we are looking for conflicts + if( !p->areDisequal( n, cv ) ){ + //TODO : check for entailed disequal + + return false; + } + } + } + } + return true; +} + +int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ) { + v = getCurrentRepVar( v ); + int vn = getVarNum( n ); + vn = vn==-1 ? -1 : getCurrentRepVar( vn ); + n = getCurrentValue( n ); + return addConstraint( p, v, n, vn, polarity, false ); +} + +int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ) { + //for handling equalities between variables, and disequalities involving variables + Debug("qcf-match-debug") << "- " << (doRemove ? "un" : "" ) << "constrain : " << v << " -> " << n << " (cv=" << getCurrentValue( n ) << ")"; + Debug("qcf-match-debug") << ", (vn=" << vn << "), polarity = " << polarity << std::endl; + Assert( doRemove || n==getCurrentValue( n ) ); + Assert( doRemove || v==getCurrentRepVar( v ) ); + Assert( doRemove || vn==getCurrentRepVar( getVarNum( n ) ) ); + if( polarity ){ + if( vn!=v ){ + if( doRemove ){ + if( vn!=-1 ){ + //if set to this in the opposite direction, clean up opposite instead + // std::map< int, TNode >::iterator itmn = d_match.find( vn ); + if( d_match[vn]==d_vars[v] ){ + return addConstraint( p, vn, d_vars[v], v, true, true ); + }else{ + //unsetting variables equal + std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( vn ); + if( itd!=d_curr_var_deq.end() ){ + //remove disequalities owned by this + std::vector< TNode > remDeq; + for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ + if( it->second==v ){ + remDeq.push_back( it->first ); + } + } + for( unsigned i=0; i<remDeq.size(); i++ ){ + d_curr_var_deq[vn].erase( remDeq[i] ); + } + } + } + } + d_match[v] = TNode::null(); + return 1; + }else{ + //std::map< int, TNode >::iterator itm = d_match.find( v ); + + if( vn!=-1 ){ + Debug("qcf-match-debug") << " ...Variable bound to variable" << std::endl; + //std::map< int, TNode >::iterator itmn = d_match.find( vn ); + if( d_match[v].isNull() ){ + //setting variables equal + bool alreadySet = false; + if( !d_match[vn].isNull() ){ + alreadySet = true; + Assert( !isVar( d_match[vn] ) ); + } + + //copy or check disequalities + std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v ); + if( itd!=d_curr_var_deq.end() ){ + for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ + Node dv = getCurrentValue( it->first ); + if( !alreadySet ){ + if( d_curr_var_deq[vn].find( dv )==d_curr_var_deq[vn].end() ){ + d_curr_var_deq[vn][dv] = v; + } + }else{ + if( !p->areMatchDisequal( d_match[vn], dv ) ){ + Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; + return -1; + } + } + } + } + if( alreadySet ){ + n = getCurrentValue( n ); + } + }else{ + if( d_match[vn].isNull() ){ + Debug("qcf-match-debug") << " ...Reverse direction" << std::endl; + //set the opposite direction + return addConstraint( p, vn, d_vars[v], v, true, false ); + }else{ + Debug("qcf-match-debug") << " -> Both variables bound, compare" << std::endl; + //are they currently equal + return p->areMatchEqual( d_match[v], d_match[vn] ) ? 0 : -1; + } + } + }else{ + Debug("qcf-match-debug") << " ...Variable bound to ground" << std::endl; + if( d_match[v].isNull() ){ + }else{ + //compare ground values + Debug("qcf-match-debug") << " -> Ground value, compare " << d_match[v] << " "<< n << std::endl; + return p->areMatchEqual( d_match[v], n ) ? 0 : -1; + } + } + if( setMatch( p, v, n ) ){ + Debug("qcf-match-debug") << " -> success" << std::endl; + return 1; + }else{ + Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; + return -1; + } + } + }else{ + Debug("qcf-match-debug") << " -> redundant, variable identity" << std::endl; + return 0; + } + }else{ + if( vn==v ){ + Debug("qcf-match-debug") << " -> fail, variable identity" << std::endl; + return -1; + }else{ + if( doRemove ){ + Assert( d_curr_var_deq[v].find( n )!=d_curr_var_deq[v].end() ); + d_curr_var_deq[v].erase( n ); + return 1; + }else{ + if( d_curr_var_deq[v].find( n )==d_curr_var_deq[v].end() ){ + //check if it respects equality + //std::map< int, TNode >::iterator itm = d_match.find( v ); + if( !d_match[v].isNull() ){ + TNode nv = getCurrentValue( n ); + if( !p->areMatchDisequal( nv, d_match[v] ) ){ + Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; + return -1; + } + } + d_curr_var_deq[v][n] = v; + Debug("qcf-match-debug") << " -> success" << std::endl; + return 1; + }else{ + Debug("qcf-match-debug") << " -> redundant disequality" << std::endl; + return 0; + } + } + } + } +} + +bool QuantInfo::isConstrainedVar( int v ) { + if( d_curr_var_deq.find( v )!=d_curr_var_deq.end() && !d_curr_var_deq[v].empty() ){ + return true; + }else{ + Node vv = getVar( v ); + //for( std::map< int, TNode >::iterator it = d_match.begin(); it != d_match.end(); ++it ){ + for( unsigned i=0; i<d_match.size(); i++ ){ + if( d_match[i]==vv ){ + return true; + } + } + for( std::map< int, std::map< TNode, int > >::iterator it = d_curr_var_deq.begin(); it != d_curr_var_deq.end(); ++it ){ + for( std::map< TNode, int >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){ + if( it2->first==vv ){ + return true; + } + } + } + return false; + } +} + +bool QuantInfo::setMatch( QuantConflictFind * p, int v, TNode n ) { + if( getCurrentCanBeEqual( p, v, n ) ){ + Debug("qcf-match-debug") << "-- bind : " << v << " -> " << n << ", checked " << d_curr_var_deq[v].size() << " disequalities" << std::endl; + d_match[v] = n; + return true; + }else{ + return false; + } +} + +bool QuantInfo::isMatchSpurious( QuantConflictFind * p ) { + for( int i=0; i<getNumVars(); i++ ){ + //std::map< int, TNode >::iterator it = d_match.find( i ); + if( !d_match[i].isNull() ){ + if( !getCurrentCanBeEqual( p, i, d_match[i], p->d_effort==QuantConflictFind::effort_conflict ) ){ + return true; + } + } + } + return false; +} + +bool QuantInfo::isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ) { + if( !d_tconstraints.empty() ){ + //check constraints + for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){ + //apply substitution to the tconstraint + Node cons = it->first.substitute( p->getTermDatabase()->d_vars[d_q].begin(), + p->getTermDatabase()->d_vars[d_q].end(), + terms.begin(), terms.end() ); + cons = it->second ? cons : cons.negate(); + if( !entailmentTest( p, cons, p->d_effort==QuantConflictFind::effort_conflict ) ){ + return true; + } + } + } + return false; +} + +bool QuantInfo::entailmentTest( QuantConflictFind * p, Node lit, bool chEnt ) { + Trace("qcf-tconstraint-debug") << "Check : " << lit << std::endl; + Node rew = Rewriter::rewrite( lit ); + if( rew==p->d_false ){ + Trace("qcf-tconstraint-debug") << "...constraint " << lit << " is disentailed (rewrites to false)." << std::endl; + return false; + }else if( rew!=p->d_true ){ + //if checking for conflicts, we must be sure that the constraint is entailed + if( chEnt ){ + //check if it is entailed + Trace("qcf-tconstraint-debug") << "Check entailment of " << rew << "..." << std::endl; + std::pair<bool, Node> et = p->getQuantifiersEngine()->getTheoryEngine()->entailmentCheck(THEORY_OF_TYPE_BASED, rew ); + ++(p->d_statistics.d_entailment_checks); + Trace("qcf-tconstraint-debug") << "ET result : " << et.first << " " << et.second << std::endl; + if( !et.first ){ + Trace("qcf-tconstraint-debug") << "...cannot show entailment of " << rew << "." << std::endl; + return false; + }else{ + return true; + } + }else{ + Trace("qcf-tconstraint-debug") << "...does not need to be entailed." << std::endl; + return true; + } + }else{ + Trace("qcf-tconstraint-debug") << "...rewrites to true." << std::endl; + return true; + } +} + +bool QuantInfo::completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue ) { + //assign values for variables that were unassigned (usually not necessary, but handles corner cases) + bool doFail = false; + bool success = true; + if( doContinue ){ + doFail = true; + success = false; + }else{ + //solve for interpreted symbol matches + // this breaks the invariant that all introduced constraints are over existing terms + for( int i=(int)(d_tsym_vars.size()-1); i>=0; i-- ){ + int index = d_tsym_vars[i]; + TNode v = getCurrentValue( d_vars[index] ); + int slv_v = -1; + if( v==d_vars[index] ){ + slv_v = index; + } + Trace("qcf-tconstraint-debug") << "Solve " << d_vars[index] << " = " << v << " " << d_vars[index].getKind() << std::endl; + if( d_vars[index].getKind()==PLUS || d_vars[index].getKind()==MULT ){ + Kind k = d_vars[index].getKind(); + std::vector< TNode > children; + for( unsigned j=0; j<d_vars[index].getNumChildren(); j++ ){ + int vn = getVarNum( d_vars[index][j] ); + if( vn!=-1 ){ + TNode vv = getCurrentValue( d_vars[index][j] ); + if( vv==d_vars[index][j] ){ + //we will assign this + if( slv_v==-1 ){ + Trace("qcf-tconstraint-debug") << "...will solve for var #" << vn << std::endl; + slv_v = vn; + if( p->d_effort!=QuantConflictFind::effort_conflict ){ + break; + } + }else{ + Node z = p->getZero( k ); + if( !z.isNull() ){ + Trace("qcf-tconstraint-debug") << "...set " << d_vars[vn] << " = " << z << std::endl; + assigned.push_back( vn ); + if( !setMatch( p, vn, z ) ){ + success = false; + break; + } + } + } + }else{ + Trace("qcf-tconstraint-debug") << "...sum value " << vv << std::endl; + children.push_back( vv ); + } + }else{ + Trace("qcf-tconstraint-debug") << "...sum " << d_vars[index][j] << std::endl; + children.push_back( d_vars[index][j] ); + } + } + if( success ){ + if( slv_v!=-1 ){ + Node lhs; + if( children.empty() ){ + lhs = p->getZero( k ); + }else if( children.size()==1 ){ + lhs = children[0]; + }else{ + lhs = NodeManager::currentNM()->mkNode( k, children ); + } + Node sum; + if( v==d_vars[index] ){ + sum = lhs; + }else{ + if( p->d_effort==QuantConflictFind::effort_conflict ){ + Kind kn = k; + if( d_vars[index].getKind()==PLUS ){ + kn = MINUS; + } + if( kn!=k ){ + sum = NodeManager::currentNM()->mkNode( kn, v, lhs ); + } + } + } + if( !sum.isNull() ){ + assigned.push_back( slv_v ); + Trace("qcf-tconstraint-debug") << "...set " << d_vars[slv_v] << " = " << sum << std::endl; + if( !setMatch( p, slv_v, sum ) ){ + success = false; + } + p->d_tempCache.push_back( sum ); + } + }else{ + //must show that constraint is met + Node sum = NodeManager::currentNM()->mkNode( k, children ); + Node eq = sum.eqNode( v ); + if( !entailmentTest( p, eq ) ){ + success = false; + } + p->d_tempCache.push_back( sum ); + } + } + } + + if( !success ){ + break; + } + } + if( success ){ + //check what is left to assign + d_unassigned.clear(); + d_unassigned_tn.clear(); + std::vector< int > unassigned[2]; + std::vector< TypeNode > unassigned_tn[2]; + for( int i=0; i<getNumVars(); i++ ){ + if( d_match[i].isNull() ){ + int rindex = d_var_mg.find( i )==d_var_mg.end() ? 1 : 0; + unassigned[rindex].push_back( i ); + unassigned_tn[rindex].push_back( getVar( i ).getType() ); + assigned.push_back( i ); + } + } + d_unassigned_nvar = unassigned[0].size(); + for( unsigned i=0; i<2; i++ ){ + d_unassigned.insert( d_unassigned.end(), unassigned[i].begin(), unassigned[i].end() ); + d_unassigned_tn.insert( d_unassigned_tn.end(), unassigned_tn[i].begin(), unassigned_tn[i].end() ); + } + d_una_eqc_count.clear(); + d_una_index = 0; + } + } + + if( !d_unassigned.empty() && ( success || doContinue ) ){ + Trace("qcf-check") << "Assign to unassigned..." << std::endl; + do { + if( doFail ){ + Trace("qcf-check-unassign") << "Failure, try again..." << std::endl; + } + bool invalidMatch = false; + while( ( d_una_index>=0 && (int)d_una_index<(int)d_unassigned.size() ) || invalidMatch || doFail ){ + invalidMatch = false; + if( !doFail && d_una_index==(int)d_una_eqc_count.size() ){ + //check if it has now been assigned + if( d_una_index<d_unassigned_nvar ){ + if( !isConstrainedVar( d_unassigned[d_una_index] ) ){ + d_una_eqc_count.push_back( -1 ); + }else{ + d_var_mg[ d_unassigned[d_una_index] ]->reset( p, true, this ); + d_una_eqc_count.push_back( 0 ); + } + }else{ + d_una_eqc_count.push_back( 0 ); + } + }else{ + bool failed = false; + if( !doFail ){ + if( d_una_index<d_unassigned_nvar ){ + if( !isConstrainedVar( d_unassigned[d_una_index] ) ){ + Trace("qcf-check-unassign") << "Succeeded, variable unconstrained at " << d_una_index << std::endl; + d_una_index++; + }else if( d_var_mg[d_unassigned[d_una_index]]->getNextMatch( p, this ) ){ + Trace("qcf-check-unassign") << "Succeeded match with mg at " << d_una_index << std::endl; + d_una_index++; + }else{ + failed = true; + Trace("qcf-check-unassign") << "Failed match with mg at " << d_una_index << std::endl; + } + }else{ + Assert( doFail || d_una_index==(int)d_una_eqc_count.size()-1 ); + if( d_una_eqc_count[d_una_index]<(int)p->d_eqcs[d_unassigned_tn[d_una_index]].size() ){ + int currIndex = d_una_eqc_count[d_una_index]; + d_una_eqc_count[d_una_index]++; + Trace("qcf-check-unassign") << d_unassigned[d_una_index] << "->" << p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] << std::endl; + if( setMatch( p, d_unassigned[d_una_index], p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] ) ){ + d_match_term[d_unassigned[d_una_index]] = TNode::null(); + Trace("qcf-check-unassign") << "Succeeded match " << d_una_index << std::endl; + d_una_index++; + }else{ + Trace("qcf-check-unassign") << "Failed match " << d_una_index << std::endl; + invalidMatch = true; + } + }else{ + failed = true; + Trace("qcf-check-unassign") << "No more matches " << d_una_index << std::endl; + } + } + } + if( doFail || failed ){ + do{ + if( !doFail ){ + d_una_eqc_count.pop_back(); + }else{ + doFail = false; + } + d_una_index--; + }while( d_una_index>=0 && d_una_eqc_count[d_una_index]==-1 ); + } + } + } + success = d_una_index>=0; + if( success ){ + doFail = true; + Trace("qcf-check-unassign") << " Try: " << std::endl; + for( unsigned i=0; i<d_unassigned.size(); i++ ){ + int ui = d_unassigned[i]; + if( !d_match[ui].isNull() ){ + Trace("qcf-check-unassign") << " Assigned #" << ui << " : " << d_vars[ui] << " -> " << d_match[ui] << std::endl; + } + } + } + }while( success && isMatchSpurious( p ) ); + } + if( success ){ + for( unsigned i=0; i<d_unassigned.size(); i++ ){ + int ui = d_unassigned[i]; + if( !d_match[ui].isNull() ){ + Trace("qcf-check") << " Assigned #" << ui << " : " << d_vars[ui] << " -> " << d_match[ui] << std::endl; + } + } + return true; + }else{ + for( unsigned i=0; i<assigned.size(); i++ ){ + d_match[ assigned[i] ] = TNode::null(); + } + assigned.clear(); + return false; + } +} + +void QuantInfo::getMatch( std::vector< Node >& terms ){ + for( unsigned i=0; i<d_q[0].getNumChildren(); i++ ){ + //Node cv = qi->getCurrentValue( qi->d_match[i] ); + int repVar = getCurrentRepVar( i ); + Node cv; + //std::map< int, TNode >::iterator itmt = qi->d_match_term.find( repVar ); + if( !d_match_term[repVar].isNull() ){ + cv = d_match_term[repVar]; + }else{ + cv = d_match[repVar]; + } + Debug("qcf-check-inst") << "INST : " << i << " -> " << cv << ", from " << d_match[i] << std::endl; + terms.push_back( cv ); + } +} + +void QuantInfo::revertMatch( std::vector< int >& assigned ) { + for( unsigned i=0; i<assigned.size(); i++ ){ + d_match[ assigned[i] ] = TNode::null(); + } +} + +void QuantInfo::debugPrintMatch( const char * c ) { + for( int i=0; i<getNumVars(); i++ ){ + Trace(c) << " " << d_vars[i] << " -> "; + if( !d_match[i].isNull() ){ + Trace(c) << d_match[i]; + }else{ + Trace(c) << "(unassigned) "; + } + if( !d_curr_var_deq[i].empty() ){ + Trace(c) << ", DEQ{ "; + for( std::map< TNode, int >::iterator it = d_curr_var_deq[i].begin(); it != d_curr_var_deq[i].end(); ++it ){ + Trace(c) << it->first << " "; + } + Trace(c) << "}"; + } + if( !d_match_term[i].isNull() && d_match_term[i]!=d_match[i] ){ + Trace(c) << ", EXP : " << d_match_term[i]; + } + Trace(c) << std::endl; + } + if( !d_tconstraints.empty() ){ + Trace(c) << "ADDITIONAL CONSTRAINTS : " << std::endl; + for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){ + Trace(c) << " " << it->first << " -> " << it->second << std::endl; + } + } +} + +MatchGen::MatchGen( QuantInfo * qi, Node n, bool isVar ){ + Trace("qcf-qregister-debug") << "Make match gen for " << n << ", isVar = " << isVar << std::endl; + std::vector< Node > qni_apps; + d_qni_size = 0; + if( isVar ){ + Assert( qi->d_var_num.find( n )!=qi->d_var_num.end() ); + if( n.getKind()==ITE ){ + d_type = typ_ite_var; + d_type_not = false; + d_n = n; + d_children.push_back( MatchGen( qi, d_n[0] ) ); + if( d_children[0].isValid() ){ + d_type = typ_ite_var; + for( unsigned i=1; i<=2; i++ ){ + Node nn = n.eqNode( n[i] ); + d_children.push_back( MatchGen( qi, nn ) ); + d_children[d_children.size()-1].d_qni_bound_except.push_back( 0 ); + if( !d_children[d_children.size()-1].isValid() ){ + setInvalid(); + break; + } + } + }else{ + d_type = typ_invalid; + } + }else{ + d_type = isHandledUfTerm( n ) ? typ_var : typ_tsym; + d_qni_var_num[0] = qi->getVarNum( n ); + d_qni_size++; + d_type_not = false; + d_n = n; + //Node f = getOperator( n ); + for( unsigned j=0; j<d_n.getNumChildren(); j++ ){ + Node nn = d_n[j]; + Trace("qcf-qregister-debug") << " " << d_qni_size; + if( qi->isVar( nn ) ){ + int v = qi->d_var_num[nn]; + Trace("qcf-qregister-debug") << " is var #" << v << std::endl; + d_qni_var_num[d_qni_size] = v; + //qi->addFuncParent( v, f, j ); + }else{ + Trace("qcf-qregister-debug") << " is gterm " << nn << std::endl; + d_qni_gterm[d_qni_size] = nn; + } + d_qni_size++; + } + } + }else{ + if( n.hasBoundVar() ){ + d_type_not = false; + d_n = n; + if( d_n.getKind()==NOT ){ + d_n = d_n[0]; + d_type_not = !d_type_not; + } + + if( isHandledBoolConnective( d_n ) ){ + //non-literals + d_type = typ_formula; + for( unsigned i=0; i<d_n.getNumChildren(); i++ ){ + if( d_n.getKind()!=FORALL || i==1 ){ + d_children.push_back( MatchGen( qi, d_n[i], false ) ); + if( !d_children[d_children.size()-1].isValid() ){ + setInvalid(); + break; + } + } + /* + else if( isTop && n.getKind()==OR && d_children[d_children.size()-1].d_type==typ_var_eq ){ + Trace("qcf-qregister-debug") << "Remove child, make built-in constraint" << std::endl; + //if variable equality/disequality at top level, remove immediately + bool cIsNot = d_children[d_children.size()-1].d_type_not; + Node cn = d_children[d_children.size()-1].d_n; + Assert( cn.getKind()==EQUAL ); + Assert( p->d_qinfo[q].isVar( cn[0] ) || p->d_qinfo[q].isVar( cn[1] ) ); + //make it a built-in constraint instead + for( unsigned i=0; i<2; i++ ){ + if( p->d_qinfo[q].isVar( cn[i] ) ){ + int v = p->d_qinfo[q].getVarNum( cn[i] ); + Node cno = cn[i==0 ? 1 : 0]; + p->d_qinfo[q].d_var_constraint[ cIsNot ? 0 : 1 ][v].push_back( cno ); + break; + } + } + d_children.pop_back(); + } + */ + } + }else{ + d_type = typ_invalid; + //literals + if( isHandledUfTerm( d_n ) ){ + Assert( qi->isVar( d_n ) ); + d_type = typ_pred; + }else if( d_n.getKind()==BOUND_VARIABLE ){ + Assert( d_n.getType().isBoolean() ); + d_type = typ_bool_var; + }else if( d_n.getKind()==EQUAL || options::qcfTConstraint() ){ + for( unsigned i=0; i<d_n.getNumChildren(); i++ ){ + if( d_n[i].hasBoundVar() ){ + if( !qi->isVar( d_n[i] ) ){ + Trace("qcf-qregister-debug") << "ERROR : not var " << d_n[i] << std::endl; + } + Assert( qi->isVar( d_n[i] ) ); + if( d_n.getKind()!=EQUAL && qi->isVar( d_n[i] ) ){ + d_qni_var_num[i+1] = qi->d_var_num[d_n[i]]; + } + }else{ + d_qni_gterm[i] = d_n[i]; + } + } + d_type = d_n.getKind()==EQUAL ? typ_eq : typ_tconstraint; + Trace("qcf-tconstraint") << "T-Constraint : " << d_n << std::endl; + } + } + }else{ + //we will just evaluate + d_n = n; + d_type = typ_ground; + } + //if( d_type!=typ_invalid ){ + //determine an efficient children ordering + //if( !d_children.empty() ){ + //for( unsigned i=0; i<d_children.size(); i++ ){ + // d_children_order.push_back( i ); + //} + //if( !d_n.isNull() && ( d_n.getKind()==OR || d_n.getKind()==AND || d_n.getKind()==IFF ) ){ + //sort based on the type of the constraint : ground comes first, then literals, then others + //MatchGenSort mgs; + //mgs.d_mg = this; + //std::sort( d_children_order.begin(), d_children_order.end(), mgs ); + //} + //} + //} + } + Trace("qcf-qregister-debug") << "Done make match gen " << n << ", type = "; + debugPrintType( "qcf-qregister-debug", d_type, true ); + Trace("qcf-qregister-debug") << std::endl; + //Assert( d_children.size()==d_children_order.size() ); + +} + +void MatchGen::collectBoundVar( QuantInfo * qi, Node n, std::vector< int >& cbvars ) { + int v = qi->getVarNum( n ); + if( v!=-1 && std::find( cbvars.begin(), cbvars.end(), v )==cbvars.end() ){ + cbvars.push_back( v ); + } + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + collectBoundVar( qi, n[i], cbvars ); + } +} + +void MatchGen::determineVariableOrder( QuantInfo * qi, std::vector< int >& bvars ) { + Trace("qcf-qregister-debug") << "Determine variable order " << d_n << std::endl; + bool isCom = d_type==typ_formula && ( d_n.getKind()==OR || d_n.getKind()==AND || d_n.getKind()==IFF ); + std::map< int, std::vector< int > > c_to_vars; + std::map< int, std::vector< int > > vars_to_c; + std::map< int, int > vb_count; + std::map< int, int > vu_count; + std::vector< bool > assigned; + Trace("qcf-qregister-debug") << "Calculate bound variables..." << std::endl; + for( unsigned i=0; i<d_children.size(); i++ ){ + collectBoundVar( qi, d_children[i].d_n, c_to_vars[i] ); + assigned.push_back( false ); + vb_count[i] = 0; + vu_count[i] = 0; + for( unsigned j=0; j<c_to_vars[i].size(); j++ ){ + int v = c_to_vars[i][j]; + vars_to_c[v].push_back( i ); + if( std::find( bvars.begin(), bvars.end(), v )==bvars.end() ){ + vu_count[i]++; + if( !isCom ){ + bvars.push_back( v ); + } + }else{ + vb_count[i]++; + } + } + } + if( isCom ){ + //children that bind the least number of unbound variables go first + do { + int min_score = -1; + int min_score_index = -1; + for( unsigned i=0; i<d_children.size(); i++ ){ + if( !assigned[i] ){ + int score = vu_count[i]; + if( min_score==-1 || score<min_score ){ + min_score = score; + min_score_index = i; + } + } + } + Trace("qcf-qregister-debug") << "...assign child " << min_score_index << "/" << d_children.size() << std::endl; + Assert( min_score_index!=-1 ); + //add to children order + d_children_order.push_back( min_score_index ); + assigned[min_score_index] = true; + //if( vb_count[min_score_index]==0 ){ + // d_independent.push_back( min_score_index ); + //} + //determine order internal to children + d_children[min_score_index].determineVariableOrder( qi, bvars ); + Trace("qcf-qregister-debug") << "...bind variables" << std::endl; + //now, make it a bound variable + for( unsigned i=0; i<c_to_vars[min_score_index].size(); i++ ){ + int v = c_to_vars[min_score_index][i]; + if( std::find( bvars.begin(), bvars.end(), v )==bvars.end() ){ + for( unsigned j=0; j<vars_to_c[v].size(); j++ ){ + int vc = vars_to_c[v][j]; + vu_count[vc]--; + vb_count[vc]++; + } + bvars.push_back( v ); + } + } + Trace("qcf-qregister-debug") << "...done assign child " << min_score_index << std::endl; + }while( d_children_order.size()!=d_children.size() ); + Trace("qcf-qregister-debug") << "Done assign variable ordering for " << d_n << std::endl; + }else{ + for( unsigned i=0; i<d_children.size(); i++ ){ + d_children_order.push_back( i ); + d_children[i].determineVariableOrder( qi, bvars ); + } + } +} + + +void MatchGen::reset_round( QuantConflictFind * p ) { + d_wasSet = false; + for( unsigned i=0; i<d_children.size(); i++ ){ + d_children[i].reset_round( p ); + } + for( std::map< int, TNode >::iterator it = d_qni_gterm.begin(); it != d_qni_gterm.end(); ++it ){ + d_qni_gterm_rep[it->first] = p->getRepresentative( it->second ); + } + if( d_type==typ_ground ){ + int e = p->evaluate( d_n ); + if( e==1 ){ + d_ground_eval[0] = p->d_true; + }else if( e==-1 ){ + d_ground_eval[0] = p->d_false; + } + }else if( d_type==typ_eq ){ + for( unsigned i=0; i<d_n.getNumChildren(); i++ ){ + if( !d_n[i].hasBoundVar() ){ + d_ground_eval[i] = p->evaluateTerm( d_n[i] ); + } + } + } + d_qni_bound_cons.clear(); + d_qni_bound_cons_var.clear(); + d_qni_bound.clear(); +} + +void MatchGen::reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ) { + d_tgt = d_type_not ? !tgt : tgt; + Debug("qcf-match") << " Reset for : " << d_n << ", type : "; + debugPrintType( "qcf-match", d_type ); + Debug("qcf-match") << ", tgt = " << d_tgt << ", children = " << d_children.size() << " " << d_children_order.size() << std::endl; + d_qn.clear(); + d_qni.clear(); + d_qni_bound.clear(); + d_child_counter = -1; + d_tgt_orig = d_tgt; + + //set up processing matches + if( d_type==typ_invalid ){ + //do nothing + }else if( d_type==typ_ground ){ + if( d_ground_eval[0]==( d_tgt ? p->d_true : p->d_false ) ){ + d_child_counter = 0; + } + }else if( d_type==typ_bool_var ){ + //get current value of the variable + TNode n = qi->getCurrentValue( d_n ); + int vn = qi->getCurrentRepVar( qi->getVarNum( n ) ); + if( vn==-1 ){ + //evaluate the value, see if it is compatible + int e = p->evaluate( n ); + if( ( e==1 && d_tgt ) || ( e==0 && !d_tgt ) ){ + d_child_counter = 0; + } + }else{ + //unassigned, set match to true/false + d_qni_bound[0] = vn; + qi->setMatch( p, vn, d_tgt ? p->d_true : p->d_false ); + d_child_counter = 0; + } + if( d_child_counter==0 ){ + d_qn.push_back( NULL ); + } + }else if( d_type==typ_var ){ + Assert( isHandledUfTerm( d_n ) ); + Node f = getOperator( p, d_n ); + Debug("qcf-match-debug") << " reset: Var will match operators of " << f << std::endl; + TermArgTrie * qni = p->getTermDatabase()->getTermArgTrie( Node::null(), f ); + if( qni!=NULL ){ + d_qn.push_back( qni ); + } + d_matched_basis = false; + }else if( d_type==typ_tsym || d_type==typ_tconstraint ){ + for( std::map< int, int >::iterator it = d_qni_var_num.begin(); it != d_qni_var_num.end(); ++it ){ + int repVar = qi->getCurrentRepVar( it->second ); + if( qi->d_match[repVar].isNull() ){ + Debug("qcf-match-debug") << "Force matching on child #" << it->first << ", which is var #" << repVar << std::endl; + d_qni_bound[it->first] = repVar; + } + } + d_qn.push_back( NULL ); + }else if( d_type==typ_pred || d_type==typ_eq ){ + //add initial constraint + Node nn[2]; + int vn[2]; + if( d_type==typ_pred ){ + nn[0] = qi->getCurrentValue( d_n ); + vn[0] = qi->getCurrentRepVar( qi->getVarNum( nn[0] ) ); + nn[1] = p->getRepresentative( d_tgt ? p->d_true : p->d_false ); + vn[1] = -1; + d_tgt = true; + }else{ + for( unsigned i=0; i<2; i++ ){ + TNode nc; + std::map< int, TNode >::iterator it = d_qni_gterm_rep.find( i ); + if( it!=d_qni_gterm_rep.end() ){ + nc = it->second; + }else{ + nc = d_n[i]; + } + nn[i] = qi->getCurrentValue( nc ); + vn[i] = qi->getCurrentRepVar( qi->getVarNum( nn[i] ) ); + } + } + bool success; + if( vn[0]==-1 && vn[1]==-1 ){ + //Trace("qcf-explain") << " reset : " << d_n << " check ground values " << nn[0] << " " << nn[1] << " (tgt=" << d_tgt << ")" << std::endl; + Debug("qcf-match-debug") << " reset: check ground values " << nn[0] << " " << nn[1] << " (" << d_tgt << ")" << std::endl; + //just compare values + if( d_tgt ){ + success = p->areMatchEqual( nn[0], nn[1] ); + }else{ + if( p->d_effort==QuantConflictFind::effort_conflict ){ + success = p->areDisequal( nn[0], nn[1] ); + }else{ + success = p->areMatchDisequal( nn[0], nn[1] ); + } + } + }else{ + //otherwise, add a constraint to a variable + if( vn[1]!=-1 && vn[0]==-1 ){ + //swap + Node t = nn[1]; + nn[1] = nn[0]; + nn[0] = t; + vn[0] = vn[1]; + vn[1] = -1; + } + Debug("qcf-match-debug") << " reset: add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << std::endl; + //add some constraint + int addc = qi->addConstraint( p, vn[0], nn[1], vn[1], d_tgt, false ); + success = addc!=-1; + //if successful and non-redundant, store that we need to cleanup this + if( addc==1 ){ + //Trace("qcf-explain") << " reset: " << d_n << " add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << ", d_tgt = " << d_tgt << std::endl; + for( unsigned i=0; i<2; i++ ){ + if( vn[i]!=-1 && std::find( d_qni_bound_except.begin(), d_qni_bound_except.end(), i )==d_qni_bound_except.end() ){ + d_qni_bound[vn[i]] = vn[i]; + } + } + d_qni_bound_cons[vn[0]] = nn[1]; + d_qni_bound_cons_var[vn[0]] = vn[1]; + } + } + //if successful, we will bind values to variables + if( success ){ + d_qn.push_back( NULL ); + } + }else{ + if( d_children.empty() ){ + //add dummy + d_qn.push_back( NULL ); + }else{ + if( d_tgt && d_n.getKind()==FORALL ){ + //do nothing + }else{ + //reset the first child to d_tgt + d_child_counter = 0; + getChild( d_child_counter )->reset( p, d_tgt, qi ); + } + } + } + d_binding = false; + d_wasSet = true; + Debug("qcf-match") << " reset: Finished reset for " << d_n << ", success = " << ( !d_qn.empty() || d_child_counter!=-1 ) << std::endl; +} + +bool MatchGen::getNextMatch( QuantConflictFind * p, QuantInfo * qi ) { + Debug("qcf-match") << " Get next match for : " << d_n << ", type = "; + debugPrintType( "qcf-match", d_type ); + Debug("qcf-match") << ", children = " << d_children.size() << ", binding = " << d_binding << std::endl; + if( d_type==typ_invalid || d_type==typ_ground ){ + if( d_child_counter==0 ){ + d_child_counter = -1; + return true; + }else{ + d_wasSet = false; + return false; + } + }else if( d_type==typ_var || d_type==typ_eq || d_type==typ_pred || d_type==typ_bool_var || d_type==typ_tconstraint || d_type==typ_tsym ){ + bool success = false; + bool terminate = false; + do { + bool doReset = false; + bool doFail = false; + if( !d_binding ){ + if( doMatching( p, qi ) ){ + Debug("qcf-match-debug") << " - Matching succeeded" << std::endl; + d_binding = true; + d_binding_it = d_qni_bound.begin(); + doReset = true; + //for tconstraint, add constraint + if( d_type==typ_tconstraint ){ + std::map< Node, bool >::iterator it = qi->d_tconstraints.find( d_n ); + if( it==qi->d_tconstraints.end() ){ + qi->d_tconstraints[d_n] = d_tgt; + //store that we added this constraint + d_qni_bound_cons[0] = d_n; + }else if( d_tgt!=it->second ){ + success = false; + terminate = true; + } + } + }else{ + Debug("qcf-match-debug") << " - Matching failed" << std::endl; + success = false; + terminate = true; + } + }else{ + doFail = true; + } + if( d_binding ){ + //also need to create match for each variable we bound + success = true; + Debug("qcf-match-debug") << " Produce matches for bound variables by " << d_n << ", type = "; + debugPrintType( "qcf-match-debug", d_type ); + Debug("qcf-match-debug") << "..." << std::endl; + + while( ( success && d_binding_it!=d_qni_bound.end() ) || doFail ){ + std::map< int, MatchGen * >::iterator itm; + if( !doFail ){ + Debug("qcf-match-debug") << " check variable " << d_binding_it->second << std::endl; + itm = qi->d_var_mg.find( d_binding_it->second ); + } + if( doFail || ( d_binding_it->first!=0 && itm!=qi->d_var_mg.end() ) ){ + Debug("qcf-match-debug") << " we had bound variable " << d_binding_it->second << ", reset = " << doReset << std::endl; + if( doReset ){ + itm->second->reset( p, true, qi ); + } + if( doFail || !itm->second->getNextMatch( p, qi ) ){ + do { + if( d_binding_it==d_qni_bound.begin() ){ + Debug("qcf-match-debug") << " failed." << std::endl; + success = false; + }else{ + --d_binding_it; + Debug("qcf-match-debug") << " decrement..." << std::endl; + } + }while( success && ( d_binding_it->first==0 || qi->d_var_mg.find( d_binding_it->second )==qi->d_var_mg.end() ) ); + doReset = false; + doFail = false; + }else{ + Debug("qcf-match-debug") << " increment..." << std::endl; + ++d_binding_it; + doReset = true; + } + }else{ + Debug("qcf-match-debug") << " skip..." << d_binding_it->second << std::endl; + ++d_binding_it; + doReset = true; + } + } + if( !success ){ + d_binding = false; + }else{ + terminate = true; + if( d_binding_it==d_qni_bound.begin() ){ + d_binding = false; + } + } + } + }while( !terminate ); + //if not successful, clean up the variables you bound + if( !success ){ + if( d_type==typ_eq || d_type==typ_pred ){ + //clean up the constraints you added + for( std::map< int, TNode >::iterator it = d_qni_bound_cons.begin(); it != d_qni_bound_cons.end(); ++it ){ + if( !it->second.isNull() ){ + Debug("qcf-match") << " Clean up bound var " << it->first << (d_tgt ? "!" : "") << " = " << it->second << std::endl; + std::map< int, int >::iterator itb = d_qni_bound_cons_var.find( it->first ); + int vn = itb!=d_qni_bound_cons_var.end() ? itb->second : -1; + //Trace("qcf-explain") << " cleanup: " << d_n << " remove constraint " << it->first << " -> " << it->second << " (vn=" << vn << ")" << ", d_tgt = " << d_tgt << std::endl; + qi->addConstraint( p, it->first, it->second, vn, d_tgt, true ); + } + } + d_qni_bound_cons.clear(); + d_qni_bound_cons_var.clear(); + d_qni_bound.clear(); + }else{ + //clean up the matches you set + for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){ + Debug("qcf-match") << " Clean up bound var " << it->second << std::endl; + Assert( it->second<qi->getNumVars() ); + qi->d_match[ it->second ] = TNode::null(); + qi->d_match_term[ it->second ] = TNode::null(); + } + d_qni_bound.clear(); + } + if( d_type==typ_tconstraint ){ + //remove constraint if applicable + if( d_qni_bound_cons.find( 0 )!=d_qni_bound_cons.end() ){ + qi->d_tconstraints.erase( d_n ); + d_qni_bound_cons.clear(); + } + } + /* + if( d_type==typ_var && p->d_effort==QuantConflictFind::effort_mc && !d_matched_basis ){ + d_matched_basis = true; + Node f = getOperator( d_n ); + TNode mbo = p->getTermDatabase()->getModelBasisOpTerm( f ); + if( qi->setMatch( p, d_qni_var_num[0], mbo ) ){ + success = true; + d_qni_bound[0] = d_qni_var_num[0]; + } + } + */ + } + Debug("qcf-match") << " ...finished matching for " << d_n << ", success = " << success << std::endl; + d_wasSet = success; + return success; + }else if( d_type==typ_formula || d_type==typ_ite_var ){ + bool success = false; + if( d_child_counter<0 ){ + if( d_child_counter<-1 ){ + success = true; + d_child_counter = -1; + } + }else{ + while( !success && d_child_counter>=0 ){ + //transition system based on d_child_counter + if( d_n.getKind()==OR || d_n.getKind()==AND ){ + if( (d_n.getKind()==AND)==d_tgt ){ + //all children must match simultaneously + if( getChild( d_child_counter )->getNextMatch( p, qi ) ){ + if( d_child_counter<(int)(getNumChildren()-1) ){ + d_child_counter++; + Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << std::endl; + getChild( d_child_counter )->reset( p, d_tgt, qi ); + }else{ + success = true; + } + }else{ + //if( std::find( d_independent.begin(), d_independent.end(), d_child_counter )!=d_independent.end() ){ + // d_child_counter--; + //}else{ + d_child_counter--; + //} + } + }else{ + //one child must match + if( !getChild( d_child_counter )->getNextMatch( p, qi ) ){ + if( d_child_counter<(int)(getNumChildren()-1) ){ + d_child_counter++; + Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << ", one match" << std::endl; + getChild( d_child_counter )->reset( p, d_tgt, qi ); + }else{ + d_child_counter = -1; + } + }else{ + success = true; + } + } + }else if( d_n.getKind()==IFF ){ + //construct match based on both children + if( d_child_counter%2==0 ){ + if( getChild( 0 )->getNextMatch( p, qi ) ){ + d_child_counter++; + getChild( 1 )->reset( p, d_child_counter==1, qi ); + }else{ + if( d_child_counter==0 ){ + d_child_counter = 2; + getChild( 0 )->reset( p, !d_tgt, qi ); + }else{ + d_child_counter = -1; + } + } + } + if( d_child_counter>=0 && d_child_counter%2==1 ){ + if( getChild( 1 )->getNextMatch( p, qi ) ){ + success = true; + }else{ + d_child_counter--; + } + } + }else if( d_n.getKind()==ITE ){ + if( d_child_counter%2==0 ){ + int index1 = d_child_counter==4 ? 1 : 0; + if( getChild( index1 )->getNextMatch( p, qi ) ){ + d_child_counter++; + getChild( d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2) )->reset( p, d_tgt, qi ); + }else{ + if( d_child_counter==4 || ( d_type==typ_ite_var && d_child_counter==2 ) ){ + d_child_counter = -1; + }else{ + d_child_counter +=2; + getChild( d_child_counter==2 ? 0 : 1 )->reset( p, d_child_counter==2 ? !d_tgt : d_tgt, qi ); + } + } + } + if( d_child_counter>=0 && d_child_counter%2==1 ){ + int index2 = d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2); + if( getChild( index2 )->getNextMatch( p, qi ) ){ + success = true; + }else{ + d_child_counter--; + } + } + }else if( d_n.getKind()==FORALL ){ + if( getChild( d_child_counter )->getNextMatch( p, qi ) ){ + success = true; + }else{ + d_child_counter = -1; + } + } + } + d_wasSet = success; + Debug("qcf-match") << " ...finished construct match for " << d_n << ", success = " << success << std::endl; + return success; + } + } + Debug("qcf-match") << " ...already finished for " << d_n << std::endl; + return false; +} + +bool MatchGen::getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ) { + if( d_type==typ_eq ){ + Node n[2]; + for( unsigned i=0; i<2; i++ ){ + Trace("qcf-explain") << "Explain term " << d_n[i] << "..." << std::endl; + n[i] = getExplanationTerm( p, qi, d_n[i], exp ); + } + Node eq = n[0].eqNode( n[1] ); + if( !d_tgt_orig ){ + eq = eq.negate(); + } + exp.push_back( eq ); + Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << eq << ", set = " << d_wasSet << std::endl; + return true; + }else if( d_type==typ_pred ){ + Trace("qcf-explain") << "Explain term " << d_n << "..." << std::endl; + Node n = getExplanationTerm( p, qi, d_n, exp ); + if( !d_tgt_orig ){ + n = n.negate(); + } + exp.push_back( n ); + Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << n << ", set = " << d_wasSet << std::endl; + return true; + }else if( d_type==typ_formula ){ + Trace("qcf-explain") << "Explanation get for " << d_n << ", counter = " << d_child_counter << ", tgt = " << d_tgt_orig << ", set = " << d_wasSet << std::endl; + if( d_n.getKind()==OR || d_n.getKind()==AND ){ + if( (d_n.getKind()==AND)==d_tgt ){ + for( unsigned i=0; i<getNumChildren(); i++ ){ + if( !getChild( i )->getExplanation( p, qi, exp ) ){ + return false; + } + } + }else{ + return getChild( d_child_counter )->getExplanation( p, qi, exp ); + } + }else if( d_n.getKind()==IFF ){ + for( unsigned i=0; i<2; i++ ){ + if( !getChild( i )->getExplanation( p, qi, exp ) ){ + return false; + } + } + }else if( d_n.getKind()==ITE ){ + for( unsigned i=0; i<3; i++ ){ + bool isActive = ( ( i==0 && d_child_counter!=5 ) || + ( i==1 && d_child_counter!=( d_tgt ? 3 : 1 ) ) || + ( i==2 && d_child_counter!=( d_tgt ? 1 : 3 ) ) ); + if( isActive ){ + if( !getChild( i )->getExplanation( p, qi, exp ) ){ + return false; + } + } + } + }else{ + return false; + } + return true; + }else{ + return false; + } +} + +Node MatchGen::getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ) { + Node v = qi->getCurrentExpValue( t ); + if( isHandledUfTerm( t ) ){ + for( unsigned i=0; i<t.getNumChildren(); i++ ){ + Node vi = getExplanationTerm( p, qi, t[i], exp ); + if( vi!=v[i] ){ + Node eq = vi.eqNode( v[i] ); + if( std::find( exp.begin(), exp.end(), eq )==exp.end() ){ + Trace("qcf-explain") << " add : " << eq << "." << std::endl; + exp.push_back( eq ); + } + } + } + } + return v; +} + +bool MatchGen::doMatching( QuantConflictFind * p, QuantInfo * qi ) { + if( !d_qn.empty() ){ + if( d_qn[0]==NULL ){ + d_qn.clear(); + return true; + }else{ + Assert( d_type==typ_var ); + Assert( d_qni_size>0 ); + bool invalidMatch; + do { + invalidMatch = false; + Debug("qcf-match-debug") << " Do matching " << d_n << " " << d_qn.size() << " " << d_qni.size() << std::endl; + if( d_qn.size()==d_qni.size()+1 ) { + int index = (int)d_qni.size(); + //initialize + TNode val; + std::map< int, int >::iterator itv = d_qni_var_num.find( index ); + if( itv!=d_qni_var_num.end() ){ + //get the representative variable this variable is equal to + int repVar = qi->getCurrentRepVar( itv->second ); + Debug("qcf-match-debug") << " Match " << index << " is a variable " << itv->second << ", which is repVar " << repVar << std::endl; + //get the value the rep variable + //std::map< int, TNode >::iterator itm = qi->d_match.find( repVar ); + if( !qi->d_match[repVar].isNull() ){ + val = qi->d_match[repVar]; + Debug("qcf-match-debug") << " Variable is already bound to " << val << std::endl; + }else{ + //binding a variable + d_qni_bound[index] = repVar; + std::map< TNode, TermArgTrie >::iterator it = d_qn[index]->d_data.begin(); + if( it != d_qn[index]->d_data.end() ) { + d_qni.push_back( it ); + //set the match + if( it->first.getType().isSubtypeOf( qi->d_var_types[repVar] ) && qi->setMatch( p, d_qni_bound[index], it->first ) ){ + Debug("qcf-match-debug") << " Binding variable" << std::endl; + if( d_qn.size()<d_qni_size ){ + d_qn.push_back( &it->second ); + } + }else{ + Debug("qcf-match") << " Binding variable, currently fail." << std::endl; + invalidMatch = true; + } + }else{ + Debug("qcf-match-debug") << " Binding variable, fail, no more variables to bind" << std::endl; + d_qn.pop_back(); + } + } + }else{ + Debug("qcf-match-debug") << " Match " << index << " is ground term" << std::endl; + Assert( d_qni_gterm.find( index )!=d_qni_gterm.end() ); + Assert( d_qni_gterm_rep.find( index )!=d_qni_gterm_rep.end() ); + val = d_qni_gterm_rep[index]; + Assert( !val.isNull() ); + } + if( !val.isNull() ){ + //constrained by val + std::map< TNode, TermArgTrie >::iterator it = d_qn[index]->d_data.find( val ); + if( it!=d_qn[index]->d_data.end() ){ + Debug("qcf-match-debug") << " Match" << std::endl; + d_qni.push_back( it ); + if( d_qn.size()<d_qni_size ){ + d_qn.push_back( &it->second ); + } + }else{ + Debug("qcf-match-debug") << " Failed to match" << std::endl; + d_qn.pop_back(); + } + } + }else{ + Assert( d_qn.size()==d_qni.size() ); + int index = d_qni.size()-1; + //increment if binding this variable + bool success = false; + std::map< int, int >::iterator itb = d_qni_bound.find( index ); + if( itb!=d_qni_bound.end() ){ + d_qni[index]++; + if( d_qni[index]!=d_qn[index]->d_data.end() ){ + success = true; + if( qi->setMatch( p, itb->second, d_qni[index]->first ) ){ + Debug("qcf-match-debug") << " Bind next variable" << std::endl; + if( d_qn.size()<d_qni_size ){ + d_qn.push_back( &d_qni[index]->second ); + } + }else{ + Debug("qcf-match-debug") << " Bind next variable, currently fail" << std::endl; + invalidMatch = true; + } + }else{ + qi->d_match[ itb->second ] = TNode::null(); + qi->d_match_term[ itb->second ] = TNode::null(); + Debug("qcf-match-debug") << " Bind next variable, no more variables to bind" << std::endl; + } + }else{ + //TODO : if it equal to something else, also try that + } + //if not incrementing, move to next + if( !success ){ + d_qn.pop_back(); + d_qni.pop_back(); + } + } + }while( ( !d_qn.empty() && d_qni.size()!=d_qni_size ) || invalidMatch ); + if( d_qni.size()==d_qni_size ){ + //Assert( !d_qni[d_qni.size()-1]->second.d_data.empty() ); + //Debug("qcf-match-debug") << " We matched " << d_qni[d_qni.size()-1]->second.d_children.begin()->first << std::endl; + Assert( !d_qni[d_qni.size()-1]->second.d_data.empty() ); + TNode t = d_qni[d_qni.size()-1]->second.d_data.begin()->first; + Debug("qcf-match-debug") << " " << d_n << " matched " << t << std::endl; + qi->d_match_term[d_qni_var_num[0]] = t; + //set the match terms + for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){ + Debug("qcf-match-debug") << " position " << it->first << " bounded " << it->second << " / " << qi->d_q[0].getNumChildren() << std::endl; + //if( it->second<(int)qi->d_q[0].getNumChildren() ){ //if it is an actual variable, we are interested in knowing the actual term + if( it->first>0 ){ + Assert( !qi->d_match[ it->second ].isNull() ); + Assert( p->areEqual( t[it->first-1], qi->d_match[ it->second ] ) ); + qi->d_match_term[it->second] = t[it->first-1]; + } + //} + } + } + } + } + return !d_qn.empty(); +} + +void MatchGen::debugPrintType( const char * c, short typ, bool isTrace ) { + if( isTrace ){ + switch( typ ){ + case typ_invalid: Trace(c) << "invalid";break; + case typ_ground: Trace(c) << "ground";break; + case typ_eq: Trace(c) << "eq";break; + case typ_pred: Trace(c) << "pred";break; + case typ_formula: Trace(c) << "formula";break; + case typ_var: Trace(c) << "var";break; + case typ_ite_var: Trace(c) << "ite_var";break; + case typ_bool_var: Trace(c) << "bool_var";break; + } + }else{ + switch( typ ){ + case typ_invalid: Debug(c) << "invalid";break; + case typ_ground: Debug(c) << "ground";break; + case typ_eq: Debug(c) << "eq";break; + case typ_pred: Debug(c) << "pred";break; + case typ_formula: Debug(c) << "formula";break; + case typ_var: Debug(c) << "var";break; + case typ_ite_var: Debug(c) << "ite_var";break; + case typ_bool_var: Debug(c) << "bool_var";break; + } + } +} + +void MatchGen::setInvalid() { + d_type = typ_invalid; + d_children.clear(); +} + +bool MatchGen::isHandledBoolConnective( TNode n ) { + return n.getType().isBoolean() && ( n.getKind()==OR || n.getKind()==AND || n.getKind()==IFF || n.getKind()==ITE || n.getKind()==FORALL || n.getKind()==NOT ); +} + +bool MatchGen::isHandledUfTerm( TNode n ) { + //return n.getKind()==APPLY_UF || n.getKind()==STORE || n.getKind()==SELECT || + // n.getKind()==APPLY_CONSTRUCTOR || n.getKind()==APPLY_SELECTOR_TOTAL || n.getKind()==APPLY_TESTER; + return inst::Trigger::isAtomicTriggerKind( n.getKind() ); +} + +Node MatchGen::getOperator( QuantConflictFind * p, Node n ) { + if( isHandledUfTerm( n ) ){ + return p->getTermDatabase()->getOperator( n ); + }else{ + return Node::null(); + } +} + +bool MatchGen::isHandled( TNode n ) { + if( n.getKind()!=BOUND_VARIABLE && n.hasBoundVar() ){ + if( !isHandledBoolConnective( n ) && !isHandledUfTerm( n ) && n.getKind()!=EQUAL && n.getKind()!=ITE ){ + return false; + } + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + if( !isHandled( n[i] ) ){ + return false; + } + } + } + return true; +} + + +QuantConflictFind::QuantConflictFind( QuantifiersEngine * qe, context::Context* c ) : +QuantifiersModule( qe ), +d_conflict( c, false ), +d_qassert( c ) { + d_fid_count = 0; + d_true = NodeManager::currentNM()->mkConst<bool>(true); + d_false = NodeManager::currentNM()->mkConst<bool>(false); +} + +Node QuantConflictFind::mkEqNode( Node a, Node b ) { + if( a.getType().isBoolean() ){ + return a.iffNode( b ); + }else{ + return a.eqNode( b ); + } +} + +//-------------------------------------------------- registration + +void QuantConflictFind::registerQuantifier( Node q ) { + if( d_quantEngine->hasOwnership( q, this ) ){ + d_quants.push_back( q ); + d_quant_id[q] = d_quants.size(); + Trace("qcf-qregister") << "Register "; + debugPrintQuant( "qcf-qregister", q ); + Trace("qcf-qregister") << " : " << q << std::endl; + //make QcfNode structure + Trace("qcf-qregister") << "- Get relevant equality/disequality pairs, calculate flattening..." << std::endl; + d_qinfo[q].initialize( q, q[1] ); + + //debug print + Trace("qcf-qregister") << "- Flattened structure is :" << std::endl; + Trace("qcf-qregister") << " "; + debugPrintQuantBody( "qcf-qregister", q, q[1] ); + Trace("qcf-qregister") << std::endl; + if( d_qinfo[q].d_vars.size()>q[0].getNumChildren() ){ + Trace("qcf-qregister") << " with additional constraints : " << std::endl; + for( unsigned j=q[0].getNumChildren(); j<d_qinfo[q].d_vars.size(); j++ ){ + Trace("qcf-qregister") << " ?x" << j << " = "; + debugPrintQuantBody( "qcf-qregister", q, d_qinfo[q].d_vars[j], false ); + Trace("qcf-qregister") << std::endl; + } + } + + Trace("qcf-qregister") << "Done registering quantifier." << std::endl; + } +} + +int QuantConflictFind::evaluate( Node n, bool pref, bool hasPref ) { + int ret = 0; + if( n.getKind()==EQUAL ){ + Node n1 = evaluateTerm( n[0] ); + Node n2 = evaluateTerm( n[1] ); + Debug("qcf-eval") << "Evaluate : Normalize " << n << " to " << n1 << " = " << n2 << std::endl; + if( areEqual( n1, n2 ) ){ + ret = 1; + }else if( areDisequal( n1, n2 ) ){ + ret = -1; + } + //else if( d_effort>QuantConflictFind::effort_conflict ){ + // ret = -1; + //} + }else if( MatchGen::isHandledUfTerm( n ) ){ //predicate + Node nn = evaluateTerm( n ); + Debug("qcf-eval") << "Evaluate : Normalize " << nn << " to " << n << std::endl; + if( areEqual( nn, d_true ) ){ + ret = 1; + }else if( areEqual( nn, d_false ) ){ + ret = -1; + } + //else if( d_effort>QuantConflictFind::effort_conflict ){ + // ret = -1; + //} + }else if( n.getKind()==NOT ){ + return -evaluate( n[0] ); + }else if( n.getKind()==ITE ){ + int cev1 = evaluate( n[0] ); + int cevc[2] = { 0, 0 }; + for( unsigned i=0; i<2; i++ ){ + if( ( i==0 && cev1!=-1 ) || ( i==1 && cev1!=1 ) ){ + cevc[i] = evaluate( n[i+1] ); + if( cev1!=0 ){ + ret = cevc[i]; + break; + }else if( cevc[i]==0 ){ + break; + } + } + } + if( ret==0 && cevc[0]!=0 && cevc[0]==cevc[1] ){ + ret = cevc[0]; + } + }else if( n.getKind()==IFF ){ + int cev1 = evaluate( n[0] ); + if( cev1!=0 ){ + int cev2 = evaluate( n[1] ); + if( cev2!=0 ){ + ret = cev1==cev2 ? 1 : -1; + } + } + + }else{ + int ssval = 0; + if( n.getKind()==OR ){ + ssval = 1; + }else if( n.getKind()==AND ){ + ssval = -1; + } + bool isUnk = false; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + int cev = evaluate( n[i] ); + if( cev==ssval ){ + ret = ssval; + break; + }else if( cev==0 ){ + isUnk = true; + } + } + if( ret==0 && !isUnk ){ + ret = -ssval; + } + } + Debug("qcf-eval") << "Evaluate " << n << " to " << ret << std::endl; + return ret; +} + +short QuantConflictFind::getMaxQcfEffort() { + if( options::qcfMode()==QCF_CONFLICT_ONLY ){ + return effort_conflict; + }else if( options::qcfMode()==QCF_PROP_EQ ){ + return effort_prop_eq; + }else if( options::qcfMode()==QCF_MC ){ + return effort_mc; + }else{ + return 0; + } +} + +bool QuantConflictFind::areMatchEqual( TNode n1, TNode n2 ) { + //if( d_effort==QuantConflictFind::effort_mc ){ + // return n1==n2 || !areDisequal( n1, n2 ); + //}else{ + return n1==n2; + //} +} + +bool QuantConflictFind::areMatchDisequal( TNode n1, TNode n2 ) { + //if( d_effort==QuantConflictFind::effort_conflict ){ + // return areDisequal( n1, n2 ); + //}else{ + return n1!=n2; + //} +} + +//-------------------------------------------------- handling assertions / eqc + +void QuantConflictFind::assertNode( Node q ) { + if( d_quantEngine->hasOwnership( q, this ) ){ + Trace("qcf-proc") << "QCF : assertQuantifier : "; + debugPrintQuant("qcf-proc", q); + Trace("qcf-proc") << std::endl; + d_qassert.push_back( q ); + //set the eqRegistries that this depends on to true + //for( std::map< EqRegistry *, bool >::iterator it = d_qinfo[q].d_rel_eqr.begin(); it != d_qinfo[q].d_rel_eqr.end(); ++it ){ + // it->first->d_active.set( true ); + //} + } +} + +Node QuantConflictFind::evaluateTerm( Node n ) { + if( MatchGen::isHandledUfTerm( n ) ){ + Node f = MatchGen::getOperator( this, n ); + Node nn; + if( getEqualityEngine()->hasTerm( n ) ){ + nn = getTermDatabase()->existsTerm( f, n ); + }else{ + std::vector< TNode > args; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + Node c = evaluateTerm( n[i] ); + args.push_back( c ); + } + nn = getTermDatabase()->d_func_map_trie[f].existsTerm( args ); + } + if( !nn.isNull() ){ + Debug("qcf-eval") << "GT: Term " << nn << " for " << n << " hasTerm = " << getEqualityEngine()->hasTerm( n ) << std::endl; + return getRepresentative( nn ); + }else{ + Debug("qcf-eval") << "GT: No term for " << n << " hasTerm = " << getEqualityEngine()->hasTerm( n ) << std::endl; + return n; + } + }else if( n.getKind()==ITE ){ + int v = evaluate( n[0], false, false ); + if( v==1 ){ + return evaluateTerm( n[1] ); + }else if( v==-1 ){ + return evaluateTerm( n[2] ); + } + } + return getRepresentative( n ); +} + +/** new node */ +void QuantConflictFind::newEqClass( Node n ) { + +} + +/** merge */ +void QuantConflictFind::merge( Node a, Node b ) { + +} + +/** assert disequal */ +void QuantConflictFind::assertDisequal( Node a, Node b ) { + +} + +//-------------------------------------------------- check function + +bool QuantConflictFind::needsCheck( Theory::Effort level ) { + bool performCheck = false; + if( options::quantConflictFind() && !d_conflict ){ + if( level==Theory::EFFORT_LAST_CALL ){ + performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_LAST_CALL; + }else if( level==Theory::EFFORT_FULL ){ + performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_DEFAULT; + }else if( level==Theory::EFFORT_STANDARD ){ + performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_STD; + } + } + return performCheck; +} + +void QuantConflictFind::reset_round( Theory::Effort level ) { + d_needs_computeRelEqr = true; +} + +/** check */ +void QuantConflictFind::check( Theory::Effort level, unsigned quant_e ) { + if( quant_e==QuantifiersEngine::QEFFORT_CONFLICT ){ + Trace("qcf-check") << "QCF : check : " << level << std::endl; + if( d_conflict ){ + Trace("qcf-check2") << "QCF : finished check : already in conflict." << std::endl; + if( level>=Theory::EFFORT_FULL ){ + Trace("qcf-warn") << "ALREADY IN CONFLICT? " << level << std::endl; + //Assert( false ); + } + }else{ + int addedLemmas = 0; + ++(d_statistics.d_inst_rounds); + double clSet = 0; + int prevEt = 0; + if( Trace.isOn("qcf-engine") ){ + prevEt = d_statistics.d_entailment_checks.getData(); + clSet = double(clock())/double(CLOCKS_PER_SEC); + Trace("qcf-engine") << "---Conflict Find Engine Round, effort = " << level << "---" << std::endl; + } + computeRelevantEqr(); + + //determine order for quantified formulas + std::vector< Node > qorder; + std::map< Node, bool > qassert; + //mark which are asserted + for( unsigned i=0; i<d_qassert.size(); i++ ){ + qassert[d_qassert[i]] = true; + } + //add which ones are specified in the order + for( unsigned i=0; i<d_quant_order.size(); i++ ){ + Node n = d_quant_order[i]; + if( std::find( qorder.begin(), qorder.end(), n )==qorder.end() && qassert.find( n )!=qassert.end() ){ + qorder.push_back( n ); + } + } + d_quant_order.clear(); + d_quant_order.insert( d_quant_order.begin(), qorder.begin(), qorder.end() ); + //add remaining + for( unsigned i=0; i<d_qassert.size(); i++ ){ + Node n = d_qassert[i]; + if( std::find( qorder.begin(), qorder.end(), n )==qorder.end() ){ + qorder.push_back( n ); + } + } + + if( Trace.isOn("qcf-debug") ){ + Trace("qcf-debug") << std::endl; + debugPrint("qcf-debug"); + Trace("qcf-debug") << std::endl; + } + short end_e = getMaxQcfEffort(); + for( short e = effort_conflict; e<=end_e; e++ ){ + d_effort = e; + Trace("qcf-check") << "Checking quantified formulas at effort " << e << "..." << std::endl; + for( unsigned j=0; j<qorder.size(); j++ ){ + Node q = qorder[j]; + QuantInfo * qi = &d_qinfo[q]; + + Assert( d_qinfo.find( q )!=d_qinfo.end() ); + if( qi->d_mg->isValid() ){ + Trace("qcf-check") << "Check quantified formula "; + debugPrintQuant("qcf-check", q); + Trace("qcf-check") << " : " << q << "..." << std::endl; + + Trace("qcf-check-debug") << "Reset round..." << std::endl; + qi->reset_round( this ); + //try to make a matches making the body false + Trace("qcf-check-debug") << "Get next match..." << std::endl; + while( qi->d_mg->getNextMatch( this, qi ) ){ + Trace("qcf-inst") << "*** Produced match at effort " << e << " : " << std::endl; + qi->debugPrintMatch("qcf-inst"); + Trace("qcf-inst") << std::endl; + std::vector< int > assigned; + if( !qi->isMatchSpurious( this ) ){ + if( qi->completeMatch( this, assigned ) ){ + std::vector< Node > terms; + qi->getMatch( terms ); + if( !qi->isTConstraintSpurious( this, terms ) ){ + if( Debug.isOn("qcf-check-inst") ){ + //if( e==effort_conflict ){ + Node inst = d_quantEngine->getInstantiation( q, terms ); + Debug("qcf-check-inst") << "Check instantiation " << inst << "..." << std::endl; + Assert( evaluate( inst )!=1 ); + Assert( evaluate( inst )==-1 || e>effort_conflict ); + //} + } + if( d_quantEngine->addInstantiation( q, terms, false ) ){ + Trace("qcf-check") << " ... Added instantiation" << std::endl; + Trace("qcf-inst") << "*** Was from effort " << e << " : " << std::endl; + qi->debugPrintMatch("qcf-inst"); + Trace("qcf-inst") << std::endl; + ++addedLemmas; + if( e==effort_conflict ){ + d_quant_order.insert( d_quant_order.begin(), q ); + d_conflict.set( true ); + ++(d_statistics.d_conflict_inst); + break; + }else if( e==effort_prop_eq ){ + ++(d_statistics.d_prop_inst); + } + }else{ + Trace("qcf-inst") << " ... Failed to add instantiation" << std::endl; + //Assert( false ); + } + } + //clean up assigned + qi->revertMatch( assigned ); + d_tempCache.clear(); + }else{ + Trace("qcf-inst") << " ... Spurious instantiation (cannot assign unassigned variables)" << std::endl; + } + }else{ + Trace("qcf-inst") << " ... Spurious instantiation (match is inconsistent)" << std::endl; + } + } + if( d_conflict ){ + break; + } + } + } + if( addedLemmas>0 ){ + break; + } + } + if( Trace.isOn("qcf-engine") ){ + double clSet2 = double(clock())/double(CLOCKS_PER_SEC); + Trace("qcf-engine") << "Finished conflict find engine, time = " << (clSet2-clSet); + if( addedLemmas>0 ){ + Trace("qcf-engine") << ", effort = " << ( d_effort==effort_conflict ? "conflict" : ( d_effort==effort_prop_eq ? "prop_eq" : "mc" ) ); + Trace("qcf-engine") << ", addedLemmas = " << addedLemmas; + } + Trace("qcf-engine") << std::endl; + int currEt = d_statistics.d_entailment_checks.getData(); + if( currEt!=prevEt ){ + Trace("qcf-engine") << " Entailment checks = " << ( currEt - prevEt ) << std::endl; + } + } + Trace("qcf-check2") << "QCF : finished check : " << level << std::endl; + } + } +} + +void QuantConflictFind::computeRelevantEqr() { + if( d_needs_computeRelEqr ){ + d_needs_computeRelEqr = false; + Trace("qcf-check") << "Compute relevant equalities..." << std::endl; + //d_uf_terms.clear(); + //d_eqc_uf_terms.clear(); + d_eqcs.clear(); + d_model_basis.clear(); + //d_arg_reps.clear(); + //double clSet = 0; + //if( Trace.isOn("qcf-opt") ){ + // clSet = double(clock())/double(CLOCKS_PER_SEC); + //} + + //long nTermst = 0; + //long nTerms = 0; + //long nEqc = 0; + + //which nodes are irrelevant for disequality matches + std::map< TNode, bool > irrelevant_dnode; + //now, store matches + eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() ); + while( !eqcs_i.isFinished() ){ + //nEqc++; + Node r = (*eqcs_i); + if( getTermDatabase()->hasTermCurrent( r ) ){ + TypeNode rtn = r.getType(); + if( options::qcfMode()==QCF_MC ){ + std::map< TypeNode, std::vector< TNode > >::iterator itt = d_eqcs.find( rtn ); + if( itt==d_eqcs.end() ){ + Node mb = getTermDatabase()->getModelBasisTerm( rtn ); + if( !getEqualityEngine()->hasTerm( mb ) ){ + Trace("qcf-warn") << "WARNING: Model basis term does not exist!" << std::endl; + Assert( false ); + } + Node mbr = getRepresentative( mb ); + if( mbr!=r ){ + d_eqcs[rtn].push_back( mbr ); + } + d_eqcs[rtn].push_back( r ); + d_model_basis[rtn] = mb; + }else{ + itt->second.push_back( r ); + } + }else{ + d_eqcs[rtn].push_back( r ); + } + } + ++eqcs_i; + } + /* + if( Trace.isOn("qcf-opt") ){ + double clSet2 = double(clock())/double(CLOCKS_PER_SEC); + Trace("qcf-opt") << "Compute rel eqc : " << std::endl; + Trace("qcf-opt") << " " << nEqc << " equivalence classes. " << std::endl; + Trace("qcf-opt") << " " << nTerms << " / " << nTermst << " terms." << std::endl; + Trace("qcf-opt") << " Time : " << (clSet2-clSet) << std::endl; + } + */ + } +} + + +//-------------------------------------------------- debugging + + +void QuantConflictFind::debugPrint( const char * c ) { + //print the equivalance classes + Trace(c) << "----------EQ classes" << std::endl; + eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() ); + while( !eqcs_i.isFinished() ){ + Node n = (*eqcs_i); + //if( !n.getType().isInteger() ){ + Trace(c) << " - " << n << " : {"; + eq::EqClassIterator eqc_i = eq::EqClassIterator( n, getEqualityEngine() ); + bool pr = false; + while( !eqc_i.isFinished() ){ + Node nn = (*eqc_i); + if( nn.getKind()!=EQUAL && nn!=n ){ + Trace(c) << (pr ? "," : "" ) << " " << nn; + pr = true; + } + ++eqc_i; + } + Trace(c) << (pr ? " " : "" ) << "}" << std::endl; + /* + EqcInfo * eqcn = getEqcInfo( n, false ); + if( eqcn ){ + Trace(c) << " DEQ : {"; + pr = false; + for( NodeBoolMap::iterator it = eqcn->d_diseq.begin(); it != eqcn->d_diseq.end(); ++it ){ + if( (*it).second ){ + Trace(c) << (pr ? "," : "" ) << " " << (*it).first; + pr = true; + } + } + Trace(c) << (pr ? " " : "" ) << "}" << std::endl; + } + //} + */ + ++eqcs_i; + } +} + +void QuantConflictFind::debugPrintQuant( const char * c, Node q ) { + Trace(c) << "Q" << d_quant_id[q]; +} + +void QuantConflictFind::debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum ) { + if( n.getNumChildren()==0 ){ + Trace(c) << n; + }else if( doVarNum && d_qinfo[q].d_var_num.find( n )!=d_qinfo[q].d_var_num.end() ){ + Trace(c) << "?x" << d_qinfo[q].d_var_num[n]; + }else{ + Trace(c) << "("; + if( n.getKind()==APPLY_UF ){ + Trace(c) << n.getOperator(); + }else{ + Trace(c) << n.getKind(); + } + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + Trace(c) << " "; + debugPrintQuantBody( c, q, n[i] ); + } + Trace(c) << ")"; + } +} + +QuantConflictFind::Statistics::Statistics(): + d_inst_rounds("QuantConflictFind::Inst_Rounds", 0), + d_conflict_inst("QuantConflictFind::Instantiations_Conflict_Find", 0 ), + d_prop_inst("QuantConflictFind::Instantiations_Prop", 0 ), + d_entailment_checks("QuantConflictFind::Entailment_Checks",0) +{ + StatisticsRegistry::registerStat(&d_inst_rounds); + StatisticsRegistry::registerStat(&d_conflict_inst); + StatisticsRegistry::registerStat(&d_prop_inst); + StatisticsRegistry::registerStat(&d_entailment_checks); +} + +QuantConflictFind::Statistics::~Statistics(){ + StatisticsRegistry::unregisterStat(&d_inst_rounds); + StatisticsRegistry::unregisterStat(&d_conflict_inst); + StatisticsRegistry::unregisterStat(&d_prop_inst); + StatisticsRegistry::unregisterStat(&d_entailment_checks); +} + +TNode QuantConflictFind::getZero( Kind k ) { + std::map< Kind, Node >::iterator it = d_zero.find( k ); + if( it==d_zero.end() ){ + Node nn; + if( k==PLUS ){ + nn = NodeManager::currentNM()->mkConst( Rational(0) ); + } + d_zero[k] = nn; + return nn; + }else{ + return it->second; + } +} + + +} diff --git a/src/theory/quantifiers/quant_conflict_find.h b/src/theory/quantifiers/quant_conflict_find.h index 829b67777..d2a982781 100644 --- a/src/theory/quantifiers/quant_conflict_find.h +++ b/src/theory/quantifiers/quant_conflict_find.h @@ -1,255 +1,255 @@ -/********************* */
-/*! \file quant_conflict_find.h
- ** \verbatim
- ** Original author: Andrew Reynolds
- ** Major contributors: none
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief quantifiers conflict find class
- **/
-
-#include "cvc4_private.h"
-
-#ifndef QUANT_CONFLICT_FIND
-#define QUANT_CONFLICT_FIND
-
-#include "context/cdhashmap.h"
-#include "context/cdchunk_list.h"
-#include "theory/quantifiers_engine.h"
-#include "theory/quantifiers/term_database.h"
-
-namespace CVC4 {
-namespace theory {
-namespace quantifiers {
-
-class QuantConflictFind;
-class QuantInfo;
-
-//match generator
-class MatchGen {
- friend class QuantInfo;
-private:
- //current children information
- int d_child_counter;
- //children of this object
- std::vector< int > d_children_order;
- unsigned getNumChildren() { return d_children.size(); }
- MatchGen * getChild( int i ) { return &d_children[d_children_order[i]]; }
- //MatchGen * getChild( int i ) { return &d_children[i]; }
- //current matching information
- std::vector< TermArgTrie * > d_qn;
- std::vector< std::map< TNode, TermArgTrie >::iterator > d_qni;
- bool doMatching( QuantConflictFind * p, QuantInfo * qi );
- //for matching : each index is either a variable or a ground term
- unsigned d_qni_size;
- std::map< int, int > d_qni_var_num;
- std::map< int, TNode > d_qni_gterm;
- std::map< int, TNode > d_qni_gterm_rep;
- std::map< int, int > d_qni_bound;
- std::vector< int > d_qni_bound_except;
- std::map< int, TNode > d_qni_bound_cons;
- std::map< int, int > d_qni_bound_cons_var;
- std::map< int, int >::iterator d_binding_it;
- //std::vector< int > d_independent;
- bool d_matched_basis;
- bool d_binding;
- //int getVarBindingVar();
- std::map< int, Node > d_ground_eval;
- //determine variable order
- void determineVariableOrder( QuantInfo * qi, std::vector< int >& bvars );
- void collectBoundVar( QuantInfo * qi, Node n, std::vector< int >& cbvars );
-public:
- //type of the match generator
- enum {
- typ_invalid,
- typ_ground,
- typ_pred,
- typ_eq,
- typ_formula,
- typ_var,
- typ_ite_var,
- typ_bool_var,
- typ_tconstraint,
- typ_tsym,
- };
- void debugPrintType( const char * c, short typ, bool isTrace = false );
-public:
- MatchGen() : d_type( typ_invalid ){}
- MatchGen( QuantInfo * qi, Node n, bool isVar = false );
- bool d_tgt;
- bool d_tgt_orig;
- bool d_wasSet;
- Node d_n;
- std::vector< MatchGen > d_children;
- short d_type;
- bool d_type_not;
- void reset_round( QuantConflictFind * p );
- void reset( QuantConflictFind * p, bool tgt, QuantInfo * qi );
- bool getNextMatch( QuantConflictFind * p, QuantInfo * qi );
- bool getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp );
- Node getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp );
- bool isValid() { return d_type!=typ_invalid; }
- void setInvalid();
-
- // is this term treated as UF application?
- static bool isHandledBoolConnective( TNode n );
- static bool isHandledUfTerm( TNode n );
- static Node getOperator( QuantConflictFind * p, Node n );
- //can this node be handled by the algorithm
- static bool isHandled( TNode n );
-};
-
-//info for quantifiers
-class QuantInfo {
-private:
- void registerNode( Node n, bool hasPol, bool pol, bool beneathQuant = false );
- void flatten( Node n, bool beneathQuant );
-private: //for completing match
- std::vector< int > d_unassigned;
- std::vector< TypeNode > d_unassigned_tn;
- int d_unassigned_nvar;
- int d_una_index;
- std::vector< int > d_una_eqc_count;
-public:
- QuantInfo() : d_mg( NULL ) {}
- ~QuantInfo() { delete d_mg; }
- std::vector< TNode > d_vars;
- std::vector< TypeNode > d_var_types;
- std::map< TNode, int > d_var_num;
- std::vector< int > d_tsym_vars;
- std::map< TNode, bool > d_inMatchConstraint;
- std::map< int, std::vector< Node > > d_var_constraint[2];
- int getVarNum( TNode v ) { return d_var_num.find( v )!=d_var_num.end() ? d_var_num[v] : -1; }
- bool isVar( TNode v ) { return d_var_num.find( v )!=d_var_num.end(); }
- int getNumVars() { return (int)d_vars.size(); }
- TNode getVar( int i ) { return d_vars[i]; }
-
- MatchGen * d_mg;
- Node d_q;
- std::map< int, MatchGen * > d_var_mg;
- void reset_round( QuantConflictFind * p );
-public:
- //initialize
- void initialize( Node q, Node qn );
- //current constraints
- std::vector< TNode > d_match;
- std::vector< TNode > d_match_term;
- std::map< int, std::map< TNode, int > > d_curr_var_deq;
- std::map< Node, bool > d_tconstraints;
- int getCurrentRepVar( int v );
- TNode getCurrentValue( TNode n );
- TNode getCurrentExpValue( TNode n );
- bool getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq = false );
- int addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity );
- int addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove );
- bool setMatch( QuantConflictFind * p, int v, TNode n );
- bool isMatchSpurious( QuantConflictFind * p );
- bool isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms );
- bool entailmentTest( QuantConflictFind * p, Node lit, bool chEnt = true );
- bool completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue = false );
- void revertMatch( std::vector< int >& assigned );
- void debugPrintMatch( const char * c );
- bool isConstrainedVar( int v );
-public:
- void getMatch( std::vector< Node >& terms );
-};
-
-class QuantConflictFind : public QuantifiersModule
-{
- friend class MatchGen;
- friend class QuantInfo;
- typedef context::CDChunkList<Node> NodeList;
- typedef context::CDHashMap<Node, bool, NodeHashFunction> NodeBoolMap;
-private:
- context::CDO< bool > d_conflict;
- std::vector< Node > d_quant_order;
- std::map< Kind, Node > d_zero;
- //for storing nodes created during t-constraint solving (prevents memory leaks)
- std::vector< Node > d_tempCache;
-private:
- std::map< Node, Node > d_op_node;
- int d_fid_count;
- std::map< Node, int > d_fid;
- Node mkEqNode( Node a, Node b );
-public: //for ground terms
- Node d_true;
- Node d_false;
- TNode getZero( Kind k );
-private:
- Node evaluateTerm( Node n );
- int evaluate( Node n, bool pref = false, bool hasPref = false );
-private:
- //currently asserted quantifiers
- NodeList d_qassert;
- std::map< Node, QuantInfo > d_qinfo;
-private: //for equivalence classes
- // type -> list(eqc)
- std::map< TypeNode, std::vector< TNode > > d_eqcs;
- std::map< TypeNode, Node > d_model_basis;
-public:
- enum {
- effort_conflict,
- effort_prop_eq,
- effort_mc,
- };
- short d_effort;
- void setEffort( int e ) { d_effort = e; }
- static short getMaxQcfEffort();
- bool areMatchEqual( TNode n1, TNode n2 );
- bool areMatchDisequal( TNode n1, TNode n2 );
-public:
- QuantConflictFind( QuantifiersEngine * qe, context::Context* c );
- ~QuantConflictFind() throw() {}
- /** register quantifier */
- void registerQuantifier( Node q );
-public:
- /** assert quantifier */
- void assertNode( Node q );
- /** new node */
- void newEqClass( Node n );
- /** merge */
- void merge( Node a, Node b );
- /** assert disequal */
- void assertDisequal( Node a, Node b );
- /** needs check */
- bool needsCheck( Theory::Effort level );
- /** reset round */
- void reset_round( Theory::Effort level );
- /** check */
- void check( Theory::Effort level, unsigned quant_e );
-private:
- bool d_needs_computeRelEqr;
-public:
- void computeRelevantEqr();
-private:
- void debugPrint( const char * c );
- //for debugging
- std::vector< Node > d_quants;
- std::map< Node, int > d_quant_id;
- void debugPrintQuant( const char * c, Node q );
- void debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum = true );
-public:
- /** statistics class */
- class Statistics {
- public:
- IntStat d_inst_rounds;
- IntStat d_conflict_inst;
- IntStat d_prop_inst;
- IntStat d_entailment_checks;
- Statistics();
- ~Statistics();
- };
- Statistics d_statistics;
- /** Identify this module */
- std::string identify() const { return "QcfEngine"; }
-};
-
-}
-}
-}
-
-#endif
+/********************* */ +/*! \file quant_conflict_find.h + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief quantifiers conflict find class + **/ + +#include "cvc4_private.h" + +#ifndef QUANT_CONFLICT_FIND +#define QUANT_CONFLICT_FIND + +#include "context/cdhashmap.h" +#include "context/cdchunk_list.h" +#include "theory/quantifiers_engine.h" +#include "theory/quantifiers/term_database.h" + +namespace CVC4 { +namespace theory { +namespace quantifiers { + +class QuantConflictFind; +class QuantInfo; + +//match generator +class MatchGen { + friend class QuantInfo; +private: + //current children information + int d_child_counter; + //children of this object + std::vector< int > d_children_order; + unsigned getNumChildren() { return d_children.size(); } + MatchGen * getChild( int i ) { return &d_children[d_children_order[i]]; } + //MatchGen * getChild( int i ) { return &d_children[i]; } + //current matching information + std::vector< TermArgTrie * > d_qn; + std::vector< std::map< TNode, TermArgTrie >::iterator > d_qni; + bool doMatching( QuantConflictFind * p, QuantInfo * qi ); + //for matching : each index is either a variable or a ground term + unsigned d_qni_size; + std::map< int, int > d_qni_var_num; + std::map< int, TNode > d_qni_gterm; + std::map< int, TNode > d_qni_gterm_rep; + std::map< int, int > d_qni_bound; + std::vector< int > d_qni_bound_except; + std::map< int, TNode > d_qni_bound_cons; + std::map< int, int > d_qni_bound_cons_var; + std::map< int, int >::iterator d_binding_it; + //std::vector< int > d_independent; + bool d_matched_basis; + bool d_binding; + //int getVarBindingVar(); + std::map< int, Node > d_ground_eval; + //determine variable order + void determineVariableOrder( QuantInfo * qi, std::vector< int >& bvars ); + void collectBoundVar( QuantInfo * qi, Node n, std::vector< int >& cbvars ); +public: + //type of the match generator + enum { + typ_invalid, + typ_ground, + typ_pred, + typ_eq, + typ_formula, + typ_var, + typ_ite_var, + typ_bool_var, + typ_tconstraint, + typ_tsym, + }; + void debugPrintType( const char * c, short typ, bool isTrace = false ); +public: + MatchGen() : d_type( typ_invalid ){} + MatchGen( QuantInfo * qi, Node n, bool isVar = false ); + bool d_tgt; + bool d_tgt_orig; + bool d_wasSet; + Node d_n; + std::vector< MatchGen > d_children; + short d_type; + bool d_type_not; + void reset_round( QuantConflictFind * p ); + void reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ); + bool getNextMatch( QuantConflictFind * p, QuantInfo * qi ); + bool getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ); + Node getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ); + bool isValid() { return d_type!=typ_invalid; } + void setInvalid(); + + // is this term treated as UF application? + static bool isHandledBoolConnective( TNode n ); + static bool isHandledUfTerm( TNode n ); + static Node getOperator( QuantConflictFind * p, Node n ); + //can this node be handled by the algorithm + static bool isHandled( TNode n ); +}; + +//info for quantifiers +class QuantInfo { +private: + void registerNode( Node n, bool hasPol, bool pol, bool beneathQuant = false ); + void flatten( Node n, bool beneathQuant ); +private: //for completing match + std::vector< int > d_unassigned; + std::vector< TypeNode > d_unassigned_tn; + int d_unassigned_nvar; + int d_una_index; + std::vector< int > d_una_eqc_count; +public: + QuantInfo() : d_mg( NULL ) {} + ~QuantInfo() { delete d_mg; } + std::vector< TNode > d_vars; + std::vector< TypeNode > d_var_types; + std::map< TNode, int > d_var_num; + std::vector< int > d_tsym_vars; + std::map< TNode, bool > d_inMatchConstraint; + std::map< int, std::vector< Node > > d_var_constraint[2]; + int getVarNum( TNode v ) { return d_var_num.find( v )!=d_var_num.end() ? d_var_num[v] : -1; } + bool isVar( TNode v ) { return d_var_num.find( v )!=d_var_num.end(); } + int getNumVars() { return (int)d_vars.size(); } + TNode getVar( int i ) { return d_vars[i]; } + + MatchGen * d_mg; + Node d_q; + std::map< int, MatchGen * > d_var_mg; + void reset_round( QuantConflictFind * p ); +public: + //initialize + void initialize( Node q, Node qn ); + //current constraints + std::vector< TNode > d_match; + std::vector< TNode > d_match_term; + std::map< int, std::map< TNode, int > > d_curr_var_deq; + std::map< Node, bool > d_tconstraints; + int getCurrentRepVar( int v ); + TNode getCurrentValue( TNode n ); + TNode getCurrentExpValue( TNode n ); + bool getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq = false ); + int addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ); + int addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ); + bool setMatch( QuantConflictFind * p, int v, TNode n ); + bool isMatchSpurious( QuantConflictFind * p ); + bool isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ); + bool entailmentTest( QuantConflictFind * p, Node lit, bool chEnt = true ); + bool completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue = false ); + void revertMatch( std::vector< int >& assigned ); + void debugPrintMatch( const char * c ); + bool isConstrainedVar( int v ); +public: + void getMatch( std::vector< Node >& terms ); +}; + +class QuantConflictFind : public QuantifiersModule +{ + friend class MatchGen; + friend class QuantInfo; + typedef context::CDChunkList<Node> NodeList; + typedef context::CDHashMap<Node, bool, NodeHashFunction> NodeBoolMap; +private: + context::CDO< bool > d_conflict; + std::vector< Node > d_quant_order; + std::map< Kind, Node > d_zero; + //for storing nodes created during t-constraint solving (prevents memory leaks) + std::vector< Node > d_tempCache; +private: + std::map< Node, Node > d_op_node; + int d_fid_count; + std::map< Node, int > d_fid; + Node mkEqNode( Node a, Node b ); +public: //for ground terms + Node d_true; + Node d_false; + TNode getZero( Kind k ); +private: + Node evaluateTerm( Node n ); + int evaluate( Node n, bool pref = false, bool hasPref = false ); +private: + //currently asserted quantifiers + NodeList d_qassert; + std::map< Node, QuantInfo > d_qinfo; +private: //for equivalence classes + // type -> list(eqc) + std::map< TypeNode, std::vector< TNode > > d_eqcs; + std::map< TypeNode, Node > d_model_basis; +public: + enum { + effort_conflict, + effort_prop_eq, + effort_mc, + }; + short d_effort; + void setEffort( int e ) { d_effort = e; } + static short getMaxQcfEffort(); + bool areMatchEqual( TNode n1, TNode n2 ); + bool areMatchDisequal( TNode n1, TNode n2 ); +public: + QuantConflictFind( QuantifiersEngine * qe, context::Context* c ); + ~QuantConflictFind() throw() {} + /** register quantifier */ + void registerQuantifier( Node q ); +public: + /** assert quantifier */ + void assertNode( Node q ); + /** new node */ + void newEqClass( Node n ); + /** merge */ + void merge( Node a, Node b ); + /** assert disequal */ + void assertDisequal( Node a, Node b ); + /** needs check */ + bool needsCheck( Theory::Effort level ); + /** reset round */ + void reset_round( Theory::Effort level ); + /** check */ + void check( Theory::Effort level, unsigned quant_e ); +private: + bool d_needs_computeRelEqr; +public: + void computeRelevantEqr(); +private: + void debugPrint( const char * c ); + //for debugging + std::vector< Node > d_quants; + std::map< Node, int > d_quant_id; + void debugPrintQuant( const char * c, Node q ); + void debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum = true ); +public: + /** statistics class */ + class Statistics { + public: + IntStat d_inst_rounds; + IntStat d_conflict_inst; + IntStat d_prop_inst; + IntStat d_entailment_checks; + Statistics(); + ~Statistics(); + }; + Statistics d_statistics; + /** Identify this module */ + std::string identify() const { return "QcfEngine"; } +}; + +} +} +} + +#endif diff --git a/test/regress/regress0/fmf/fc-pigeonhole19.smt2 b/test/regress/regress0/fmf/fc-pigeonhole19.smt2 index 15c36682c..f145013d8 100644 --- a/test/regress/regress0/fmf/fc-pigeonhole19.smt2 +++ b/test/regress/regress0/fmf/fc-pigeonhole19.smt2 @@ -1,20 +1,20 @@ -(set-logic UFC)
-(set-info :status unsat)
-
-(declare-sort P 0)
-(declare-sort H 0)
-
-(declare-fun p () P)
-(declare-fun h () H)
-
-; pigeonhole using native cardinality constraints
-(assert (fmf.card p 19))
-(assert (not (fmf.card p 18)))
-(assert (fmf.card h 18))
-(assert (not (fmf.card h 17)))
-
-; each pigeon has different holes
-(declare-fun f (P) H)
-(assert (forall ((p1 P) (p2 P)) (=> (not (= p1 p2)) (not (= (f p1) (f p2))))))
-
+(set-logic UFC) +(set-info :status unsat) + +(declare-sort P 0) +(declare-sort H 0) + +(declare-fun p () P) +(declare-fun h () H) + +; pigeonhole using native cardinality constraints +(assert (fmf.card p 19)) +(assert (not (fmf.card p 18))) +(assert (fmf.card h 18)) +(assert (not (fmf.card h 17))) + +; each pigeon has different holes +(declare-fun f (P) H) +(assert (forall ((p1 P) (p2 P)) (=> (not (= p1 p2)) (not (= (f p1) (f p2)))))) + (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/fmf/fc-unsat-pent.smt2 b/test/regress/regress0/fmf/fc-unsat-pent.smt2 index f1721cb04..2d4000e6e 100644 --- a/test/regress/regress0/fmf/fc-unsat-pent.smt2 +++ b/test/regress/regress0/fmf/fc-unsat-pent.smt2 @@ -1,20 +1,20 @@ -(set-logic QF_UFC)
-(set-info :status unsat)
-
-(declare-sort U 0)
-
-(declare-fun a () U)
-(declare-fun b () U)
-(declare-fun c () U)
-(declare-fun d () U)
-(declare-fun e () U)
-
-(assert (not (= a b)))
-(assert (not (= b c)))
-(assert (not (= c d)))
-(assert (not (= d e)))
-(assert (not (= e a)))
-
-(assert (fmf.card c 2))
-
+(set-logic QF_UFC) +(set-info :status unsat) + +(declare-sort U 0) + +(declare-fun a () U) +(declare-fun b () U) +(declare-fun c () U) +(declare-fun d () U) +(declare-fun e () U) + +(assert (not (= a b))) +(assert (not (= b c))) +(assert (not (= c d))) +(assert (not (= d e))) +(assert (not (= e a))) + +(assert (fmf.card c 2)) + (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/fmf/fc-unsat-tot-2.smt2 b/test/regress/regress0/fmf/fc-unsat-tot-2.smt2 index d946974ed..0d438f718 100644 --- a/test/regress/regress0/fmf/fc-unsat-tot-2.smt2 +++ b/test/regress/regress0/fmf/fc-unsat-tot-2.smt2 @@ -1,14 +1,14 @@ -(set-logic UFC)
-(set-info :status unsat)
-
-(declare-sort U 0)
-
-(declare-fun a () U)
-(declare-fun b () U)
-(declare-fun c () U)
-
-(assert (not (fmf.card a 2)))
-
-(assert (forall ((x U)) (or (= x a) (= x b))))
-
+(set-logic UFC) +(set-info :status unsat) + +(declare-sort U 0) + +(declare-fun a () U) +(declare-fun b () U) +(declare-fun c () U) + +(assert (not (fmf.card a 2))) + +(assert (forall ((x U)) (or (= x a) (= x b)))) + (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/quantifiers/simp-typ-test.smt2 b/test/regress/regress0/quantifiers/simp-typ-test.smt2 index 366559b9d..380a66aac 100644 --- a/test/regress/regress0/quantifiers/simp-typ-test.smt2 +++ b/test/regress/regress0/quantifiers/simp-typ-test.smt2 @@ -1,7 +1,7 @@ -(set-logic UFLIRA)
-(set-info :status unsat)
-; ensure that E-matching matches on sub-types
-(declare-fun P (Real) Bool)
-(assert (forall ((x Real)) (P x)))
-(assert (not (P 5)))
+(set-logic UFLIRA) +(set-info :status unsat) +; ensure that E-matching matches on sub-types +(declare-fun P (Real) Bool) +(assert (forall ((x Real)) (P x))) +(assert (not (P 5))) (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/strings/at001.smt2 b/test/regress/regress0/strings/at001.smt2 index 616189d96..2ecbcc993 100644 --- a/test/regress/regress0/strings/at001.smt2 +++ b/test/regress/regress0/strings/at001.smt2 @@ -1,12 +1,12 @@ -(set-logic QF_S)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun i () Int)
-
-(assert (= (str.at x i) "b"))
-(assert (and (>= i 4) (< i (str.len x))))
-(assert (< (str.len x) 7))
-(assert (> (str.len x) 2))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun i () Int) + +(assert (= (str.at x i) "b")) +(assert (and (>= i 4) (< i (str.len x)))) +(assert (< (str.len x) 7)) +(assert (> (str.len x) 2)) + +(check-sat) diff --git a/test/regress/regress0/strings/bug001.smt2 b/test/regress/regress0/strings/bug001.smt2 index 49568329e..cdeebd20b 100644 --- a/test/regress/regress0/strings/bug001.smt2 +++ b/test/regress/regress0/strings/bug001.smt2 @@ -1,15 +1,15 @@ -(set-logic QF_S)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun y () String)
-(declare-fun z () String)
-
-(assert (= "\x4a" x))
-(assert (= "\x6a" y))
-
-(assert (= "\x4A" z))
-
-(assert (= x z))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +(assert (= "\x4a" x)) +(assert (= "\x6a" y)) + +(assert (= "\x4A" z)) + +(assert (= x z)) + +(check-sat) diff --git a/test/regress/regress0/strings/bug002.smt2 b/test/regress/regress0/strings/bug002.smt2 index 15d1ea5a2..f8a481e14 100644 --- a/test/regress/regress0/strings/bug002.smt2 +++ b/test/regress/regress0/strings/bug002.smt2 @@ -1,10 +1,10 @@ -(set-logic ASLIA)
-(set-info :smt-lib-version 2.0)
-(set-option :strings-exp true)
-(set-info :status sat)
-
-; regex = [\*-,\t\*-\|](.{6,}()?)+
-(define-fun strinre ((?s String)) Bool (str.in.re ?s (re.union re.nostr (re.++ (str.to.re "") (str.to.re "") (re.union re.nostr (re.range "*" ",") (str.to.re "\t") (re.range "*" "|") ) (re.+ (re.union re.nostr (re.++ (str.to.re "") (str.to.re "") (re.loop re.allchar 6 ) (re.opt (re.union re.nostr (re.++ (str.to.re "") (str.to.re "") ) ) ) ) ) ) ) ) ) )
-(assert (not (strinre "6O\1\127\n?")))
-
+(set-logic ASLIA) +(set-info :smt-lib-version 2.0) +(set-option :strings-exp true) +(set-info :status sat) + +; regex = [\*-,\t\*-\|](.{6,}()?)+ +(define-fun strinre ((?s String)) Bool (str.in.re ?s (re.union re.nostr (re.++ (str.to.re "") (str.to.re "") (re.union re.nostr (re.range "*" ",") (str.to.re "\t") (re.range "*" "|") ) (re.+ (re.union re.nostr (re.++ (str.to.re "") (str.to.re "") (re.loop re.allchar 6 ) (re.opt (re.union re.nostr (re.++ (str.to.re "") (str.to.re "") ) ) ) ) ) ) ) ) ) ) +(assert (not (strinre "6O\1\127\n?"))) + (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/strings/escchar.smt2 b/test/regress/regress0/strings/escchar.smt2 index aa2afb7e4..67a184ade 100644 --- a/test/regress/regress0/strings/escchar.smt2 +++ b/test/regress/regress0/strings/escchar.smt2 @@ -1,12 +1,12 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-info :smt-lib-version 2.0)
-
-(declare-fun x () String)
-(declare-const I Int)
-
-(assert (= x "\0\1\2\3\04\005\x06\7\8\9ABC\\\"\t\a\b"))
-(assert (= I (str.len x)))
-
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) +(set-info :smt-lib-version 2.0) + +(declare-fun x () String) +(declare-const I Int) + +(assert (= x "\0\1\2\3\04\005\x06\7\8\9ABC\\\"\t\a\b")) +(assert (= I (str.len x))) + + +(check-sat) diff --git a/test/regress/regress0/strings/escchar_25.smt2 b/test/regress/regress0/strings/escchar_25.smt2 index f48995344..af93a7ae5 100644 --- a/test/regress/regress0/strings/escchar_25.smt2 +++ b/test/regress/regress0/strings/escchar_25.smt2 @@ -1,12 +1,12 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-info :smt-lib-version 2.5)
-
-(declare-fun x () String)
-(declare-const I Int)
-
-(assert (= x "\0\1\2\3\04\005\x06\7\8\9ABC\\""\t\a\b"))
-(assert (= I (str.len x)))
-
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) +(set-info :smt-lib-version 2.5) + +(declare-fun x () String) +(declare-const I Int) + +(assert (= x "\0\1\2\3\04\005\x06\7\8\9ABC\\""\t\a\b")) +(assert (= I (str.len x))) + + +(check-sat) diff --git a/test/regress/regress0/strings/fmf001.smt2 b/test/regress/regress0/strings/fmf001.smt2 index 05bbab586..6081c8e06 100644 --- a/test/regress/regress0/strings/fmf001.smt2 +++ b/test/regress/regress0/strings/fmf001.smt2 @@ -1,20 +1,20 @@ -(set-logic QF_S)
-(set-option :strings-exp true)
-(set-option :strings-fmf true)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun y () String)
-
-(assert (str.in.re x
- (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))
- ))
-
-(assert (str.in.re y
- (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))
- ))
-
-(assert (not (= x y)))
-(assert (= (str.len x) (str.len y)))
-
-(check-sat)
+(set-logic QF_S) +(set-option :strings-exp true) +(set-option :strings-fmf true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) + +(assert (str.in.re x + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (str.in.re y + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (not (= x y))) +(assert (= (str.len x) (str.len y))) + +(check-sat) diff --git a/test/regress/regress0/strings/fmf002.smt2 b/test/regress/regress0/strings/fmf002.smt2 index 1d41b1085..d52dae2d2 100644 --- a/test/regress/regress0/strings/fmf002.smt2 +++ b/test/regress/regress0/strings/fmf002.smt2 @@ -1,17 +1,17 @@ -(set-logic QF_S)
-(set-option :strings-exp true)
-(set-option :strings-fmf true)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun y () String)
-(declare-fun z () String)
-
-(assert (str.in.re x
- (re.+ (re.range "a" "c"))
- ))
-
-(assert (= x (str.++ y "c" z "b")))
-(assert (> (str.len z) 1))
-
-(check-sat)
+(set-logic QF_S) +(set-option :strings-exp true) +(set-option :strings-fmf true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +(assert (str.in.re x + (re.+ (re.range "a" "c")) + )) + +(assert (= x (str.++ y "c" z "b"))) +(assert (> (str.len z) 1)) + +(check-sat) diff --git a/test/regress/regress0/strings/leadingzero001.smt2 b/test/regress/regress0/strings/leadingzero001.smt2 index ae61b5f5b..2889348c1 100644 --- a/test/regress/regress0/strings/leadingzero001.smt2 +++ b/test/regress/regress0/strings/leadingzero001.smt2 @@ -1,11 +1,11 @@ -(set-logic QF_S)
-(set-option :strings-exp true)
-(set-info :status sat)
-
-(declare-fun Y () String)
-
-(assert (= Y "0001"))
-;(assert (= (str.to.int Y) (- 1)))
-(assert (= (str.to.int Y) 1))
-
-(check-sat)
+(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun Y () String) + +(assert (= Y "0001")) +;(assert (= (str.to.int Y) (- 1))) +(assert (= (str.to.int Y) 1)) + +(check-sat) diff --git a/test/regress/regress0/strings/loop008.smt2 b/test/regress/regress0/strings/loop008.smt2 index 113577e48..f84ba442b 100644 --- a/test/regress/regress0/strings/loop008.smt2 +++ b/test/regress/regress0/strings/loop008.smt2 @@ -1,10 +1,10 @@ -(set-logic QF_S)
-(set-option :strings-exp true)
-(set-info :status sat)
-
-(declare-fun x () String)
-
-(assert (= (str.++ x "ab") (str.++ "ba" x)))
-(assert (> (str.len x) 5))
-
-(check-sat)
+(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) + +(assert (= (str.++ x "ab") (str.++ "ba" x))) +(assert (> (str.len x) 5)) + +(check-sat) diff --git a/test/regress/regress0/strings/loop009.smt2 b/test/regress/regress0/strings/loop009.smt2 index 9ccc6de6e..30fc6cebc 100644 --- a/test/regress/regress0/strings/loop009.smt2 +++ b/test/regress/regress0/strings/loop009.smt2 @@ -1,10 +1,10 @@ -(set-logic QF_S)
-(set-option :strings-exp true)
-(set-info :status sat)
-
-(declare-fun x () String)
-
-(assert (= (str.++ x "aa") (str.++ "aa" x)))
-(assert (= (str.len x) 7))
-
-(check-sat)
+(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) + +(assert (= (str.++ x "aa") (str.++ "aa" x))) +(assert (= (str.len x) 7)) + +(check-sat) diff --git a/test/regress/regress0/strings/regexp001.smt2 b/test/regress/regress0/strings/regexp001.smt2 index 6a2044ea8..62c142d1d 100644 --- a/test/regress/regress0/strings/regexp001.smt2 +++ b/test/regress/regress0/strings/regexp001.smt2 @@ -1,13 +1,13 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-option :strings-exp true)
-
-(declare-fun x () String)
-
-(assert (str.in.re x
- (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))
- ))
-
-(assert (= (str.len x) 3))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun x () String) + +(assert (str.in.re x + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (= (str.len x) 3)) + +(check-sat) diff --git a/test/regress/regress0/strings/regexp002.smt2 b/test/regress/regress0/strings/regexp002.smt2 index 8c29ccb38..a8bd2187a 100644 --- a/test/regress/regress0/strings/regexp002.smt2 +++ b/test/regress/regress0/strings/regexp002.smt2 @@ -1,24 +1,24 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-option :strings-exp true)
-; this option requires user to check whether the constraint is in the fragment
-; currently we do not provide only positive membership constraint checking
-; if users use this option but the constraint is not in this fragment, the result will fail
-(set-option :strings-inm true)
-
-(declare-fun x () String)
-(declare-fun y () String)
-
-(assert (str.in.re x
- (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))
- ))
-
-(assert (str.in.re y
- (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))
- ))
-
-(assert (not (= x y)))
-(assert (= (str.len x) (str.len y)))
-(assert (= (str.len y) 3))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) +; this option requires user to check whether the constraint is in the fragment +; currently we do not provide only positive membership constraint checking +; if users use this option but the constraint is not in this fragment, the result will fail +(set-option :strings-inm true) + +(declare-fun x () String) +(declare-fun y () String) + +(assert (str.in.re x + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (str.in.re y + (re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") )) + )) + +(assert (not (= x y))) +(assert (= (str.len x) (str.len y))) +(assert (= (str.len y) 3)) + +(check-sat) diff --git a/test/regress/regress0/strings/regexp003.smt2 b/test/regress/regress0/strings/regexp003.smt2 index 601689958..7696838fe 100644 --- a/test/regress/regress0/strings/regexp003.smt2 +++ b/test/regress/regress0/strings/regexp003.smt2 @@ -1,13 +1,13 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-option :strings-exp true)
-
-(declare-const s String)
-
-(assert (str.in.re s (re.inter
- (re.++ (str.to.re "a") (re.* (str.to.re "b"))
- (re.inter (str.to.re "c") (re.* (str.to.re "c"))))
- (re.++ (str.to.re "a") (re.* (str.to.re "b")) (re.* (str.to.re "c")))
- )))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-const s String) + +(assert (str.in.re s (re.inter + (re.++ (str.to.re "a") (re.* (str.to.re "b")) + (re.inter (str.to.re "c") (re.* (str.to.re "c")))) + (re.++ (str.to.re "a") (re.* (str.to.re "b")) (re.* (str.to.re "c"))) + ))) + +(check-sat) diff --git a/test/regress/regress0/strings/reloop.smt2 b/test/regress/regress0/strings/reloop.smt2 index 39b2b76b1..9915504ae 100644 --- a/test/regress/regress0/strings/reloop.smt2 +++ b/test/regress/regress0/strings/reloop.smt2 @@ -1,18 +1,18 @@ -(set-logic QF_S)
-(set-option :strings-exp true)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun y () String)
-(declare-fun z () String)
-(declare-fun w () String)
-
-(assert (str.in.re x (re.loop (str.to.re "a") 5)))
-(assert (str.in.re y (re.loop (str.to.re "b") 2 5)))
-(assert (str.in.re z (re.loop (str.to.re "c") 5)))
-(assert (> (str.len z) 7))
-(assert (str.in.re w (re.loop (str.to.re "b") 2 7)))
-(assert (> (str.len w) 2))
-(assert (< (str.len w) 5))
-
-(check-sat)
+(set-logic QF_S) +(set-option :strings-exp true) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun w () String) + +(assert (str.in.re x (re.loop (str.to.re "a") 5))) +(assert (str.in.re y (re.loop (str.to.re "b") 2 5))) +(assert (str.in.re z (re.loop (str.to.re "c") 5))) +(assert (> (str.len z) 7)) +(assert (str.in.re w (re.loop (str.to.re "b") 2 7))) +(assert (> (str.len w) 2)) +(assert (< (str.len w) 5)) + +(check-sat) diff --git a/test/regress/regress0/strings/str006.smt2 b/test/regress/regress0/strings/str006.smt2 index 592ef6a7f..2bdf9b1b5 100644 --- a/test/regress/regress0/strings/str006.smt2 +++ b/test/regress/regress0/strings/str006.smt2 @@ -1,14 +1,14 @@ -(set-logic QF_S)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun y () String)
-(declare-fun z () String)
-
-;plandowski p469 1
-(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))
-(assert (= z (str.++ x y)))
-(assert (not (= (str.++ x "a") (str.++ "a" x))))
-
-(check-sat)
-
+(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) + +;plandowski p469 1 +(assert (= (str.++ x "ab" y) (str.++ y "ba" z))) +(assert (= z (str.++ x y))) +(assert (not (= (str.++ x "a") (str.++ "a" x)))) + +(check-sat) + diff --git a/test/regress/regress0/strings/str007.smt2 b/test/regress/regress0/strings/str007.smt2 index 0ca2ec4c3..a7173701a 100644 --- a/test/regress/regress0/strings/str007.smt2 +++ b/test/regress/regress0/strings/str007.smt2 @@ -1,13 +1,13 @@ -(set-logic QF_S)
-(set-info :status unsat)
-
-(declare-fun x () String)
-(declare-fun y () String)
-
-
-(assert (or (= x y) (= x y)))
-
-(assert (= (str.++ x "ba") (str.++ "ab" x)))
-(assert (= (str.++ y "ab") (str.++ "ab" y)))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status unsat) + +(declare-fun x () String) +(declare-fun y () String) + + +(assert (or (= x y) (= x y))) + +(assert (= (str.++ x "ba") (str.++ "ab" x))) +(assert (= (str.++ y "ab") (str.++ "ab" y))) + +(check-sat) diff --git a/test/regress/regress0/strings/substr001.smt2 b/test/regress/regress0/strings/substr001.smt2 index bdfa33afb..78f3ffee7 100644 --- a/test/regress/regress0/strings/substr001.smt2 +++ b/test/regress/regress0/strings/substr001.smt2 @@ -1,16 +1,16 @@ -(set-logic QF_S)
-(set-info :status sat)
-
-(declare-fun x () String)
-(declare-fun i1 () Int)
-(declare-fun i2 () Int)
-(declare-fun i3 () Int)
-(declare-fun i4 () Int)
-
-(assert (and (>= i1 0) (>= i2 0) (< (+ i1 i2) (str.len x))))
-(assert (and (>= i3 0) (>= i4 0) (< (+ i3 i4) (str.len x))))
-(assert (= "efg" (str.substr x i1 i2) ) )
-(assert (= "bef" (str.substr x i3 i4) ) )
-(assert (> (str.len x) 5))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) + +(declare-fun x () String) +(declare-fun i1 () Int) +(declare-fun i2 () Int) +(declare-fun i3 () Int) +(declare-fun i4 () Int) + +(assert (and (>= i1 0) (>= i2 0) (< (+ i1 i2) (str.len x)))) +(assert (and (>= i3 0) (>= i4 0) (< (+ i3 i4) (str.len x)))) +(assert (= "efg" (str.substr x i1 i2) ) ) +(assert (= "bef" (str.substr x i3 i4) ) ) +(assert (> (str.len x) 5)) + +(check-sat) diff --git a/test/regress/regress0/strings/type001.smt2 b/test/regress/regress0/strings/type001.smt2 index ca93b00e5..77eabcccc 100644 --- a/test/regress/regress0/strings/type001.smt2 +++ b/test/regress/regress0/strings/type001.smt2 @@ -1,21 +1,21 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-option :strings-exp true)
-
-(declare-fun x () String)
-(declare-fun y () String)
-(declare-fun i () Int)
-(declare-fun j () Int)
-(declare-fun z () String)
-
-;big num test
-(assert (= x (int.to.str 4785582390527685649)))
-;should be ""
-(assert (= y (int.to.str (- 9))))
-
-;big num
-(assert (= i (str.to.int "783914785582390527685649")))
-;should be -1
-(assert (= j (str.to.int "-783914785582390527685649")))
-
+(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun i () Int) +(declare-fun j () Int) +(declare-fun z () String) + +;big num test +(assert (= x (int.to.str 4785582390527685649))) +;should be "" +(assert (= y (int.to.str (- 9)))) + +;big num +(assert (= i (str.to.int "783914785582390527685649"))) +;should be -1 +(assert (= j (str.to.int "-783914785582390527685649"))) + (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/strings/type002.smt2 b/test/regress/regress0/strings/type002.smt2 index cbad2226a..296057a76 100644 --- a/test/regress/regress0/strings/type002.smt2 +++ b/test/regress/regress0/strings/type002.smt2 @@ -1,18 +1,18 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-option :strings-exp true)
-
-(declare-fun x () String)
-(declare-fun y () String)
-(declare-fun z () String)
-(declare-fun i () Int)
-
-(assert (>= i 420))
-(assert (= x (u16.to.str i)))
-(assert (= x (str.++ y "0" z)))
-(assert (not (= y "")))
-(assert (not (= z "")))
-
-
-
+(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun x () String) +(declare-fun y () String) +(declare-fun z () String) +(declare-fun i () Int) + +(assert (>= i 420)) +(assert (= x (u16.to.str i))) +(assert (= x (str.++ y "0" z))) +(assert (not (= y ""))) +(assert (not (= z ""))) + + + (check-sat)
\ No newline at end of file diff --git a/test/regress/regress0/strings/type003.smt2 b/test/regress/regress0/strings/type003.smt2 index b8f0ac5ae..c2d4792cc 100644 --- a/test/regress/regress0/strings/type003.smt2 +++ b/test/regress/regress0/strings/type003.smt2 @@ -1,12 +1,12 @@ -(set-logic QF_S)
-(set-info :status sat)
-(set-option :strings-exp true)
-
-(declare-fun i () Int)
-(declare-fun s () String)
-
-(assert (< 67 (str.to.int s)))
-(assert (= (str.len s) 2))
-(assert (not (= s "68")))
-
-(check-sat)
+(set-logic QF_S) +(set-info :status sat) +(set-option :strings-exp true) + +(declare-fun i () Int) +(declare-fun s () String) + +(assert (< 67 (str.to.int s))) +(assert (= (str.len s) 2)) +(assert (not (= s "68"))) + +(check-sat) |