From 87a02d4d2a8b95fcf7a63335080116940f668514 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 12:11:20 -0700 Subject: [PATCH 01/79] Delete unnecessary 3rd party implementation of `std::optional`. --- .../com_github_tartanllama_optional/COPYING | 121 ----------------- .../com_github_tartanllama_optional/README.md | 127 ------------------ 2 files changed, 248 deletions(-) delete mode 100644 src/third_party/com_github_tartanllama_optional/COPYING delete mode 100644 src/third_party/com_github_tartanllama_optional/README.md diff --git a/src/third_party/com_github_tartanllama_optional/COPYING b/src/third_party/com_github_tartanllama_optional/COPYING deleted file mode 100644 index 0e259d42c..000000000 --- a/src/third_party/com_github_tartanllama_optional/COPYING +++ /dev/null @@ -1,121 +0,0 @@ -Creative Commons Legal Code - -CC0 1.0 Universal - - CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE - LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN - ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS - INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES - REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS - PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM - THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED - HEREUNDER. - -Statement of Purpose - -The laws of most jurisdictions throughout the world automatically confer -exclusive Copyright and Related Rights (defined below) upon the creator -and subsequent owner(s) (each and all, an "owner") of an original work of -authorship and/or a database (each, a "Work"). - -Certain owners wish to permanently relinquish those rights to a Work for -the purpose of contributing to a commons of creative, cultural and -scientific works ("Commons") that the public can reliably and without fear -of later claims of infringement build upon, modify, incorporate in other -works, reuse and redistribute as freely as possible in any form whatsoever -and for any purposes, including without limitation commercial purposes. -These owners may contribute to the Commons to promote the ideal of a free -culture and the further production of creative, cultural and scientific -works, or to gain reputation or greater distribution for their Work in -part through the use and efforts of others. - -For these and/or other purposes and motivations, and without any -expectation of additional consideration or compensation, the person -associating CC0 with a Work (the "Affirmer"), to the extent that he or she -is an owner of Copyright and Related Rights in the Work, voluntarily -elects to apply CC0 to the Work and publicly distribute the Work under its -terms, with knowledge of his or her Copyright and Related Rights in the -Work and the meaning and intended legal effect of CC0 on those rights. - -1. Copyright and Related Rights. A Work made available under CC0 may be -protected by copyright and related or neighboring rights ("Copyright and -Related Rights"). Copyright and Related Rights include, but are not -limited to, the following: - - i. the right to reproduce, adapt, distribute, perform, display, - communicate, and translate a Work; - ii. moral rights retained by the original author(s) and/or performer(s); -iii. publicity and privacy rights pertaining to a person's image or - likeness depicted in a Work; - iv. rights protecting against unfair competition in regards to a Work, - subject to the limitations in paragraph 4(a), below; - v. rights protecting the extraction, dissemination, use and reuse of data - in a Work; - vi. database rights (such as those arising under Directive 96/9/EC of the - European Parliament and of the Council of 11 March 1996 on the legal - protection of databases, and under any national implementation - thereof, including any amended or successor version of such - directive); and -vii. other similar, equivalent or corresponding rights throughout the - world based on applicable law or treaty, and any national - implementations thereof. - -2. Waiver. To the greatest extent permitted by, but not in contravention -of, applicable law, Affirmer hereby overtly, fully, permanently, -irrevocably and unconditionally waives, abandons, and surrenders all of -Affirmer's Copyright and Related Rights and associated claims and causes -of action, whether now known or unknown (including existing as well as -future claims and causes of action), in the Work (i) in all territories -worldwide, (ii) for the maximum duration provided by applicable law or -treaty (including future time extensions), (iii) in any current or future -medium and for any number of copies, and (iv) for any purpose whatsoever, -including without limitation commercial, advertising or promotional -purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each -member of the public at large and to the detriment of Affirmer's heirs and -successors, fully intending that such Waiver shall not be subject to -revocation, rescission, cancellation, termination, or any other legal or -equitable action to disrupt the quiet enjoyment of the Work by the public -as contemplated by Affirmer's express Statement of Purpose. - -3. Public License Fallback. Should any part of the Waiver for any reason -be judged legally invalid or ineffective under applicable law, then the -Waiver shall be preserved to the maximum extent permitted taking into -account Affirmer's express Statement of Purpose. In addition, to the -extent the Waiver is so judged Affirmer hereby grants to each affected -person a royalty-free, non transferable, non sublicensable, non exclusive, -irrevocable and unconditional license to exercise Affirmer's Copyright and -Related Rights in the Work (i) in all territories worldwide, (ii) for the -maximum duration provided by applicable law or treaty (including future -time extensions), (iii) in any current or future medium and for any number -of copies, and (iv) for any purpose whatsoever, including without -limitation commercial, advertising or promotional purposes (the -"License"). The License shall be deemed effective as of the date CC0 was -applied by Affirmer to the Work. Should any part of the License for any -reason be judged legally invalid or ineffective under applicable law, such -partial invalidity or ineffectiveness shall not invalidate the remainder -of the License, and in such case Affirmer hereby affirms that he or she -will not (i) exercise any of his or her remaining Copyright and Related -Rights in the Work or (ii) assert any associated claims and causes of -action with respect to the Work, in either case contrary to Affirmer's -express Statement of Purpose. - -4. Limitations and Disclaimers. - - a. No trademark or patent rights held by Affirmer are waived, abandoned, - surrendered, licensed or otherwise affected by this document. - b. Affirmer offers the Work as-is and makes no representations or - warranties of any kind concerning the Work, express, implied, - statutory or otherwise, including without limitation warranties of - title, merchantability, fitness for a particular purpose, non - infringement, or the absence of latent or other defects, accuracy, or - the present or absence of errors, whether or not discoverable, all to - the greatest extent permissible under applicable law. - c. Affirmer disclaims responsibility for clearing rights of other persons - that may apply to the Work or any use thereof, including without - limitation any person's Copyright and Related Rights in the Work. - Further, Affirmer disclaims responsibility for obtaining any necessary - consents, permissions or other rights required for any use of the - Work. - d. Affirmer understands and acknowledges that Creative Commons is not a - party to this document and has no duty or obligation with respect to - this CC0 or use of the Work. diff --git a/src/third_party/com_github_tartanllama_optional/README.md b/src/third_party/com_github_tartanllama_optional/README.md deleted file mode 100644 index 90d30002f..000000000 --- a/src/third_party/com_github_tartanllama_optional/README.md +++ /dev/null @@ -1,127 +0,0 @@ -# optional -Single header implementation of `std::optional` with functional-style extensions and support for references. - -Clang + GCC: [![Linux Build Status](https://travis-ci.org/TartanLlama/optional.png?branch=master)](https://travis-ci.org/TartanLlama/optional) -MSVC: [![Windows Build Status](https://ci.appveyor.com/api/projects/status/k5x00xa11y3s5wsg?svg=true)](https://ci.appveyor.com/project/TartanLlama/optional) - -`std::optional` is the preferred way to represent an object which may or may not have a value. Unfortunately, chaining together many computations which may or may not produce a value can be verbose, as empty-checking code will be mixed in with the actual programming logic. This implementation provides a number of utilities to make coding with `optional` cleaner. - -For example, instead of writing this code: - -```c++ -std::optional get_cute_cat (const image& img) { - auto cropped = crop_to_cat(img); - if (!cropped) { - return std::nullopt; - } - - auto with_tie = add_bow_tie(*cropped); - if (!with_tie) { - return std::nullopt; - } - - auto with_sparkles = make_eyes_sparkle(*with_tie); - if (!with_sparkles) { - return std::nullopt; - } - - return add_rainbow(make_smaller(*with_sparkles)); -} -``` - -You can do this: - -```c++ -tl::optional get_cute_cat (const image& img) { - return crop_to_cat(img) - .and_then(add_bow_tie) - .and_then(make_eyes_sparkle) - .map(make_smaller) - .map(add_rainbow); -} -``` - -Full documentation available at [optional.tartanllama.xyz](https://optional.tartanllama.xyz) - -The interface is the same as `std::optional`, but the following member functions are also defined. Explicit types are for clarity. - -- `map`: carries out some operation on the stored object if there is one. - * `tl::optional s = opt_string.map(&std::string::size);` -- `and_then`: like `map`, but for operations which return a `tl::optional`. - * `tl::optional stoi (const std::string& s);` - * `tl::optional i = opt_string.and_then(stoi);` -- `or_else`: calls some function if there is no value stored. - * `opt.or_else([] { throw std::runtime_error{"oh no"}; });` -- `map_or`: carries out a `map` if there is a value, otherwise returns a default value. - * `tl::optional s = opt_string.map_or(&std::string::size, 0);` -- `map_or_else`: carries out a `map` if there is a value, otherwise returns the result of a given default function. - * `std::size_t get_default();` - * `tl::optional s = opt_string.map_or(&std::string::size, get_default);` -- `conjunction`: returns the argument if a value is stored in the optional, otherwise an empty optional. - * `tl::make_optional(42).conjunction(13); //13` - * `tl::optional){}.conjunction(13); //empty` -- `disjunction`: returns the argument if the optional is empty, otherwise the current value. - * `tl::make_optional(42).disjunction(13); //42` - * `tl::optional{}.disjunction(13); //13` -- `take`: returns the current value, leaving the optional empty. - * `opt_string.take().map(&std::string::size); //opt_string now empty;` - -In addition to those member functions, optional references are also supported: - -```c++ -int i = 42; -tl::optional o = i; -*o == 42; //true -i = 12; -*o = 12; //true -&*o == &i; //true -``` - -Assignment has rebind semantics rather than assign-through semantics: - -```c++ -int j = 8; -o = j; - -&*o == &j; //true -``` - -### Compiler support - -Tested on: - - -- Linux - * clang 6.0.1 - * clang 5.0.2 - * clang 4.0.1 - * clang 3.9 - * clang 3.8 - * clang 3.7 - * clang 3.6 - * clang 3.5 - * g++ 8.0.1 - * g++ 7.3 - * g++ 6.4 - * g++ 5.5 - * g++ 4.9 - * g++ 4.8 -- Windows - * MSVC 2015 - * MSVC 2017 - -### Dependencies - -Requires [Standardese](https://github.com/foonathan/standardese) for generating documentation. - -Requires [Catch](https://github.com/philsquared/Catch) for testing. This is bundled in the test directory. - -### Standards Proposal - -This library also serves as an implementation of WG21 standards paper [P0798R0: Monadic operations for std::optional](https://wg21.tartanllama.xyz/monadic-optional). This paper proposes adding `map`, `and_then`, and `or_else` to `std::optional`. - ----------- - -[![CC0](http://i.creativecommons.org/p/zero/1.0/88x31.png)]("http://creativecommons.org/publicdomain/zero/1.0/") - -To the extent possible under law, [Simon Brand](https://twitter.com/TartanLlama) has waived all copyright and related or neighboring rights to the `optional` library. This work is published from: United Kingdom. From fc1a28e8b13490d6bff9ec4f17490c0fcdf31b04 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 12:12:49 -0700 Subject: [PATCH 02/79] Updated IDE configuration files --- .idea/dreal4-cmake.iml | 8 +- .idea/editor.xml | 483 +++++++++++++++++++++-------------------- .idea/misc.xml | 4 + 3 files changed, 256 insertions(+), 239 deletions(-) diff --git a/.idea/dreal4-cmake.iml b/.idea/dreal4-cmake.iml index f08604bb6..bd985f000 100644 --- a/.idea/dreal4-cmake.iml +++ b/.idea/dreal4-cmake.iml @@ -1,2 +1,8 @@ - \ No newline at end of file + + + + + + + \ No newline at end of file diff --git a/.idea/editor.xml b/.idea/editor.xml index 55d1bc11a..2b1d539e7 100644 --- a/.idea/editor.xml +++ b/.idea/editor.xml @@ -1,483 +1,490 @@ + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index 89bac425a..808f1d1a0 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,5 +1,8 @@ + + @@ -7,6 +10,7 @@ + From 41822491ba7c396acdbf1e12fffca9bad80c89fe Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:21:37 -0700 Subject: [PATCH 03/79] Add statistics counters to pattern matching code. --- .../pattern_matching/pattern_matching_trie.h | 59 ++++++++++++-- .../pattern_matching_trie_general.cc | 79 ++++++++++++------- src/dreal/util/predicate_normalizer.cc | 4 +- src/dreal/util/predicate_normalizer.h | 5 +- .../solver/test/pattern_matching_test.cc | 11 ++- 5 files changed, 116 insertions(+), 42 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index 3bd403105..2df822c5f 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -18,22 +18,60 @@ namespace dreal class PatternMatchingTrie { public: + typedef struct + { + unsigned misses; + unsigned partial_matches; + unsigned matches; + } matching_stats_t; + + static std::string matching_stats_csv_header(const std::string& prefix) { + std::ostringstream s; + s << prefix << "misses,"; + s << prefix << "partial_matches,"; + s << prefix << "matches"; + return s.str(); + } + using e_matches_vec = std::function; using f_matches_vec = std::function; - [[nodiscard]] std::vector, substitutions_map>> + [[nodiscard]] std::pair, substitutions_map>>, matching_stats_t> find_matches( - const std::set& literals + const std::vector& literals ) const; - [[nodiscard]] std::vector> find_matches( + + [[nodiscard]] std::pair>, matching_stats_t> find_matches( const Formula& f, - const substitutions_map& substitutions = {} + substitutions_map& substitutions ) const; - [[nodiscard]] std::vector> find_matches( - const Expression& f, - const substitutions_map& substitutions = {} + + [[nodiscard]] std::pair>, matching_stats_t> find_matches( + const Formula& f + ) const { + substitutions_map s; + return find_matches(f, s); + } + + [[nodiscard]] std::pair>, matching_stats_t> find_matches( + const Expression& e, + substitutions_map& substitutions ) const; + [[nodiscard]] std::pair>, matching_stats_t> find_matches( + const Expression& e + ) const { + substitutions_map s; + return find_matches(e, s); + } + + // ended up being completely useless :( + // uint64_t estimate_branches(const Formula& f); + // uint64_t estimate_branches(const Expression& e); + + // uint64_t estimate_branches(const Formula& f) const; + // uint64_t estimate_branches(const Expression& f) const; + void insert(const Formula& f); void insert(const Expression& f); @@ -262,6 +300,13 @@ namespace dreal const std::optional& is_terminal ); }; + + inline std::ostream& operator<<(std::ostream& os, const PatternMatchingTrie::matching_stats_t& stats) { + os << stats.misses << ','; + os << stats.partial_matches << ','; + os << stats.matches; + return os; + } } // namespace dreal diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index f7ab80459..fe193db9f 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -2,6 +2,8 @@ // Created by Kunal Sheth on 2/19/25. // +#include + #include "pattern_matching_trie.h" #include @@ -9,31 +11,32 @@ #include #include -#include "pattern_matching_trie.h" - namespace dreal { - std::vector, substitutions_map>> - PatternMatchingTrie::find_matches(const std::set& literals) const { - DREAL_LOG_INFO("Finding matches for literals: {}", !make_conjunction(literals)); - + std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> + PatternMatchingTrie::find_matches(const std::vector& literals) const { + matching_stats_t stats = {0}; std::vector matches_vec; std::vector, substitutions_map>> result; matches_vec.reserve(literals.size()); - const f_misses_vec misses = [](const auto& _) {}; + const f_misses_vec misses = [&](const auto& _) { + stats.misses++; + }; const f_partial_matches_vec partial_matches = PM_CONT_LAMBDA(n, s) { DREAL_LOG_ERROR("Unterminated partial matching?"); DREAL_UNREACHABLE(); // everything should AT LEAST match itself !?!?! }; const f_misses_vec all_literals_match = [&](const auto& s) { DREAL_ASSERT(matches_vec.size() == literals.size()); + // todo: GATE THIS USING THE SAME FLAG AS AUDIT MODE. // if (DREAL_LOG_DEBUG_ENABLED) - for (const auto& lit : matches_vec) { - DREAL_ASSERT(literals.count( - substitutions_map::apply_substitution(lit, s, false) - ) == 1); - } + // for (const auto& lit : matches_vec) { + // DREAL_ASSERT(literals.count( + // substitutions_map::apply_substitution(lit, s, false) + // ) == 1); + // } + stats.matches++; result.emplace_back(matches_vec, s); }; @@ -50,6 +53,7 @@ namespace dreal } auto it2 = it1; ++it2; + stats.partial_matches++; if (it2 == iend) all_literals_match(s2); else recMatchForm(*it2, f_root, s2, match_next_literal(it2), partial_matches, misses); matches_vec.pop_back(); @@ -58,50 +62,69 @@ namespace dreal substitutions_map substitutions; recMatchForm(*ibegin, f_root, substitutions, match_next_literal(ibegin), partial_matches, misses); - - return result; + DREAL_ASSERT(result.size() == stats.matches); + DREAL_LOG_INFO("Found {} matches with {} misses.", stats.matches, stats.misses); + // if (DREAL_LOG_INFO_ENABLED) { + // for (const auto& [matched_clause, _] : result) { + // std::ostringstream s; + // s << "!("; + // for (const auto& lit : matched_clause) s << '(' << lit << ") and "; + // s << ")"; + // DREAL_LOG_INFO("Match: {}", s.str()); + // } + // } + return {result, stats}; } - std::vector> PatternMatchingTrie::find_matches( + std::pair>, PatternMatchingTrie::matching_stats_t> + PatternMatchingTrie::find_matches( const Formula& f, - const substitutions_map& substitutions + substitutions_map& substitutions ) const { + const auto init_size = substitutions.size(); DREAL_LOG_TRACE("Finding matches for formula {}", fmt::streamed(f)); + matching_stats_t stats = {0}; std::vector> match_vec; - substitutions_map substitutions_copy = substitutions; recMatchForm( - f, f_root, substitutions_copy, + f, f_root, substitutions, PM_CONT_LAMBDA(m, s) { + stats.matches++; match_vec.emplace_back(m, s); }, PM_CONT_LAMBDA(n, s) { + stats.partial_matches++; DREAL_LOG_ERROR("Unterminated partial matching? Not sure if this should ever be reachable."); }, - [](const auto& s) {} + [&](const auto& s) { stats.misses++; } ); - DREAL_ASSERT(substitutions_copy == substitutions); - return match_vec; + DREAL_ASSERT(substitutions.size() == init_size); + return {match_vec, stats}; } - std::vector> PatternMatchingTrie::find_matches( + std::pair>, PatternMatchingTrie::matching_stats_t> + PatternMatchingTrie::find_matches( const Expression& e, - const substitutions_map& substitutions + substitutions_map& substitutions ) const { + const auto init_size = substitutions.size(); DREAL_LOG_TRACE("Finding matches for expression {}", fmt::streamed(e)); + substitutions_map empty; + matching_stats_t stats = {0}; std::vector> match_vec; - substitutions_map substitutions_copy = substitutions; recMatchExpr( - e, e_root, substitutions_copy, + e, e_root, substitutions, PM_CONT_LAMBDA(m, s) { + stats.matches++; match_vec.emplace_back(m, s); }, PM_CONT_LAMBDA(n, s) { + stats.partial_matches++; DREAL_LOG_ERROR("Unterminated partial matching? Not sure if this should ever be reachable."); }, - [](const auto& s) {} + [&](const auto& s) { stats.misses++; } ); - DREAL_ASSERT(substitutions_copy == substitutions); - return match_vec; + DREAL_ASSERT(substitutions.size() == init_size); + return {match_vec, stats}; } void PatternMatchingTrie::insert(const Formula& f) { diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index cec310605..b95ebef5c 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -20,14 +20,14 @@ namespace dreal { - std::vector, substitutions_map>> + std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> PredicateNormalizer::FindSimilar(const std::set& clause) const { for (const auto& f : clause) { const auto& atom = is_negation(f) ? get_operand(f) : f; // Learned clauses MUST be a collection of normalized literals. DREAL_ASSERT(is_equal_to(atom) || is_less_than(atom) || is_less_than_or_equal_to(atom) || is_forall(atom)); } - return trie.find_matches(clause); + return trie.find_matches(ordered_clause); } Formula PredicateNormalizer::Convert(const Formula& f) { diff --git a/src/dreal/util/predicate_normalizer.h b/src/dreal/util/predicate_normalizer.h index a2d45a271..fcf70953e 100644 --- a/src/dreal/util/predicate_normalizer.h +++ b/src/dreal/util/predicate_normalizer.h @@ -28,7 +28,10 @@ namespace dreal public: Formula Convert(const Formula& f); - [[nodiscard]] std::vector, substitutions_map>> + [[nodiscard]] std::pair< + std::vector, substitutions_map>>, PatternMatchingTrie:: + matching_stats_t + > FindSimilar(const std::set& f) const; private: diff --git a/test/dreal/solver/test/pattern_matching_test.cc b/test/dreal/solver/test/pattern_matching_test.cc index d155c1bd3..3d58f10bc 100644 --- a/test/dreal/solver/test/pattern_matching_test.cc +++ b/test/dreal/solver/test/pattern_matching_test.cc @@ -67,7 +67,7 @@ namespace dreal for (const auto& miss : misses1) trie.insert(miss); for (const auto& miss : misses2) trie.insert(miss); std::set found; - for (const auto& [form, subs] : trie.find_matches(pattern)) { + for (const auto& [form, subs] : trie.find_matches(pattern).first) { // check substitutions are correct and injective: EXPECT_TRUE(substitutions_map::apply_substitution(form, subs, false).EqualTo(pattern)); EXPECT_TRUE(substitutions_map::apply_substitution(pattern, subs, true).EqualTo(form)); @@ -104,10 +104,13 @@ namespace dreal y2 == atan(x2), }; for (const auto& lit : literals) trie.insert(lit); - const auto related_clauses = trie.find_matches( + const auto [related_clauses, stats] = trie.find_matches( {y1 == sin(x1), y1 == atan(x1)} ); + EXPECT_EQ(stats.misses, 4); + EXPECT_EQ(stats.matches, 2); EXPECT_EQ(related_clauses.size(), 2); + // EXPECT_EQ(trie.estimate_branches(y1 == sin(x1)), 12); // todo: make less brittle... depends on hash values. EXPECT_TRUE(related_clauses[0].first[0].EqualTo(y1 == sin(x1))); @@ -542,12 +545,12 @@ namespace dreal pattern.Substitute({{x1, p1}, {x2, p2}}), }; for (const auto& match : matches) { - const auto found = trie.find_matches(match); + const auto found = trie.find_matches(match).first; EXPECT_EQ(found.size(), 1); std::cout << pattern << " MATCHES " << match << std::endl; } for (const auto& miss : misses) { - const auto found = trie.find_matches(miss); + const auto found = trie.find_matches(miss).first; EXPECT_EQ(found.size(), 0); std::cout << pattern << " MISSES " << miss << std::endl; } From e0f2fa5280b16f91a8344c9a94ca1d552bd48482 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:30:47 -0700 Subject: [PATCH 04/79] Sort clause prior to pattern matching to avoid fruitless substitution branches. --- src/dreal/util/predicate_normalizer.cc | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index b95ebef5c..456740aa6 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -16,13 +16,25 @@ #include "dreal/util/predicate_normalizer.h" #include -#include "dynamic_bitset.h" - namespace dreal { std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> PredicateNormalizer::FindSimilar(const std::set& clause) const { - for (const auto& f : clause) { + std::vector ordered_clause(clause.begin(), clause.end()); + std::sort(ordered_clause.begin(), ordered_clause.end(), [&](const Formula &a, const Formula &b) { + return a.GetFreeVariables().size() > b.GetFreeVariables().size(); // descending + // return trie.estimate_branches(a) > trie.estimate_branches(b); + }); + if (DREAL_LOG_INFO_ENABLED) { + std::ostringstream s; + s << "!("; + for (const auto& lit : ordered_clause) s << '(' << lit << ") and "; + s << ")"; + DREAL_LOG_INFO("Finding matches for: {}", s.str()); + } + // todo `std::reverse()` and compare performance. + + for (const auto& f : ordered_clause) { const auto& atom = is_negation(f) ? get_operand(f) : f; // Learned clauses MUST be a collection of normalized literals. DREAL_ASSERT(is_equal_to(atom) || is_less_than(atom) || is_less_than_or_equal_to(atom) || is_forall(atom)); From f8f5c7951934239911bcbf0a91e960f2e4ce0175 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:33:18 -0700 Subject: [PATCH 05/79] Fruitless attempt at creating estimation heuristic for cost of pattern matching. --- .../pattern_matching/pattern_matching_trie.h | 203 +++++++++---- .../pattern_matching_trie_expr.cc | 274 +++++++++++++----- .../pattern_matching_trie_form.cc | 138 +++++++-- .../pattern_matching_trie_general.cc | 32 ++ src/dreal/util/predicate_normalizer.cc | 7 + src/dreal/util/predicate_normalizer.h | 6 + 6 files changed, 498 insertions(+), 162 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index 2df822c5f..ea9bf93fc 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -7,7 +7,6 @@ #include #include -#include #include #include "dreal/symbolic/symbolic.h" @@ -75,25 +74,32 @@ namespace dreal void insert(const Formula& f); void insert(const Expression& f); - // private: + private: + static uint64_t init_id() { + static uint64_t global_id_counter = 0; + return global_id_counter++; + } + + public: template class TrieNode { public: - TrieNode(): children{4} {} + TrieNode(): id{init_id()}, children{4} {} - TrieNode( + explicit TrieNode( const std::optional& leaf, const std::optional& terminal_expression = {} - ): switch_kind{}, children{4}, leaf{leaf}, terminal_expression{terminal_expression} {} + ): leaf{leaf}, terminal_expression{terminal_expression}, switch_kind{}, id{init_id()}, children{4} {} TrieNode(const TrieNode& other) = delete; // these should never be copied. TrieNode(TrieNode&& other) noexcept - : switch_kind{std::move(other.switch_kind)}, - children{std::move(other.children)}, - leaf{std::move(other.leaf)}, - terminal_expression{std::move(other.terminal_expression)} {} + : leaf{std::move(other.leaf)}, + terminal_expression{std::move(other.terminal_expression)}, + switch_kind{std::move(other.switch_kind)}, + id{std::move(other.id)}, + children{std::move(other.children)} {} ~TrieNode() noexcept { if (switch_kind != nullptr) delete switch_kind; @@ -104,37 +110,58 @@ namespace dreal return *switch_kind; } - [[nodiscard]] const std::vector>& c(const TKind& k) const { + [[nodiscard]] const std::vector& c(const TKind& k) const { const auto it = children.find(k); if (it != children.end()) return it->second; - const static std::vector> t_empty; + const static std::vector t_empty; return t_empty; } - [[nodiscard]] std::vector>& c(const TKind& k) { + [[nodiscard]] std::vector& c(const TKind& k) { return children[k]; } - [[nodiscard]] const TrieNode& c_leafless(const TKind& k) const { + [[nodiscard]] const TrieNode& c_leafless(const TKind& k) const { const auto& vec = c(k); DREAL_ASSERT(vec.size() == 1); return vec[0]; } - [[nodiscard]] TrieNode& c_leafless(const TKind& k) { + [[nodiscard]] TrieNode& c_leafless(const TKind& k) { auto& vec = c(k); if (vec.empty()) vec.emplace_back(); DREAL_ASSERT(vec.size() == 1); return vec[0]; } + // template + // [[nodiscard]] const std::unordered_map& c_unique(const TKind& kind) const { + // return unique_children(kind); + // } + // + // template + // [[nodiscard]] std::unordered_map& c_unique(const TKind& kind) { + // return unique_children(kind); + // } + std::optional leaf{}; std::optional terminal_expression{}; // important for ITEs which contain both Formulas and Expressions TrieNode* switch_kind = nullptr; + const uint64_t id; + private: std::unordered_map> children; + + // template + // std::unordered_map& unique_children(const TKind& kind) const { + // static std::unordered_map< + // uint64_t, std::unordered_map> + // > additional_members; + // return additional_members[id][kind]; + // } + // friend PatternMatchingTrie; }; @@ -142,16 +169,23 @@ namespace dreal using FormNode = TrieNode; ExprNode e_root; FormNode f_root; + // std::unordered_set f_already_inserted; + // std::unordered_set e_already_inserted; + // std::unordered_map f_branch_est_cache; + // std::unordered_map e_branch_est_cache; // using e_partial_matches_vec = std::vector>; using e_partial_matches_vec = std::function; + using e_est_continuation_vec = std::function; // using f_partial_matches_vec = std::vector>; using f_partial_matches_vec = std::function; + using f_est_continuation_vec = std::function; - using e_misses_vec = std::function; - using f_misses_vec = std::function; + using e_misses_vec = std::function; + using f_misses_vec = std::function; #define PM_CONT_LAMBDA(n,s) [&](const auto &n, auto &s) +#define EST_CONT_LAMBDA(n) [&](const auto &n) #define VISIT_DECL(name) void name ( \ const Expression &_e, const ExprNode &parent, \ @@ -161,37 +195,40 @@ namespace dreal const e_misses_vec &misses \ ) const #define ADD_DECL(name) ExprNode& name (const Expression &e, ExprNode &parent, const std::optional &is_terminal) -#define VISIT_AND_ADD_DECL(name) \ +#define EST_DECL(name) void name (const Expression &e, const ExprNode &parent, uint64_t &branches, const e_est_continuation_vec& partial_matches) const; +#define ALL_DECLS(name) \ VISIT_DECL(name); \ - ADD_DECL(name); - VISIT_AND_ADD_DECL(VisitVariable); - VISIT_AND_ADD_DECL(VisitConstant); - VISIT_AND_ADD_DECL(VisitRealConstant); - VISIT_AND_ADD_DECL(VisitAddition); - VISIT_AND_ADD_DECL(VisitMultiplication); - VISIT_AND_ADD_DECL(VisitDivision); - VISIT_AND_ADD_DECL(VisitLog); - VISIT_AND_ADD_DECL(VisitAbs); - VISIT_AND_ADD_DECL(VisitExp); - VISIT_AND_ADD_DECL(VisitSqrt); - VISIT_AND_ADD_DECL(VisitPow); - VISIT_AND_ADD_DECL(VisitSin); - VISIT_AND_ADD_DECL(VisitCos); - VISIT_AND_ADD_DECL(VisitTan); - VISIT_AND_ADD_DECL(VisitAsin); - VISIT_AND_ADD_DECL(VisitAcos); - VISIT_AND_ADD_DECL(VisitAtan); - VISIT_AND_ADD_DECL(VisitAtan2); - VISIT_AND_ADD_DECL(VisitSinh); - VISIT_AND_ADD_DECL(VisitCosh); - VISIT_AND_ADD_DECL(VisitTanh); - VISIT_AND_ADD_DECL(VisitMin); - VISIT_AND_ADD_DECL(VisitMax); - VISIT_AND_ADD_DECL(VisitIfThenElse); - VISIT_AND_ADD_DECL(VisitUninterpretedFunction); + ADD_DECL(name); \ + EST_DECL(name); + ALL_DECLS(VisitVariable); + ALL_DECLS(VisitConstant); + ALL_DECLS(VisitRealConstant); + ALL_DECLS(VisitAddition); + ALL_DECLS(VisitMultiplication); + ALL_DECLS(VisitDivision); + ALL_DECLS(VisitLog); + ALL_DECLS(VisitAbs); + ALL_DECLS(VisitExp); + ALL_DECLS(VisitSqrt); + ALL_DECLS(VisitPow); + ALL_DECLS(VisitSin); + ALL_DECLS(VisitCos); + ALL_DECLS(VisitTan); + ALL_DECLS(VisitAsin); + ALL_DECLS(VisitAcos); + ALL_DECLS(VisitAtan); + ALL_DECLS(VisitAtan2); + ALL_DECLS(VisitSinh); + ALL_DECLS(VisitCosh); + ALL_DECLS(VisitTanh); + ALL_DECLS(VisitMin); + ALL_DECLS(VisitMax); + ALL_DECLS(VisitIfThenElse); + ALL_DECLS(VisitUninterpretedFunction); #undef VISIT_DECL +#undef EST_DECL #undef ADD_DECL -#undef VISIT_AND_ADD_DECL +#undef ALL_DECLS #define VISIT_DECL(name) void name ( \ const Formula &f, const FormNode &parent, \ @@ -201,25 +238,28 @@ namespace dreal const f_misses_vec& misses \ ) const #define ADD_DECL(name) FormNode& name (const Formula &f, FormNode &parent, const std::optional &is_terminal) -#define VISIT_AND_ADD_DECL(name) \ +#define EST_DECL(name) void name (const Formula &f, const FormNode &parent, uint64_t &branches, const f_est_continuation_vec& partial_matches) const; +#define ALL_DECLS(name) \ VISIT_DECL(name); \ - ADD_DECL(name); - VISIT_AND_ADD_DECL(VisitFalse); - VISIT_AND_ADD_DECL(VisitTrue); - VISIT_AND_ADD_DECL(VisitVariable); - VISIT_AND_ADD_DECL(VisitEqualTo); - VISIT_AND_ADD_DECL(VisitNotEqualTo); - VISIT_AND_ADD_DECL(VisitGreaterThan); - VISIT_AND_ADD_DECL(VisitGreaterThanOrEqualTo); - VISIT_AND_ADD_DECL(VisitLessThan); - VISIT_AND_ADD_DECL(VisitLessThanOrEqualTo); - VISIT_AND_ADD_DECL(VisitConjunction); - VISIT_AND_ADD_DECL(VisitDisjunction); - VISIT_AND_ADD_DECL(VisitNegation); - VISIT_AND_ADD_DECL(VisitForall); + ADD_DECL(name); \ + EST_DECL(name); + ALL_DECLS(VisitFalse); + ALL_DECLS(VisitTrue); + ALL_DECLS(VisitVariable); + ALL_DECLS(VisitEqualTo); + ALL_DECLS(VisitNotEqualTo); + ALL_DECLS(VisitGreaterThan); + ALL_DECLS(VisitGreaterThanOrEqualTo); + ALL_DECLS(VisitLessThan); + ALL_DECLS(VisitLessThanOrEqualTo); + ALL_DECLS(VisitConjunction); + ALL_DECLS(VisitDisjunction); + ALL_DECLS(VisitNegation); + ALL_DECLS(VisitForall); #undef VISIT_DECL +#undef EST_DECL #undef ADD_DECL -#undef VISIT_AND_ADD_DECL +#undef ALL_DECLS void UnaryOpMatchHelper(const Expression& e, const ExpressionKind& k, const ExprNode& parent, substitutions_map& substitutions, @@ -256,6 +296,16 @@ namespace dreal const std::optional& is_terminal); FormNode& NaryOpAddHelper(const Formula& f, const FormulaKind& k, FormNode& parent, const std::optional& is_terminal); + void UnaryOpEstHelper(const Expression& f, const ExpressionKind& k, const ExprNode& parent, + uint64_t& branches, const e_est_continuation_vec& partial_matches) const; + void UnaryOpEstHelper(const Formula& f, const FormulaKind& k, const FormNode& parent, + uint64_t& branches, const f_est_continuation_vec& partial_matches) const; + void BinaryOpEstHelper(const Expression& f, const ExpressionKind& k, const ExprNode& parent, + uint64_t& branches, const e_est_continuation_vec& partial_matches) const; + void BinaryOpEstHelper(const Formula& f, const FormulaKind& k, const FormNode& parent, + uint64_t& branches, const f_est_continuation_vec& partial_matches) const; + void NaryOpEstHelper(const Formula& f, const FormulaKind& k, const FormNode& parent, + uint64_t& branches, const f_est_continuation_vec& partial_matches) const; void recMatchExpr( const Expression& e, const ExprNode& parent, substitutions_map& substitutions, @@ -267,7 +317,18 @@ namespace dreal ExprNode& recAddExpr( const Expression& e, ExprNode& parent, const std::optional& is_terminal - ) { return VisitExpression(this, e, parent, is_terminal); } + ) { + // std::cout << "recAddExpr: " << e << std::endl; + return VisitExpression(this, e, parent, is_terminal); + } + + void recEstExpr( + const Expression& e, const ExprNode& parent, uint64_t& branches, + const e_est_continuation_vec& partial_matches + ) const { + // std::cout << "recEstExpr: " << e << std::endl; + VisitExpression(this, e, parent, branches, partial_matches); + } void recMatchForm( const Formula& f, const FormNode& parent, substitutions_map& substitutions, @@ -279,7 +340,17 @@ namespace dreal FormNode& recAddForm( const Formula& f, FormNode& parent, const std::optional& is_terminal - ) { return VisitFormula(this, f, parent, is_terminal); } + ) { + // std::cout << "recAddForm: " << f << std::endl; + return VisitFormula(this, f, parent, is_terminal); + } + + void recEstForm( + const Formula& f, const FormNode& parent, uint64_t& branches, const f_est_continuation_vec& partial_matches + ) const { + // std::cout << "recEstForm: " << f << std::endl; + VisitFormula(this, f, parent, branches, partial_matches); + } friend void drake::symbolic::VisitExpression( PatternMatchingTrie*, const Expression& e, @@ -290,6 +361,10 @@ namespace dreal PatternMatchingTrie*, const Expression& e, ExprNode& parent, const std::optional& is_terminal ); + friend void drake::symbolic::VisitExpression( + PatternMatchingTrie*, const Expression& e, const ExprNode& parent, + uint64_t& branches, const e_est_continuation_vec& partial_matches + ); friend void drake::symbolic::VisitFormula( PatternMatchingTrie*, const Formula& e, const FormNode& parent, substitutions_map& substitutions, @@ -299,6 +374,10 @@ namespace dreal PatternMatchingTrie*, const Formula& e, FormNode& parent, const std::optional& is_terminal ); + friend void drake::symbolic::VisitFormula( + PatternMatchingTrie*, const Formula& e, const FormNode& parent, + uint64_t& branches, const f_est_continuation_vec& partial_matches + ); }; inline std::ostream& operator<<(std::ostream& os, const PatternMatchingTrie::matching_stats_t& stats) { diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc index b6cd0adca..6ad1e7b10 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc @@ -19,6 +19,8 @@ void PatternMatchingTrie::name ( \ const e_partial_matches_vec& partial_matches, \ const e_misses_vec &misses \ ) const +#define EST_DECL(name) \ +void PatternMatchingTrie::name (const Expression &_e, const ExprNode &parent, uint64_t &branches, const e_est_continuation_vec& partial_matches) const #define ADD_DECL(name) \ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, ExprNode &parent, const std::optional &is_terminal) @@ -27,6 +29,19 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::Var).emplace_back(e, is_terminal); } + EST_DECL(VisitVariable) { + const auto& e = get_variable(_e); + for (auto& node : parent.c(ExpressionKind::Var)) { + const auto& matched_e = get_variable(*node.leaf); + if (!matched_e.equal_to(e) /* confirmed non-recursive, simple one-liner */) {} + else if (!node.terminal_expression.has_value()) { + // partial match, keep going! + partial_matches(node); + } + } + branches *= parent.c(ExpressionKind::Var).size(); + } + VISIT_DECL(VisitVariable) { const auto& e = get_variable(_e); for (auto& node : parent.c(ExpressionKind::Var)) { @@ -57,6 +72,17 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::Constant).emplace_back(e, is_terminal); } + EST_DECL(VisitConstant) { + branches += parent.c(ExpressionKind::Constant).size(); + const auto e = get_constant_value(_e); + for (auto& node : parent.c(ExpressionKind::Constant)) { + const auto& matched_e = get_constant_value(*node.leaf); + if (e != matched_e) {} + else if (!node.terminal_expression.has_value()) + partial_matches(node); + } + } + VISIT_DECL(VisitConstant) { const auto e = get_constant_value(_e); for (auto& node : parent.c(ExpressionKind::Constant)) { @@ -76,6 +102,17 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::RealConstant).emplace_back(e, is_terminal); } + EST_DECL(VisitRealConstant) { + branches += parent.c(ExpressionKind::RealConstant).size(); + const auto e = to_real_constant(_e); + for (auto& node : parent.c(ExpressionKind::RealConstant)) { + const auto& matched_e = to_real_constant(*node.leaf); + if (!e->EqualTo(*matched_e) /* confirmed non-recursive, simple one-liner */) {} + else if (!node.terminal_expression.has_value()) + partial_matches(node); + } + } + VISIT_DECL(VisitRealConstant) { const auto e = to_real_constant(_e); for (auto& node : parent.c(ExpressionKind::RealConstant)) { @@ -109,6 +146,40 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return *stateCoeff; } + EST_DECL(VisitAddition) { + branches += parent.c(ExpressionKind::Add).size(); + const auto e = to_addition(_e); + for (auto& n1 : parent.c(ExpressionKind::Add)) { + const auto& m = to_addition(*n1.leaf); + if (e->get_constant() != m->get_constant()) continue; + if (e->get_expr_to_coeff_map().size() != m->get_expr_to_coeff_map().size()) continue; + + std::multimap e_canon_coeff_to_expr_map; + for (auto& [expr, coeff] : e->get_expr_to_coeff_map()) + e_canon_coeff_to_expr_map.emplace(coeff, expr); + + DREAL_ASSERT(!n1.terminal_expression.has_value()); + const auto ibegin = e_canon_coeff_to_expr_map.begin(); + const auto iend = e_canon_coeff_to_expr_map.end(); + std::function it_to_match_coeff, it_to_match_expr; + it_to_match_coeff = [&](const auto& it1) { + return [&, /*copy*/ it1](const auto& n) { + auto it2 = it1; + ++it2; + if (it2 == iend) partial_matches(n); + else recEstExpr(it2->first, n, branches, it_to_match_expr(it2)); + }; + }; + it_to_match_expr = [&](const auto& it) { + return [&, /*copy*/ it](const auto& n) { + DREAL_ASSERT(!n.terminal_expression.has_value()); + recEstExpr(it->second, n, branches, it_to_match_coeff(it)); + }; + }; + recEstExpr(ibegin->first, n1, branches, it_to_match_expr(ibegin)); + } + } + VISIT_DECL(VisitAddition) { const auto e = to_addition(_e); for (auto& n1 : parent.c(ExpressionKind::Add)) { @@ -160,6 +231,40 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return *stateExp; } + EST_DECL(VisitMultiplication) { + branches += parent.c(ExpressionKind::Mul).size(); + const auto e = to_multiplication(_e); + for (auto& n1 : parent.c(ExpressionKind::Mul)) { + const auto& m = to_multiplication(*n1.leaf); + if (e->get_constant() != m->get_constant()) continue; + if (e->get_base_to_exponent_map().size() != m->get_base_to_exponent_map().size()) continue; + + std::multimap e_canon_expo_to_base_map; + for (auto& [base, expo] : e->get_base_to_exponent_map()) + e_canon_expo_to_base_map.emplace(expo, base); + + DREAL_ASSERT(!n1.terminal_expression.has_value()); + const auto ibegin = e_canon_expo_to_base_map.begin(); + const auto iend = e_canon_expo_to_base_map.end(); + std::function it_to_match_expo, it_to_match_base; + it_to_match_expo = [&](const auto& it1) { + return [&, /*copy*/ it1](const auto& n) { + auto it2 = it1; + ++it2; + if (it2 == iend) partial_matches(n); + else recEstExpr(it2->first, n, branches, it_to_match_base(it2)); + }; + }; + it_to_match_base = [&](const auto& it1) { + return [&, /*copy*/ it1](const auto& n) { + DREAL_ASSERT(!n.terminal_expression.has_value()); + recEstExpr(it1->second, n, branches, it_to_match_expo(it1)); + }; + }; + recEstExpr(ibegin->first, n1, branches, it_to_match_base(ibegin)); + } + } + VISIT_DECL(VisitMultiplication) { const auto e = to_multiplication(_e); for (auto& n1 : parent.c(ExpressionKind::Mul)) { @@ -203,6 +308,21 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return n3; } + void PatternMatchingTrie::BinaryOpEstHelper( + const Expression& e, const ExpressionKind& k, + const ExprNode& parent, uint64_t& branches, const e_est_continuation_vec& partial_matches + ) const { + branches += parent.c(k).size(); + for (auto& n1 : parent.c(k)) { + recEstExpr(get_first_argument(e), n1, branches, EST_CONT_LAMBDA(n2) { + DREAL_ASSERT(!n1.leaf.has_value()); + DREAL_ASSERT(!n1.terminal_expression.has_value()); + DREAL_ASSERT(!n2.terminal_expression.has_value()); + recEstExpr(get_second_argument(e), n2, branches, partial_matches); + }); + } + } + void PatternMatchingTrie::BinaryOpMatchHelper( const Expression& _e, const ExpressionKind& k, const ExprNode& parent, substitutions_map& s1, @@ -229,6 +349,18 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return n2; } + void PatternMatchingTrie::UnaryOpEstHelper( + const Expression& e, const ExpressionKind& k, + const ExprNode& parent, uint64_t& branches, const e_est_continuation_vec& partial_matches + ) const { + branches += parent.c(k).size(); + for (auto& n1 : parent.c(k)) { + DREAL_ASSERT(!n1.leaf.has_value()); + DREAL_ASSERT(!n1.terminal_expression.has_value()); + recEstExpr(get_argument(e), n1, branches, partial_matches); + } + } + void PatternMatchingTrie::UnaryOpMatchHelper( const Expression& e, const ExpressionKind& k, const ExprNode& parent, substitutions_map& s1, @@ -243,146 +375,110 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } } - ADD_DECL(VisitDivision) { - return BinaryOpAddHelper(e, ExpressionKind::Div, parent, is_terminal); - } - + ADD_DECL(VisitDivision) { return BinaryOpAddHelper(e, ExpressionKind::Div, parent, is_terminal); } + EST_DECL(VisitDivision) { return BinaryOpEstHelper(_e, ExpressionKind::Div, parent, branches, partial_matches); } VISIT_DECL(VisitDivision) { return BinaryOpMatchHelper(_e, ExpressionKind::Div, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitLog) { - return UnaryOpAddHelper(e, ExpressionKind::Log, parent, is_terminal); - } - + ADD_DECL(VisitLog) { return UnaryOpAddHelper(e, ExpressionKind::Log, parent, is_terminal); } + EST_DECL(VisitLog) { return UnaryOpEstHelper(_e, ExpressionKind::Log, parent, branches, partial_matches); } VISIT_DECL(VisitLog) { return UnaryOpMatchHelper(_e, ExpressionKind::Log, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitAbs) { - return UnaryOpAddHelper(e, ExpressionKind::Abs, parent, is_terminal); - } - + ADD_DECL(VisitAbs) { return UnaryOpAddHelper(e, ExpressionKind::Abs, parent, is_terminal); } + EST_DECL(VisitAbs) { return UnaryOpEstHelper(_e, ExpressionKind::Abs, parent, branches, partial_matches); } VISIT_DECL(VisitAbs) { return UnaryOpMatchHelper(_e, ExpressionKind::Abs, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitExp) { - return UnaryOpAddHelper(e, ExpressionKind::Exp, parent, is_terminal); - } - + ADD_DECL(VisitExp) { return UnaryOpAddHelper(e, ExpressionKind::Exp, parent, is_terminal); } + EST_DECL(VisitExp) { return UnaryOpEstHelper(_e, ExpressionKind::Exp, parent, branches, partial_matches); } VISIT_DECL(VisitExp) { return UnaryOpMatchHelper(_e, ExpressionKind::Exp, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitSqrt) { - return UnaryOpAddHelper(e, ExpressionKind::Sqrt, parent, is_terminal); - } - + ADD_DECL(VisitSqrt) { return UnaryOpAddHelper(e, ExpressionKind::Sqrt, parent, is_terminal); } + EST_DECL(VisitSqrt) { return UnaryOpEstHelper(_e, ExpressionKind::Sqrt, parent, branches, partial_matches); } VISIT_DECL(VisitSqrt) { return UnaryOpMatchHelper(_e, ExpressionKind::Sqrt, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitPow) { - return BinaryOpAddHelper(e, ExpressionKind::Pow, parent, is_terminal); - } - + ADD_DECL(VisitPow) { return BinaryOpAddHelper(e, ExpressionKind::Pow, parent, is_terminal); } + EST_DECL(VisitPow) { return BinaryOpEstHelper(_e, ExpressionKind::Pow, parent, branches, partial_matches); } VISIT_DECL(VisitPow) { return BinaryOpMatchHelper(_e, ExpressionKind::Pow, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitSin) { - return UnaryOpAddHelper(e, ExpressionKind::Sin, parent, is_terminal); - } - + ADD_DECL(VisitSin) { return UnaryOpAddHelper(e, ExpressionKind::Sin, parent, is_terminal); } + EST_DECL(VisitSin) { return UnaryOpEstHelper(_e, ExpressionKind::Sin, parent, branches, partial_matches); } VISIT_DECL(VisitSin) { return UnaryOpMatchHelper(_e, ExpressionKind::Sin, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitCos) { - return UnaryOpAddHelper(e, ExpressionKind::Cos, parent, is_terminal); - } - + ADD_DECL(VisitCos) { return UnaryOpAddHelper(e, ExpressionKind::Cos, parent, is_terminal); } + EST_DECL(VisitCos) { return UnaryOpEstHelper(_e, ExpressionKind::Cos, parent, branches, partial_matches); } VISIT_DECL(VisitCos) { return UnaryOpMatchHelper(_e, ExpressionKind::Cos, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitTan) { - return UnaryOpAddHelper(e, ExpressionKind::Tan, parent, is_terminal); - } - + ADD_DECL(VisitTan) { return UnaryOpAddHelper(e, ExpressionKind::Tan, parent, is_terminal); } + EST_DECL(VisitTan) { return UnaryOpEstHelper(_e, ExpressionKind::Tan, parent, branches, partial_matches); } VISIT_DECL(VisitTan) { return UnaryOpMatchHelper(_e, ExpressionKind::Tan, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitAsin) { - return UnaryOpAddHelper(e, ExpressionKind::Asin, parent, is_terminal); - } - + ADD_DECL(VisitAsin) { return UnaryOpAddHelper(e, ExpressionKind::Asin, parent, is_terminal); } + EST_DECL(VisitAsin) { return UnaryOpEstHelper(_e, ExpressionKind::Asin, parent, branches, partial_matches); } VISIT_DECL(VisitAsin) { return UnaryOpMatchHelper(_e, ExpressionKind::Asin, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitAcos) { - return UnaryOpAddHelper(e, ExpressionKind::Acos, parent, is_terminal); - } - + ADD_DECL(VisitAcos) { return UnaryOpAddHelper(e, ExpressionKind::Acos, parent, is_terminal); } + EST_DECL(VisitAcos) { return UnaryOpEstHelper(_e, ExpressionKind::Acos, parent, branches, partial_matches); } VISIT_DECL(VisitAcos) { return UnaryOpMatchHelper(_e, ExpressionKind::Acos, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitAtan) { - return UnaryOpAddHelper(e, ExpressionKind::Atan, parent, is_terminal); - } - + ADD_DECL(VisitAtan) { return UnaryOpAddHelper(e, ExpressionKind::Atan, parent, is_terminal); } + EST_DECL(VisitAtan) { return UnaryOpEstHelper(_e, ExpressionKind::Atan, parent, branches, partial_matches); } VISIT_DECL(VisitAtan) { return UnaryOpMatchHelper(_e, ExpressionKind::Atan, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitAtan2) { - return BinaryOpAddHelper(e, ExpressionKind::Atan2, parent, is_terminal); - } - + ADD_DECL(VisitAtan2) { return BinaryOpAddHelper(e, ExpressionKind::Atan2, parent, is_terminal); } + EST_DECL(VisitAtan2) { return BinaryOpEstHelper(_e, ExpressionKind::Atan2, parent, branches, partial_matches); } VISIT_DECL(VisitAtan2) { return BinaryOpMatchHelper(_e, ExpressionKind::Atan2, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitSinh) { - return UnaryOpAddHelper(e, ExpressionKind::Sinh, parent, is_terminal); - } - + ADD_DECL(VisitSinh) { return UnaryOpAddHelper(e, ExpressionKind::Sinh, parent, is_terminal); } + EST_DECL(VisitSinh) { return UnaryOpEstHelper(_e, ExpressionKind::Sinh, parent, branches, partial_matches); } VISIT_DECL(VisitSinh) { return UnaryOpMatchHelper(_e, ExpressionKind::Sinh, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitCosh) { - return UnaryOpAddHelper(e, ExpressionKind::Cosh, parent, is_terminal); - } - + ADD_DECL(VisitCosh) { return UnaryOpAddHelper(e, ExpressionKind::Cosh, parent, is_terminal); } + EST_DECL(VisitCosh) { return UnaryOpEstHelper(_e, ExpressionKind::Cosh, parent, branches, partial_matches); } VISIT_DECL(VisitCosh) { return UnaryOpMatchHelper(_e, ExpressionKind::Cosh, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitTanh) { - return UnaryOpAddHelper(e, ExpressionKind::Tanh, parent, is_terminal); - } - + ADD_DECL(VisitTanh) { return UnaryOpAddHelper(e, ExpressionKind::Tanh, parent, is_terminal); } + EST_DECL(VisitTanh) { return UnaryOpEstHelper(_e, ExpressionKind::Tanh, parent, branches, partial_matches); } VISIT_DECL(VisitTanh) { return UnaryOpMatchHelper(_e, ExpressionKind::Tanh, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitMin) { - return BinaryOpAddHelper(e, ExpressionKind::Min, parent, is_terminal); - } - + ADD_DECL(VisitMin) { return BinaryOpAddHelper(e, ExpressionKind::Min, parent, is_terminal); } + EST_DECL(VisitMin) { return BinaryOpEstHelper(_e, ExpressionKind::Min, parent, branches, partial_matches); } VISIT_DECL(VisitMin) { return BinaryOpMatchHelper(_e, ExpressionKind::Min, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitMax) { - return BinaryOpAddHelper(e, ExpressionKind::Max, parent, is_terminal); - } - + ADD_DECL(VisitMax) { return BinaryOpAddHelper(e, ExpressionKind::Max, parent, is_terminal); } + EST_DECL(VisitMax) { return BinaryOpEstHelper(_e, ExpressionKind::Max, parent, branches, partial_matches); } VISIT_DECL(VisitMax) { return BinaryOpMatchHelper(_e, ExpressionKind::Max, parent, substitutions, matches, partial_matches, misses); } @@ -396,6 +492,28 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return n4; } + EST_DECL(VisitIfThenElse) { + branches += parent.c(ExpressionKind::IfThenElse).size(); + const auto e = to_if_then_else(_e); + for (auto& n1 : parent.c(ExpressionKind::IfThenElse)) { + DREAL_ASSERT(n1.switch_kind != nullptr); + recEstForm( + e->get_conditional_formula(), *n1.switch_kind, branches, + EST_CONT_LAMBDA(n2) { + DREAL_ASSERT(n2.switch_kind != nullptr); + recEstExpr( + e->get_then_expression(), *n2.switch_kind, branches, + EST_CONT_LAMBDA(n3) { + DREAL_ASSERT(!n1.leaf.has_value()); + DREAL_ASSERT(!n1.terminal_expression.has_value()); + DREAL_ASSERT(!n2.terminal_expression.has_value()); + DREAL_ASSERT(!n3.terminal_expression.has_value()); + recEstExpr(e->get_else_expression(), n3, branches, partial_matches); + }); + }); + } + } + VISIT_DECL(VisitIfThenElse) { const auto e = to_if_then_else(_e); for (auto& n1 : parent.c(ExpressionKind::IfThenElse)) { @@ -422,6 +540,17 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::UninterpretedFunction).emplace_back(e, is_terminal); } + EST_DECL(VisitUninterpretedFunction) { + branches += parent.c(ExpressionKind::UninterpretedFunction).size(); + const auto e = to_uninterpreted_function(_e); + for (auto& node : parent.c(ExpressionKind::UninterpretedFunction)) { + const auto& matched_e = to_uninterpreted_function(*node.leaf); + if (!e->EqualTo(*matched_e) /*confirmed non-recursive, simple one-liner*/) {} + else if (!node.terminal_expression.has_value()) + partial_matches(node); + } + } + VISIT_DECL(VisitUninterpretedFunction) { // todo: can an uninterpreted function be substituted? yeah probably... // but doesn't really make sense for dReal. @@ -439,5 +568,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } } #undef VISIT_DECL +#undef EST_DECL #undef ADD_DECL } diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index 9ffe7e06b..f777877cf 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -19,14 +19,27 @@ void PatternMatchingTrie::name ( \ const f_partial_matches_vec& partial_matches, \ const f_misses_vec& misses \ ) const +#define EST_DECL(name) \ +void PatternMatchingTrie::name (const Formula &_f, const FormNode &parent, uint64_t &branches, const f_est_continuation_vec& partial_matches) const #define ADD_DECL(name) \ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, FormNode &parent, const std::optional &is_terminal) ADD_DECL(VisitFalse) { + DREAL_ASSERT(parent.c(FormulaKind::False).empty()); // todo? idk. idk how my own code works. return parent.c(FormulaKind::False).emplace_back(f, is_terminal); } + EST_DECL(VisitFalse) { + branches += parent.c(FormulaKind::False).size(); + DREAL_ASSERT(parent.c(FormulaKind::False).size() == 1); // todo? idk. idk how my own code works. + for (auto& node : parent.c(FormulaKind::False)) { + if (!node.terminal_expression.has_value()) + partial_matches(node); + } + } + VISIT_DECL(VisitFalse) { + DREAL_ASSERT(parent.c(FormulaKind::False).size() == 1); // todo? idk. idk how my own code works. for (auto& node : parent.c(FormulaKind::False)) { if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); @@ -38,10 +51,21 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } ADD_DECL(VisitTrue) { + DREAL_ASSERT(parent.c(FormulaKind::True).empty()); // todo? idk. idk how my own code works. return parent.c(FormulaKind::True).emplace_back(f, is_terminal); } + EST_DECL(VisitTrue) { + branches += parent.c(FormulaKind::True).size(); + DREAL_ASSERT(parent.c(FormulaKind::True).size() == 1); // todo? idk. idk how my own code works. + for (auto& node : parent.c(FormulaKind::True)) { + if (!node.terminal_expression.has_value()) + partial_matches(node); + } + } + VISIT_DECL(VisitTrue) { + DREAL_ASSERT(parent.c(FormulaKind::True).size() == 1); // todo? idk. idk how my own code works. for (auto& node : parent.c(FormulaKind::True)) { if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); @@ -56,6 +80,19 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return parent.c(FormulaKind::Var).emplace_back(f, is_terminal); } + EST_DECL(VisitVariable) { + const auto& f = get_variable(_f); + for (auto& node : parent.c(FormulaKind::Var)) { + const auto& matched_f = get_variable(*node.leaf); + if (!matched_f.equal_to(f) /* confirmed non-recursive, simple one-liner */) {} + else if (!node.terminal_expression.has_value()) { + // partial match, keep going! + partial_matches(node); + } + } + branches *= parent.c(FormulaKind::Var).size(); + } + VISIT_DECL(VisitVariable) { const auto& f = get_variable(_f); for (auto& node : parent.c(FormulaKind::Var)) { @@ -94,6 +131,24 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return n4; } + void PatternMatchingTrie::BinaryOpEstHelper( + const Formula& f, const FormulaKind& k, + const FormNode& parent, uint64_t& branches, const f_est_continuation_vec& partial_matches + ) const { + branches += parent.c(k).size(); + for (auto& n1 : parent.c(k)) { + recEstExpr(get_lhs_expression(f), *n1.switch_kind, branches, EST_CONT_LAMBDA(n2) { + DREAL_ASSERT(!n1.leaf.has_value()); + DREAL_ASSERT(!n1.terminal_expression.has_value()); + DREAL_ASSERT(!n2.terminal_expression.has_value()); + recEstExpr(get_rhs_expression(f), n2, branches, EST_CONT_LAMBDA(n3) { + if (!n3.switch_kind->terminal_expression.has_value()) + partial_matches(*n3.switch_kind); + }); + }); + } + } + void PatternMatchingTrie::BinaryOpMatchHelper( const Formula& _f, const FormulaKind& k, const FormNode& parent, substitutions_map& s1, @@ -135,6 +190,32 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return *state; } + void PatternMatchingTrie::NaryOpEstHelper( + const Formula& f, const FormulaKind& k, + const FormNode& parent, uint64_t& branches, const f_est_continuation_vec& partial_matches + ) const { + branches += parent.c(k).size(); + const auto _f = to_nary(f); + for (auto& n1 : parent.c(k)) { + DREAL_ASSERT(!n1.terminal_expression.has_value()); + const auto ibegin = _f->get_operands().begin(); + const auto iend = _f->get_operands().end(); + std::function it_to_match_op = [&](const auto& it1) { + return [&, /*copy*/ it1](const auto& n2) { + if (it1 == iend) { + DREAL_ASSERT(get_operands(f).size() == 1); + return partial_matches(n2); + } + auto it2 = it1; + ++it2; + if (it2 == iend) partial_matches(n2); + else recEstForm(*it2, n2, branches, it_to_match_op(it2)); + }; + }; + recEstForm(*ibegin, n1, branches, it_to_match_op(ibegin)); + } + } + void PatternMatchingTrie::NaryOpMatchHelper( const Formula& f, const FormulaKind& k, const FormNode& parent, substitutions_map& s1, @@ -163,68 +244,58 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } } - ADD_DECL(VisitEqualTo) { - return BinaryOpAddHelper(f, FormulaKind::Eq, parent, is_terminal); - } - + ADD_DECL(VisitEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Eq, parent, is_terminal); } + EST_DECL(VisitEqualTo) { return BinaryOpEstHelper(_f, FormulaKind::Eq, parent, branches, partial_matches); } VISIT_DECL(VisitEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Eq, parent, substitutions, matches, partial_matches, misses); } // todo: Canonical-ize NEQ to NOT + EQ ? - ADD_DECL(VisitNotEqualTo) { - return BinaryOpAddHelper(f, FormulaKind::Neq, parent, is_terminal); - } - + ADD_DECL(VisitNotEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Neq, parent, is_terminal); } + EST_DECL(VisitNotEqualTo) { return BinaryOpEstHelper(_f, FormulaKind::Neq, parent, branches, partial_matches); } VISIT_DECL(VisitNotEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Neq, parent, substitutions, matches, partial_matches, misses); } // todo: Canonical-ize GT/LT to just one or the other ? - ADD_DECL(VisitGreaterThan) { - return BinaryOpAddHelper(f, FormulaKind::Gt, parent, is_terminal); - } - + ADD_DECL(VisitGreaterThan) { return BinaryOpAddHelper(f, FormulaKind::Gt, parent, is_terminal); } + EST_DECL(VisitGreaterThan) { return BinaryOpEstHelper(_f, FormulaKind::Gt, parent, branches, partial_matches); } VISIT_DECL(VisitGreaterThan) { return BinaryOpMatchHelper(_f, FormulaKind::Gt, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitGreaterThanOrEqualTo) { - return BinaryOpAddHelper(f, FormulaKind::Geq, parent, is_terminal); + ADD_DECL(VisitGreaterThanOrEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Geq, parent, is_terminal); } + EST_DECL(VisitGreaterThanOrEqualTo) { + return BinaryOpEstHelper(_f, FormulaKind::Geq, parent, branches, partial_matches); } VISIT_DECL(VisitGreaterThanOrEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Geq, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitLessThan) { - return BinaryOpAddHelper(f, FormulaKind::Lt, parent, is_terminal); - } - + ADD_DECL(VisitLessThan) { return BinaryOpAddHelper(f, FormulaKind::Lt, parent, is_terminal); } + EST_DECL(VisitLessThan) { return BinaryOpEstHelper(_f, FormulaKind::Lt, parent, branches, partial_matches); } VISIT_DECL(VisitLessThan) { return BinaryOpMatchHelper(_f, FormulaKind::Lt, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitLessThanOrEqualTo) { - return BinaryOpAddHelper(f, FormulaKind::Leq, parent, is_terminal); + ADD_DECL(VisitLessThanOrEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Leq, parent, is_terminal); } + EST_DECL(VisitLessThanOrEqualTo) { + return BinaryOpEstHelper(_f, FormulaKind::Leq, parent, branches, partial_matches); } VISIT_DECL(VisitLessThanOrEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Leq, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitConjunction) { - return NaryOpAddHelper(f, FormulaKind::And, parent, is_terminal); - } - + ADD_DECL(VisitConjunction) { return NaryOpAddHelper(f, FormulaKind::And, parent, is_terminal); } + EST_DECL(VisitConjunction) { return NaryOpEstHelper(_f, FormulaKind::And, parent, branches, partial_matches); } VISIT_DECL(VisitConjunction) { NaryOpMatchHelper(_f, FormulaKind::And, parent, substitutions, matches, partial_matches, misses); } - ADD_DECL(VisitDisjunction) { - return NaryOpAddHelper(f, FormulaKind::Or, parent, is_terminal); - } - + ADD_DECL(VisitDisjunction) { return NaryOpAddHelper(f, FormulaKind::Or, parent, is_terminal); } + EST_DECL(VisitDisjunction) { return NaryOpEstHelper(_f, FormulaKind::Or, parent, branches, partial_matches); } VISIT_DECL(VisitDisjunction) { NaryOpMatchHelper(_f, FormulaKind::Or, parent, substitutions, matches, partial_matches, misses); } @@ -234,6 +305,12 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return recAddForm(get_operand(f), n1, is_terminal); } + EST_DECL(VisitNegation) { + branches += parent.c(FormulaKind::Not).size(); + auto& n1 = parent.c_leafless(FormulaKind::Not); + recEstForm(get_operand(_f), n1, branches, partial_matches); + } + VISIT_DECL(VisitNegation) { for (auto& n1 : parent.c(FormulaKind::Not)) { DREAL_ASSERT(!n1.leaf.has_value()); @@ -246,6 +323,11 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form throw DREAL_RUNTIME_ERROR("Pattern matching of quantifiers is currently unsupported {}", f); } + EST_DECL(VisitForall) { + branches += parent.c(FormulaKind::Forall).size(); + throw DREAL_RUNTIME_ERROR("Pattern matching of quantifiers is currently unsupported {}", _f); + } + VISIT_DECL(VisitForall) { throw DREAL_RUNTIME_ERROR("Pattern matching of quantifiers is currently unsupported {}", _f); } diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index fe193db9f..a90b24ab7 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -127,11 +127,43 @@ namespace dreal return {match_vec, stats}; } + // uint64_t PatternMatchingTrie::estimate_branches(const Formula& f) { + // const auto it = f_branch_est_cache.find(f); + // if (it != f_branch_est_cache.end()) return it->second; + // + // uint64_t branches = 1; + // const f_est_continuation_vec partial_matches = EST_CONT_LAMBDA(n) { + // DREAL_LOG_ERROR("Unterminated partial matching?"); + // DREAL_UNREACHABLE(); // everything should AT LEAST match itself !?!?! + // }; + // recEstForm(f, f_root, branches, partial_matches); + // f_branch_est_cache.emplace(f, branches); + // return branches; + // } + // + // uint64_t PatternMatchingTrie::estimate_branches(const Expression& e) { + // const auto it = e_branch_est_cache.find(e); + // if (it != e_branch_est_cache.end()) return it->second; + // + // uint64_t branches = 1; + // const e_est_continuation_vec partial_matches = EST_CONT_LAMBDA(n) { + // DREAL_LOG_ERROR("Unterminated partial matching?"); + // DREAL_UNREACHABLE(); // everything should AT LEAST match itself !?!?! + // }; + // recEstExpr(e, e_root, branches, partial_matches); + // e_branch_est_cache.emplace(e, branches); + // return branches; + // } + void PatternMatchingTrie::insert(const Formula& f) { + // if (f_already_inserted.count(f)) return; // was relevant during c_unique() attempt. recAddForm(f, f_root, f); + // f_already_inserted.emplace(f); } void PatternMatchingTrie::insert(const Expression& e) { + // if (e_already_inserted.count(e)) return; // was relevant during c_unique() attempt. recAddExpr(e, e_root, e); + // e_already_inserted.emplace(e); } } diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index 456740aa6..af045bfce 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -42,6 +42,13 @@ namespace dreal return trie.find_matches(ordered_clause); } + // ended up being completely friggen useless lol :( + // uint64_t PredicateNormalizer::EstimateMatchingCost(const std::set& f) { + // uint64_t branches = 1; + // for (const auto & lit : f) branches += trie.estimate_branches(lit); + // return branches; + // } + Formula PredicateNormalizer::Convert(const Formula& f) { const auto it = cache.find(f); if (it == cache.cend()) { diff --git a/src/dreal/util/predicate_normalizer.h b/src/dreal/util/predicate_normalizer.h index fcf70953e..f97769d96 100644 --- a/src/dreal/util/predicate_normalizer.h +++ b/src/dreal/util/predicate_normalizer.h @@ -19,6 +19,7 @@ #include #include +#include "predicate_ranker.h" #include "dreal/symbolic/symbolic.h" namespace dreal @@ -34,6 +35,11 @@ namespace dreal > FindSimilar(const std::set& f) const; + // useless heuristic + // uint64_t EstimateMatchingCost(const std::set& f); + + PredicateRanker ranker; // todo: make private? + private: Formula VisitFalse(const Formula& f); Formula VisitTrue(const Formula& f); From 72c7cd966f245259a61fa2aeb30d2f6ee1736d80 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:40:36 -0700 Subject: [PATCH 06/79] Implement predicate statistics collector for future heuristic development. --- src/dreal/util/predicate_heuristic.cc | 295 ++++++++++++++++++++++++++ src/dreal/util/predicate_heuristic.h | 225 ++++++++++++++++++++ 2 files changed, 520 insertions(+) create mode 100644 src/dreal/util/predicate_heuristic.cc create mode 100644 src/dreal/util/predicate_heuristic.h diff --git a/src/dreal/util/predicate_heuristic.cc b/src/dreal/util/predicate_heuristic.cc new file mode 100644 index 000000000..40e990078 --- /dev/null +++ b/src/dreal/util/predicate_heuristic.cc @@ -0,0 +1,295 @@ +/* + Copyright 2017 Toyota Research Institute + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +#include "dreal/util/predicate_heuristic.h" + +#include +#include + +#include "exception.h" +#include "logging.h" + +namespace dreal +{ + PredicateHeuristic::predicate_stats_t PredicateHeuristic::collect_statistics(const Expression& e) { + const auto it = ecache.find(e); + if (it == ecache.cend()) { + predicate_stats_t stats = {0}; + recHeurExpr(e, stats); + stats.unique_variables = e.GetVariables().size(); + ecache.try_emplace(e, stats); + return stats; + } + else return it->second; + } + + PredicateHeuristic::predicate_stats_t PredicateHeuristic::collect_statistics(const Formula& f, const bool inverted) { + auto& fcache = inverted ? fcache_neg : fcache_pos; + const auto it = fcache.find(f); + if (it == fcache.cend()) { + predicate_stats_t stats = {0}; + recHeurForm(f, stats, inverted); + stats.unique_variables = f.GetFreeVariables().size(); + if ( + !(is_negation(f) && is_nary(get_operand(f))) && + !is_nary(f) // these will be cached at a lower level + ) fcache.try_emplace(f, stats); + return stats; + } + else return it->second; + } + +#define ADD_DECL(name) void PredicateHeuristic::name (const Expression &e, predicate_stats_t &stats) const + ADD_DECL(VisitVariable) { + stats.variable_cntr++; + } + + ADD_DECL(VisitConstant) { + stats.constant_cntr++; + } + + ADD_DECL(VisitRealConstant) { + stats.realconstant_cntr++; + } + + ADD_DECL(VisitAddition) { + const auto& map = get_expr_to_coeff_map_in_addition(e); + stats.addition_cntr += map.size(); + for (const auto& [expr, coeff] : map) { + recHeurExpr(expr, stats); + } + } + + ADD_DECL(VisitMultiplication) { + const auto map = get_base_to_exponent_map_in_multiplication(e); + stats.multiplication_cntr += map.size(); + for (const auto& [base, exp] : map) { + recHeurExpr(base, stats); + recHeurExpr(exp, stats); + } + } + + ADD_DECL(VisitDivision) { + stats.division_cntr++; + BinaryOpHelper(e, stats); + } + + ADD_DECL(VisitLog) { + stats.log_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitAbs) { + stats.abs_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitExp) { + stats.exp_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitSqrt) { + stats.sqrt_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitPow) { + stats.pow_cntr++; + BinaryOpHelper(e, stats); + } + + ADD_DECL(VisitSin) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitCos) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitTan) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitAsin) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitAcos) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitAtan) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitAtan2) { + stats.trigonometry_cntr++; + BinaryOpHelper(e, stats); + } + + ADD_DECL(VisitSinh) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitCosh) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitTanh) { + stats.trigonometry_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitMin) { + stats.min_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitMax) { + stats.max_cntr++; + UnaryOpHelper(e, stats); + } + + ADD_DECL(VisitIfThenElse) { + stats.ifthenelse_cntr++; + const auto ite = to_if_then_else(e); + recHeurForm(ite->get_conditional_formula(), stats, false); + recHeurExpr(ite->get_then_expression(), stats); + recHeurExpr(ite->get_else_expression(), stats); + } + + ADD_DECL(VisitUninterpretedFunction) { + stats.uninterpretedfunction_cntr++; + } + +#undef ADD_DECL +#define ADD_DECL(name) void PredicateHeuristic::name (const Formula &f, predicate_stats_t &stats, const bool &inverted) const + ADD_DECL(VisitFalse) { + stats.false_cntr++; + } + + ADD_DECL(VisitTrue) { + stats.true_cntr++; + } + + ADD_DECL(VisitVariable) { + stats.variable_cntr++; + } + + ADD_DECL(VisitEqualTo) { + stats.equalto_cntr++; + BinaryOpHelper(f, stats, inverted); + } + + ADD_DECL(VisitNotEqualTo) { + stats.notequalto_cntr++; + BinaryOpHelper(f, stats, inverted); + } + + ADD_DECL(VisitGreaterThan) { + stats.inequality_cntr++; + BinaryOpHelper(f, stats, inverted); + } + + ADD_DECL(VisitGreaterThanOrEqualTo) { + stats.inequality_cntr++; + BinaryOpHelper(f, stats, inverted); + } + + ADD_DECL(VisitLessThan) { + stats.inequality_cntr++; + BinaryOpHelper(f, stats, inverted); + } + + ADD_DECL(VisitLessThanOrEqualTo) { + stats.inequality_cntr++; + BinaryOpHelper(f, stats, inverted); + } + + ADD_DECL(VisitConjunction) { + const auto& ops = get_operands(f); + stats.conjunction_cntr += ops.size(); + for (const auto& op : ops) recHeurFormCheckCache(op, stats, inverted); + } + + ADD_DECL(VisitDisjunction) { + const auto& ops = get_operands(f); + stats.disjunction_cntr += ops.size(); + for (const auto& op : ops) recHeurFormCheckCache(op, stats, inverted); + } + + ADD_DECL(VisitNegation) { + stats.negation_cntr++; + UnaryOpHelper(f, stats, !inverted); + } + + ADD_DECL(VisitForall) { + stats.forall_cntr++; + throw DREAL_RUNTIME_ERROR("Heuristics for quantifiers are currently unsupported {}", f); + } + +#undef ADD_DECL + + void PredicateHeuristic::recHeurExprCheckCache(const Expression& e, predicate_stats_t& outer_stats) const { + const auto it = ecache.find(e); + if (it == ecache.cend()) recHeurExpr(e, outer_stats); + else outer_stats += it->second; + } + + void PredicateHeuristic::recHeurExpr(const Expression& e, predicate_stats_t& stats) const { + return VisitExpression(this, e, stats); + } + + void PredicateHeuristic::recHeurFormCheckCache(const Formula& f, predicate_stats_t& outer_stats, + const bool& inverted) const { + auto& fcache = inverted ? fcache_neg : fcache_pos; + const auto it = fcache.find(f); + if (it == fcache.cend()) recHeurForm(f, outer_stats, inverted); + else outer_stats += it->second; + } + + void PredicateHeuristic::recHeurForm(const Formula& f, predicate_stats_t& stats, const bool& inverted) const { + return VisitFormula(this, f, stats, inverted); + } + + void PredicateHeuristic::UnaryOpHelper(const Expression& e, predicate_stats_t& stats) const { + return recHeurExpr(get_argument(e), stats); + } + + void PredicateHeuristic::UnaryOpHelper(const Formula& f, predicate_stats_t& stats, const bool& inverted) const { + return recHeurForm(get_operand(f), stats, inverted); + } + + void PredicateHeuristic::BinaryOpHelper(const Expression& e, predicate_stats_t& stats) const { + const auto b = to_binary(e); + recHeurExpr(b->get_first_argument(), stats); + recHeurExpr(b->get_second_argument(), stats); + } + + void PredicateHeuristic::BinaryOpHelper(const Formula& f, predicate_stats_t& stats, const bool& inverted) const { + const auto b = to_relational(f); + recHeurExpr(b->get_lhs_expression(), stats); + recHeurExpr(b->get_rhs_expression(), stats); + } +} // namespace dreal diff --git a/src/dreal/util/predicate_heuristic.h b/src/dreal/util/predicate_heuristic.h new file mode 100644 index 000000000..f64e90966 --- /dev/null +++ b/src/dreal/util/predicate_heuristic.h @@ -0,0 +1,225 @@ +// +// Created by Kunal Sheth on 2/19/25. +// + +#ifndef predicate_heuristic_H +#define predicate_heuristic_H + +#include "dreal/symbolic/symbolic.h" +#include "dreal/util/box.h" + +namespace dreal +{ + class PredicateHeuristic + { + // todo: unit test this!!! + + public: + typedef struct + { + double raw_score; + unsigned unique_variables; + unsigned variable_cntr; + unsigned constant_cntr; + unsigned realconstant_cntr; + unsigned addition_cntr; + unsigned multiplication_cntr; + unsigned division_cntr; + unsigned log_cntr; + unsigned abs_cntr; + unsigned exp_cntr; + unsigned sqrt_cntr; + unsigned pow_cntr; + unsigned trigonometry_cntr; + unsigned min_cntr; + unsigned max_cntr; + unsigned ifthenelse_cntr; + unsigned uninterpretedfunction_cntr; + unsigned false_cntr; + unsigned true_cntr; + unsigned equalto_cntr; + unsigned notequalto_cntr; + unsigned inequality_cntr; + unsigned conjunction_cntr; + unsigned disjunction_cntr; + unsigned negation_cntr; + unsigned forall_cntr; + } predicate_stats_t; + + static std::string predicate_stats_csv_header(const std::string& prefix) { + std::ostringstream s; + s << prefix << "raw_score,"; + s << prefix << "unique_variables,"; + s << prefix << "variable_cntr,"; + s << prefix << "constant_cntr,"; + s << prefix << "realconstant_cntr,"; + s << prefix << "addition_cntr,"; + s << prefix << "multiplication_cntr,"; + s << prefix << "division_cntr,"; + s << prefix << "log_cntr,"; + s << prefix << "abs_cntr,"; + s << prefix << "exp_cntr,"; + s << prefix << "sqrt_cntr,"; + s << prefix << "pow_cntr,"; + s << prefix << "trigonometry_cntr,"; + s << prefix << "min_cntr,"; + s << prefix << "max_cntr,"; + s << prefix << "ifthenelse_cntr,"; + s << prefix << "uninterpretedfunction_cntr,"; + s << prefix << "false_cntr,"; + s << prefix << "true_cntr,"; + s << prefix << "equalto_cntr,"; + s << prefix << "notequalto_cntr,"; + s << prefix << "inequality_cntr,"; + s << prefix << "conjunction_cntr,"; + s << prefix << "disjunction_cntr,"; + s << prefix << "negation_cntr,"; + s << prefix << "forall_cntr"; + return s.str(); + } + + predicate_stats_t collect_statistics(const Expression& e); + predicate_stats_t collect_statistics(const Formula& f, bool inverted = false); + + private: + // must be reference to const bool because of `drake::symbolic::VisitExpression...` template requires it. +#define ADD_DECL(name) void name (const Expression &e, predicate_stats_t &stats) const + ADD_DECL(VisitVariable); + ADD_DECL(VisitConstant); + ADD_DECL(VisitRealConstant); + ADD_DECL(VisitAddition); + ADD_DECL(VisitMultiplication); + ADD_DECL(VisitDivision); + ADD_DECL(VisitLog); + ADD_DECL(VisitAbs); + ADD_DECL(VisitExp); + ADD_DECL(VisitSqrt); + ADD_DECL(VisitPow); + ADD_DECL(VisitSin); + ADD_DECL(VisitCos); + ADD_DECL(VisitTan); + ADD_DECL(VisitAsin); + ADD_DECL(VisitAcos); + ADD_DECL(VisitAtan); + ADD_DECL(VisitAtan2); + ADD_DECL(VisitSinh); + ADD_DECL(VisitCosh); + ADD_DECL(VisitTanh); + ADD_DECL(VisitMin); + ADD_DECL(VisitMax); + ADD_DECL(VisitIfThenElse); + ADD_DECL(VisitUninterpretedFunction); +#undef ADD_DECL + + // must be reference to const bool because of `drake::symbolic::VisitExpression...` template requires it. +#define ADD_DECL(name) void name (const Formula &e, predicate_stats_t &stats, const bool &inverted) const + ADD_DECL(VisitFalse); + ADD_DECL(VisitTrue); + ADD_DECL(VisitVariable); + ADD_DECL(VisitEqualTo); + ADD_DECL(VisitNotEqualTo); + ADD_DECL(VisitGreaterThan); + ADD_DECL(VisitGreaterThanOrEqualTo); + ADD_DECL(VisitLessThan); + ADD_DECL(VisitLessThanOrEqualTo); + ADD_DECL(VisitConjunction); + ADD_DECL(VisitDisjunction); + ADD_DECL(VisitNegation); + ADD_DECL(VisitForall); +#undef VISIT_DECL +#undef ADD_DECL +#undef VISIT_AND_ADD_DECL + + std::unordered_map fcache_pos; + std::unordered_map fcache_neg; + std::unordered_map ecache; + + void recHeurExprCheckCache(const Expression& e, predicate_stats_t& stats) const; + void recHeurExpr(const Expression& e, predicate_stats_t& stats) const; + + void recHeurFormCheckCache(const Formula& f, predicate_stats_t& stats, const bool& inverted) const; + void recHeurForm(const Formula& f, predicate_stats_t& stats, const bool& inverted) const; + + void UnaryOpHelper(const Expression& e, predicate_stats_t& stats) const; + void UnaryOpHelper(const Formula& f, predicate_stats_t& stats, const bool& inverted) const; + void BinaryOpHelper(const Expression& e, predicate_stats_t& stats) const; + void BinaryOpHelper(const Formula& f, predicate_stats_t& stats, const bool& inverted) const; + void NaryOpHelper(const Formula& f, predicate_stats_t& stats, bool inverted) const; + + friend void drake::symbolic::VisitExpression( + const PredicateHeuristic*, const Expression&, predicate_stats_t& + ); + friend void drake::symbolic::VisitFormula( + const PredicateHeuristic*, const Formula&, predicate_stats_t&, const bool& + ); + }; + + inline std::ostream& operator<<(std::ostream& os, const PredicateHeuristic::predicate_stats_t& stats) { + os << stats.raw_score << ','; + os << stats.unique_variables << ','; + os << stats.variable_cntr << ','; + os << stats.constant_cntr << ','; + os << stats.realconstant_cntr << ','; + os << stats.addition_cntr << ','; + os << stats.multiplication_cntr << ','; + os << stats.division_cntr << ','; + os << stats.log_cntr << ','; + os << stats.abs_cntr << ','; + os << stats.exp_cntr << ','; + os << stats.sqrt_cntr << ','; + os << stats.pow_cntr << ','; + os << stats.trigonometry_cntr << ','; + os << stats.min_cntr << ','; + os << stats.max_cntr << ','; + os << stats.ifthenelse_cntr << ','; + os << stats.uninterpretedfunction_cntr << ','; + os << stats.false_cntr << ','; + os << stats.true_cntr << ','; + os << stats.equalto_cntr << ','; + os << stats.notequalto_cntr << ','; + os << stats.inequality_cntr << ','; + os << stats.conjunction_cntr << ','; + os << stats.disjunction_cntr << ','; + os << stats.negation_cntr << ','; + os << stats.forall_cntr; + return os; + } + + inline PredicateHeuristic::predicate_stats_t& operator+=( + PredicateHeuristic::predicate_stats_t& lhs, + const PredicateHeuristic::predicate_stats_t& rhs + ) { + lhs.raw_score += rhs.raw_score; + lhs.unique_variables += rhs.unique_variables; + lhs.variable_cntr += rhs.variable_cntr; + lhs.constant_cntr += rhs.constant_cntr; + lhs.realconstant_cntr += rhs.realconstant_cntr; + lhs.addition_cntr += rhs.addition_cntr; + lhs.multiplication_cntr += rhs.multiplication_cntr; + lhs.division_cntr += rhs.division_cntr; + lhs.log_cntr += rhs.log_cntr; + lhs.abs_cntr += rhs.abs_cntr; + lhs.exp_cntr += rhs.exp_cntr; + lhs.sqrt_cntr += rhs.sqrt_cntr; + lhs.pow_cntr += rhs.pow_cntr; + lhs.trigonometry_cntr += rhs.trigonometry_cntr; + lhs.min_cntr += rhs.min_cntr; + lhs.max_cntr += rhs.max_cntr; + lhs.ifthenelse_cntr += rhs.ifthenelse_cntr; + lhs.uninterpretedfunction_cntr += rhs.uninterpretedfunction_cntr; + lhs.false_cntr += rhs.false_cntr; + lhs.true_cntr += rhs.true_cntr; + lhs.equalto_cntr += rhs.equalto_cntr; + lhs.notequalto_cntr += rhs.notequalto_cntr; + lhs.inequality_cntr += rhs.inequality_cntr; + lhs.conjunction_cntr += rhs.conjunction_cntr; + lhs.disjunction_cntr += rhs.disjunction_cntr; + lhs.negation_cntr += rhs.negation_cntr; + lhs.forall_cntr += rhs.forall_cntr; + return lhs; + } +} // namespace dreal + +// * learned regression model here * + +#endif //predicate_heuristic_H From b4d34916a258b975ee900772531447c14425f1a4 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:44:17 -0700 Subject: [PATCH 07/79] Plumbing for efficient/cached heuristics collection. --- src/dreal/util/predicate_normalizer.cc | 8 ++++++++ src/dreal/util/predicate_normalizer.h | 4 ++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index af045bfce..7a496d88f 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -16,6 +16,8 @@ #include "dreal/util/predicate_normalizer.h" #include +#include "logging.h" + namespace dreal { std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> @@ -66,18 +68,24 @@ namespace dreal Formula PredicateNormalizer::VisitEqualTo(const Formula& f) { trie.insert(f); trie.insert(!f); + heuristic.collect_statistics(f); + heuristic.collect_statistics(!f); return f; } Formula PredicateNormalizer::VisitLessThan(const Formula& f) { trie.insert(f); trie.insert(!f); + heuristic.collect_statistics(f); + heuristic.collect_statistics(!f); return f; } Formula PredicateNormalizer::VisitLessThanOrEqualTo(const Formula& f) { trie.insert(f); trie.insert(!f); + heuristic.collect_statistics(f); + heuristic.collect_statistics(!f); return f; } diff --git a/src/dreal/util/predicate_normalizer.h b/src/dreal/util/predicate_normalizer.h index f97769d96..57c63ee47 100644 --- a/src/dreal/util/predicate_normalizer.h +++ b/src/dreal/util/predicate_normalizer.h @@ -19,7 +19,7 @@ #include #include -#include "predicate_ranker.h" +#include "predicate_heuristic.h" #include "dreal/symbolic/symbolic.h" namespace dreal @@ -38,7 +38,7 @@ namespace dreal // useless heuristic // uint64_t EstimateMatchingCost(const std::set& f); - PredicateRanker ranker; // todo: make private? + PredicateHeuristic heuristic; // todo: make private? private: Formula VisitFalse(const Formula& f); From 8c076f404587ea7e02e455158fd8a94c3684bc57 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:44:38 -0700 Subject: [PATCH 08/79] Fruitless attempt at optimizing `attempt_substitution()`. --- .../pattern_matching/substitutions_map.cc | 53 ++++++++++++++++++- .../util/pattern_matching/substitutions_map.h | 5 +- 2 files changed, 53 insertions(+), 5 deletions(-) diff --git a/src/dreal/util/pattern_matching/substitutions_map.cc b/src/dreal/util/pattern_matching/substitutions_map.cc index f3d66d8f0..453de2273 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.cc +++ b/src/dreal/util/pattern_matching/substitutions_map.cc @@ -5,6 +5,7 @@ #include "substitutions_map.h" #include +#include #include namespace dreal @@ -45,8 +46,8 @@ namespace dreal const bool has_aP = it_aP != bwd.end(); if (!has_a && !has_aP) { // do insert - fwd[a] = aP; - bwd[aP] = a; + fwd.try_emplace(a, aP); + bwd.try_emplace(aP, a); insertion_stack.back().emplace_back(a, aP); return true; } @@ -66,6 +67,54 @@ namespace dreal return false; } + // this is literally the hottest function in the entire code rn, when we pattern match aggressively. -KS + // ended up being actually slower?? a little. + /* + bool substitutions_map::attempt_substitution(const Variable& a, const Variable& aP) { + if (a.get_type() != aP.get_type()) return false; + + // Attempt to find 'a' and 'aP' just once + const auto [a_iterator, a_was_inserted] = fwd.try_emplace(a, aP); + if (a_was_inserted) { + // Only try to insert into bwd if we successfully inserted into fwd + const auto [aP_iterator, aP_was_inserted] = bwd.try_emplace(aP, a); + if (aP_was_inserted) { + insertion_stack.back().emplace_back(a, aP); + return true; + } + else { + // Rollback fwd insertion if bwd insertion failed + fwd.erase(a_iterator); + return false; + } + } + else { + // Check if existing values match + const auto aP_iterator = bwd.find(aP); + if ( + aP_iterator != bwd.end() && + a_iterator->second.equal_to(aP) && + aP_iterator->second.equal_to(a) + ) { + return true; + } + + DREAL_LOG_TRACE( + "Substitution failed. New 'a' {} is already {}, while new 'aP' {} is already {}.", + a.get_name(), aP_iterator != bwd.end() ? aP_iterator->second.get_name() : "", + aP.get_name(), a_iterator->second.get_name() + ); + return false; + } + DREAL_UNREACHABLE(); + } + */ + + size_t substitutions_map::size() const { + DREAL_ASSERT(fwd.size() == bwd.size()); + return fwd.size(); + } + bool operator==(const substitutions_map& lhs, const substitutions_map& rhs) { if (lhs.fwd.size() != rhs.fwd.size()) return false; if (lhs.bwd.size() != rhs.bwd.size()) return false; diff --git a/src/dreal/util/pattern_matching/substitutions_map.h b/src/dreal/util/pattern_matching/substitutions_map.h index aeb412e38..57a0c6781 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.h +++ b/src/dreal/util/pattern_matching/substitutions_map.h @@ -4,11 +4,8 @@ #ifndef substitutions_mapH #define substitutions_mapH -#include #include -#include #include -#include #include namespace dreal @@ -47,6 +44,8 @@ namespace dreal bool attempt_substitution(const Variable& a, const Variable& aP); + size_t size() const; + static bool verify_substitutions(const substitutions_map& subs) { return true; } // legacy friend bool operator==(const substitutions_map& lhs, const substitutions_map& rhs); From c505d6cc9c06539bbb8a9b57604f10a6cf5d244e Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:47:26 -0700 Subject: [PATCH 09/79] Write `make_conjunction_SKIP_CHECKS_KUNAL_HACK()` to slightly speed up creation on conjunctions for learned clauses. --- .../dreal/symbolic/symbolic_formula.cc | 16 ++++++++++++++++ .../dreal/symbolic/symbolic_formula.h | 2 ++ 2 files changed, 18 insertions(+) diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc index a8094dc73..b01857610 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc @@ -223,6 +223,22 @@ Formula Formula::make_conjunction(Formula& f1, const Formula& f2) { return f1 = Formula{new FormulaAnd(set{f1, f2})}; } +Formula make_conjunction_SKIP_CHECKS_KUNAL_HACK(set formulas) { // copy because move later. + for (const Formula& f : formulas) { + DREAL_ASSERT(!is_false(f)); + DREAL_ASSERT(!is_true(f)); + DREAL_ASSERT(!is_conjunction(f)); + } + if (formulas.empty()) { + // ⋀{} = True + return Formula::True(); + } + if (formulas.size() == 1) { + return *(formulas.begin()); + } + return Formula{new FormulaAnd(std::move(formulas))}; +} + Formula make_conjunction(const set& formulas) { set operands; for (const Formula& f : formulas) { diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h index 22a593d6d..8bdf48daf 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h @@ -256,6 +256,7 @@ class Formula { friend FormulaCell; friend Formula forall(const Variables& vars, const Formula& f); friend Formula make_conjunction(const std::set& formulas); + friend Formula make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::set formulas); friend Formula make_disjunction(const std::set& formulas); friend Formula operator!(const Formula& f); friend Formula operator==(const Expression& e1, const Expression& e2); @@ -289,6 +290,7 @@ Formula forall(const Variables& vars, const Formula& f); * f₂ ∧ f₃}) returns f₁ ∧ f₂ ∧ f₃. */ Formula make_conjunction(const std::set& formulas); +Formula make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::set formulas); Formula operator&&(const Formula& f1, const Formula& f2); Formula operator&&(const Formula& f1, Formula&& f2); Formula operator&&(Formula&& f1, const Formula& f2); From e39067a0184f1c11fceb04d3df2a6346ecaa2bfd Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:50:29 -0700 Subject: [PATCH 10/79] sat_solver.cc cleanup. --- src/dreal/solver/sat_solver.cc | 44 +++++++++++++++++----------------- src/dreal/solver/sat_solver.h | 5 +++- 2 files changed, 26 insertions(+), 23 deletions(-) diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index c3913326e..28be7abc6 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -38,9 +38,10 @@ SatSolver::SatSolver(const Config& config) : cadical(new CaDiCaL::Solver) { cadical->set("seed", config.random_seed()); DREAL_LOG_DEBUG("SatSolver::Set Random Seed {}", config.random_seed()); } - cadical->set("phase", static_cast(config.sat_default_phase())); - DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", - config.sat_default_phase()); + // this actually doesn't work lol. + // cadical->set("phase", static_cast(config.sat_default_phase())); + // DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", + // config.sat_default_phase()); // todo: look into this? want to absolutely minimize calls to theory solver. // eliminate as many variables as possible. ? @@ -65,7 +66,7 @@ void SatSolver::AddFormula(const Formula& f) { } void SatSolver::AddLearnedClause(const set& conflicting_conjunction, const Box& box) { - // audit(!make_conjunction(conflicting_conjunction), box); // todo: gate. + if (DREAL_LOG_DEBUG_ENABLED) audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(conflicting_conjunction), box); for (const Formula& f : conflicting_conjunction) { AddLiteral(!predicate_abstractor_.Convert(f)); } @@ -82,47 +83,45 @@ void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { is_conjunction(condition) ? get_operands(condition) : set{condition} ) { // todo: audit? currently can't because it is already predicate_abstractor-ed - // std::cout << "AddBox: " << lit << std::endl; AddLiteral(lit); cadical->add(0); } } } -void SatSolver::AddLearnedClausePattern( - PredicateNormalizer &pn, +PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( + PredicateNormalizer& pn, const set& base_conflict, const Box& base_box ) { // todo: clean this a little.. avoid duplicates. but some clauses aren't in the trie and don't match to themselves? - // AddLearnedClause(base_conflict, base_box); - const auto all_related_conflicts = pn.FindSimilar(base_conflict); + const auto [all_related_conflicts, match_statistics] = pn.FindSimilar(base_conflict); DREAL_ASSERT(!all_related_conflicts.empty()); // should AT LEAST match with itself. - std::cout << "Matched " << all_related_conflicts.size() << " for the price of 1." << std::endl; + for (const auto& [conflict_clause, subs] : all_related_conflicts) { - Box conflict_box = substitutions_map_node::apply_substitution(base_box, subs, true); + Box conflict_box = substitutions_map::apply_substitution(base_box, subs, false); - // audit(!make_conjunction(conflict_clause), conflict_box); // todo: gate. + if (DREAL_LOG_DEBUG_ENABLED) { // todo: better gate. + std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); + audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), conflict_box); + } // a & b & c & ... ==> ~(x & y & z & ...) // ~(a & b & c & ...) | ~(x & y & z & ...) // ~a | ~b | ~c | ... | ~x | ~y | ~z | ... for (const auto& v : conflict_box.variables()) { - if (v.get_type() == Variable::Type::BOOLEAN) continue; + // if (v.get_type() == Variable::Type::BOOLEAN) continue; // todo: commented, because maybe unsound???? const auto condition = MakeSatIntervalVar(pn, v, conflict_box[v]); if (is_true(condition)) continue; - for ( - const auto& lit : - is_conjunction(condition) ? get_operands(condition) : set{condition} - ) { - AddLiteral(!lit); // already predicate-converted. - } - } - for (const Formula& f : conflict_clause) { - AddLiteral(!predicate_abstractor_.Convert(f)); + else if (!is_conjunction(condition)) AddLiteral(!condition); // already predicate-converted. + else for (const auto& lit : get_operands(condition)) AddLiteral(!lit); } + // ==> + for (const Formula& f : conflict_clause) AddLiteral(!predicate_abstractor_.Convert(f)); + cadical->add(0); } + return match_statistics; } void SatSolver::AddClause(const Formula& f) { @@ -288,6 +287,7 @@ void SatSolver::MakeSatVar(const Variable& var) { Formula SatSolver::MakeSatIntervalVar(PredicateNormalizer &pn, const Variable& var, const Box::Interval& intv) { DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); + DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVar({} ∈ {})", fmt::streamed(var), fmt::streamed(intv)); auto ub_pred = Formula::True(); if (isfinite(intv.ub())) { ub_pred = var <= intv.ub(); // TODO: figure out if this is inclusive or exclusive. diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 027718f26..d525e038e 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -69,7 +69,10 @@ class SatSolver { /// Given a @p formulas = {f₁, ..., fₙ}, adds a clause (¬f₁ ∨ ... ∨ ¬ fₙ) to /// the solver. void AddLearnedClause(const std::set& conflicting_conjunction, const Box& box); - void AddLearnedClausePattern(PredicateNormalizer& pn, const std::set& base_conflict, const Box& base_box); + PatternMatchingTrie::matching_stats_t AddLearnedClausePattern( + PredicateNormalizer& pn, + const std::set& base_conflict, + const Box& base_box); void AddBox(PredicateNormalizer& pn, const Box& base_box); Formula MakeSatIntervalVar(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv); From 3282241239237d1a84bfdef2e6b148d5a16c9a09 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 16:51:32 -0700 Subject: [PATCH 11/79] Bolt in statistics, telemetry, and logging for benchmarking run - April 10, 2025. --- CMakeLists.txt | 2 + src/dreal/solver/context_impl.cc | 191 ++++++++++++++++++++++++++----- 2 files changed, 163 insertions(+), 30 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ac33325f0..0c5043765 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,6 +52,8 @@ set(LIBCDS_HOME "${PROJECT_SOURCE_DIR}/src/third_party/com_github_khizmax_libcds set(JSON_HOME "${PROJECT_SOURCE_DIR}/src/third_party/com_github_nlohmann_json/") set(PICOSAT_HOME "${PROJECT_SOURCE_DIR}/src/third_party/com_github_dreal-deps_picosat/") +unset(DREAL_SOURCES) +unset(DREAL_SOURCES CACHE) file(GLOB_RECURSE DREAL_SOURCES "${PROJECT_SOURCE_DIR}/src/dreal/*/**.cc" "${PROJECT_SOURCE_DIR}/src/dreal/*/**.yy" diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index e9f287e14..0d3bc22dd 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -19,12 +19,14 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include @@ -131,24 +133,84 @@ void Context::Impl::Assert(const Formula& f) { optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { + //////////////////////////////////////////////////////////////////////////////// + std::ofstream myfile; + std::string file_name; + { + std::ostringstream s; + s << "./kunal_paper_data_epoch"; + s << std::chrono::system_clock::now().time_since_epoch().count(); + + // Seed random number generator with high-resolution clock + static std::mt19937 rng(std::chrono::high_resolution_clock::now().time_since_epoch().count()); + static std::uniform_int_distribution dist(1000, 9999); // random 4-digit numbers + + s << "_random" << dist(rng) << dist(rng) << dist(rng) << dist(rng);; + s << ".csv"; + file_name = s.str(); + + std::cout << "Logging statistics to " << file_name << std::endl; + std::cerr << "Logging statistics to " << file_name << std::endl; + } + myfile.open(file_name, std::ios::app); + if (!myfile) throw DREAL_RUNTIME_ERROR("Failed to open log file"); + + struct + { + unsigned box_continuous_count; + unsigned box_integer_count; + unsigned box_boolean_count; + unsigned assertions_size; + PredicateHeuristic::predicate_stats_t assertions_stats; + double theory_checksat_ms; + unsigned lemma_size; + PredicateHeuristic::predicate_stats_t lemma_stats; + uint64_t estimated_matching_cost; + double pattern_match_ms; + PatternMatchingTrie::matching_stats_t pattern_matching_stats; + } kunal_paper_data = {0}; + //////////////////////////////////////////////////////////////////////////////// + DREAL_LOG_DEBUG("ContextImpl::CheckSatCore()"); DREAL_LOG_TRACE("ContextImpl::CheckSat: Box =\n{}", box); - if (box.empty()) { - return {}; - } + if (box.empty()) return {}; // If false ∈ stack, it's UNSAT. - for (const auto& f : stack.get_vector()) { - if (is_false(f)) { - return {}; - } - } + for (const auto& f : stack.get_vector()) if (is_false(f)) return {}; // If stack = ∅ or stack = {true}, it's trivially SAT. if (stack.empty() || (stack.size() == 1 && is_true(stack.first()))) { DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Found Model\n{}", box); return box; } - sat_solver->AddBox(pn_, box); + //////////////////////////////////////////////////////////////////////////////// + { + std::ostringstream s; + s << "box_continuous_count,"; + s << "box_integer_count,"; + s << "box_boolean_count,"; + s << "assertions_size,"; + s << PredicateHeuristic::predicate_stats_csv_header("assertions_stats_") << ','; + s << "theory_checksat_ms,"; + s << "lemma_size,"; + s << PredicateHeuristic::predicate_stats_csv_header("lemma_stats_") << ','; + s << "estimated_matching_cost,"; + s << "pattern_match_ms,"; + s << PatternMatchingTrie::matching_stats_csv_header("pattern_matching_stats_"); + myfile << s.str() << std::endl; + } + //////////////////////////////////////////////////////////////////////////////// + + sat_solver->AddBox(pn_, box); // SKIPS Boolean Variables ✔ + //////////////////////////////////////////////////////////////////////////////// + for (const auto & variable : box.variables()) { + if (variable.get_type() == Variable::Type::CONTINUOUS) kunal_paper_data.box_continuous_count++; + else if (variable.get_type() == Variable::Type::INTEGER) kunal_paper_data.box_integer_count++; + else if (variable.get_type() == Variable::Type::BOOLEAN) kunal_paper_data.box_boolean_count++; + else if (variable.get_type() == Variable::Type::BINARY) kunal_paper_data.box_boolean_count++; + else DREAL_UNREACHABLE(); + } + //////////////////////////////////////////////////////////////////////////////// + while (true) { // Note that 'DREAL_CHECK_INTERRUPT' is only defined in setup.py, // when we build dReal python package. @@ -162,24 +224,41 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const auto optional_model = sat_solver->CheckSat(); if (optional_model) { const vector>& boolean_model{optional_model->first}; - for (const pair& p : boolean_model) { - box[p.first] = p.second ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 - } const vector>& theory_model{optional_model->second}; + + for (const auto& [sat_var, assignment] : boolean_model) + box[sat_var] = assignment ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 + if (!theory_model.empty()) { // SAT from SATSolver. DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Sat Check = SAT"); vector assertions; assertions.reserve(theory_model.size()); - for (const pair& p : theory_model) { - assertions.push_back(p.second ? sat_solver->theory_literal(p.first) - : !sat_solver->theory_literal(p.first)); - } - if (theory_solver_.CheckSat(box, assertions)) { + for (const auto& [sat_var, assignment] : theory_model) + assertions.emplace_back( + assignment ? sat_solver->theory_literal(sat_var) : !sat_solver->theory_literal(sat_var) + ); + + //////////////////////////////////////////////////////////////////////////////// + kunal_paper_data.assertions_size = assertions.size(); + + const auto ranking_start1 = std::chrono::high_resolution_clock::now(); + std::set assertions_set(assertions.begin(), assertions.end()); + kunal_paper_data.assertions_stats = pn_.heuristic.collect_statistics(make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(assertions_set))); + const auto ranking_end1 = std::chrono::high_resolution_clock::now(); + const std::chrono::duration ranking_elapsed1 = ranking_end1 - ranking_start1; + + const auto tscs_start = std::chrono::high_resolution_clock::now(); + const auto tscs_result = theory_solver_.CheckSat(box, assertions); + const auto tscs_end = std::chrono::high_resolution_clock::now(); + const std::chrono::duration tscs_elapsed = tscs_end - tscs_start; + kunal_paper_data.theory_checksat_ms = tscs_elapsed.count(); + //////////////////////////////////////////////////////////////////////////////// + + if (tscs_result) { // SAT from TheorySolver. - DREAL_LOG_DEBUG( - "ContextImpl::CheckSatCore() - Theory Check = delta-SAT"); + DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Theory Check = delta-SAT"); Box model{theory_solver_.GetModel()}; return model; } else { @@ -187,25 +266,77 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Theory Check = UNSAT"); const set& explanation{theory_solver_.GetExplanation()}; DREAL_LOG_DEBUG( - "ContextImpl::CheckSatCore() - size of explanation = {} - stack " - "size = {}", + "ContextImpl::CheckSatCore() - size of explanation = {} - stack size = {}", explanation.size(), stack.get_vector().size()); - sat_solver->AddLearnedClausePattern(pn_, explanation, box); + //////////////////////////////////////////////////////////////////////////////// + kunal_paper_data.lemma_size = explanation.size(); + + const auto ranking_start2 = std::chrono::high_resolution_clock::now(); + kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation)); + const auto ranking_end2 = std::chrono::high_resolution_clock::now(); + const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; + + // const auto emc_start = std::chrono::high_resolution_clock::now(); + // kunal_paper_data.estimated_matching_cost = pn_.EstimateMatchingCost(explanation); + // const auto emc_end = std::chrono::high_resolution_clock::now(); + // const std::chrono::duration emc_elapsed = emc_end - emc_start; + DREAL_LOG_INFO("Total lemma info: asserts={}, clause={}, ranking_ms={}", + kunal_paper_data.assertions_size, kunal_paper_data.lemma_size, + (ranking_elapsed1 + ranking_elapsed2).count() + ); + if (/* we think its worth it? */ true) { + const auto alcp_start = std::chrono::high_resolution_clock::now(); + const auto alcp_result = sat_solver->AddLearnedClausePattern(pn_, explanation, box); + const auto alcp_end = std::chrono::high_resolution_clock::now(); + const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; + + kunal_paper_data.pattern_match_ms = alcp_elapsed.count(); + kunal_paper_data.pattern_matching_stats = alcp_result; + + const auto bnb_lpms = 1 / tscs_elapsed.count(); + const auto pm_lpms = alcp_result.matches / alcp_elapsed.count(); + DREAL_LOG_INFO("Worth it? {} \t B&B {} lpms v.s. PM {} lpms", + bnb_lpms >= pm_lpms ? "NO" : "YES", bnb_lpms, pm_lpms); + } else { + std::cout << "Adding lemma" << std::endl; + sat_solver->AddLearnedClause(explanation, box); + } + //////////////////////////////////////////////////////////////////////////////// + + /////////////////////////////////////////////////////////////////////////////////// + { + std::ostringstream s; + s << kunal_paper_data.box_continuous_count << ','; + s << kunal_paper_data.box_integer_count << ','; + s << kunal_paper_data.box_boolean_count << ','; + s << kunal_paper_data.assertions_size << ','; + s << kunal_paper_data.assertions_stats << ','; + s << kunal_paper_data.theory_checksat_ms << ','; + s << kunal_paper_data.lemma_size << ','; + s << kunal_paper_data.lemma_stats << ','; + s << kunal_paper_data.estimated_matching_cost << ','; + s << kunal_paper_data.pattern_match_ms << ','; + s << kunal_paper_data.pattern_matching_stats; + myfile << s.str() << std::endl; // also flushes + + typeof(kunal_paper_data) reset_data{0}; + reset_data.box_boolean_count = kunal_paper_data.box_boolean_count; + reset_data.box_integer_count = kunal_paper_data.box_integer_count; + reset_data.box_continuous_count = kunal_paper_data.box_continuous_count; + kunal_paper_data = reset_data; + } + /////////////////////////////////////////////////////////////////////////////////// if (DREAL_LOG_TRACE_ENABLED) { - for (const auto& f_i : stack.get_vector()) { + for (const auto& f_i : stack.get_vector()) DREAL_LOG_TRACE("ContextImpl::CheckSatCore: Stack {}", f_i); - } - for (const auto& f_i : explanation) { + for (const auto& f_i : explanation) DREAL_LOG_TRACE("ContextImpl::CheckSatCore: Explanation {}", f_i); - } } } - } else { - return box; - } - } else { + } else /* theory_model.empty() */ return box; + } else /* !optional_model */ { // UNSAT from SATSolver. Escape the loop. DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Sat Check = UNSAT"); return {}; From b86a84f097caa1012d0f74933085f9bf24943420 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 20:05:32 -0700 Subject: [PATCH 12/79] Tune load factors and preallocations for substitutions_map's internal hash tables. --- .../util/pattern_matching/pattern_matching_trie.h | 4 ++-- .../pattern_matching_trie_general.cc | 6 ++++-- .../util/pattern_matching/substitutions_map.cc | 15 +++++++++++++++ .../util/pattern_matching/substitutions_map.h | 5 +++++ 4 files changed, 26 insertions(+), 4 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index ea9bf93fc..cc62ca8f5 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -48,7 +48,7 @@ namespace dreal [[nodiscard]] std::pair>, matching_stats_t> find_matches( const Formula& f ) const { - substitutions_map s; + substitutions_map s(f.GetFreeVariables().size()); return find_matches(f, s); } @@ -60,7 +60,7 @@ namespace dreal [[nodiscard]] std::pair>, matching_stats_t> find_matches( const Expression& e ) const { - substitutions_map s; + substitutions_map s(e.GetVariables().size()); return find_matches(e, s); } diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index a90b24ab7..37e064acc 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -60,7 +60,10 @@ namespace dreal }; }; - substitutions_map substitutions; + size_t sub_preallocations=0; + for (const auto & literal : literals) sub_preallocations += literal.GetFreeVariables().size(); + substitutions_map substitutions(sub_preallocations); + recMatchForm(*ibegin, f_root, substitutions, match_next_literal(ibegin), partial_matches, misses); DREAL_ASSERT(result.size() == stats.matches); DREAL_LOG_INFO("Found {} matches with {} misses.", stats.matches, stats.misses); @@ -108,7 +111,6 @@ namespace dreal ) const { const auto init_size = substitutions.size(); DREAL_LOG_TRACE("Finding matches for expression {}", fmt::streamed(e)); - substitutions_map empty; matching_stats_t stats = {0}; std::vector> match_vec; recMatchExpr( diff --git a/src/dreal/util/pattern_matching/substitutions_map.cc b/src/dreal/util/pattern_matching/substitutions_map.cc index 453de2273..5b5880549 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.cc +++ b/src/dreal/util/pattern_matching/substitutions_map.cc @@ -10,6 +10,15 @@ namespace dreal { + substitutions_map::substitutions_map() { + fwd.max_load_factor(0.25); + bwd.max_load_factor(0.25); + } + + substitutions_map::substitutions_map(const size_t reserved_size) : substitutions_map() { + reserve(reserved_size); + } + Box substitutions_map::apply_substitution( const Box& b, const substitutions_map& subs, bool backward ) { @@ -115,6 +124,12 @@ namespace dreal return fwd.size(); } + void substitutions_map::reserve(const size_t n) { + fwd.reserve(n); + bwd.reserve(n); + insertion_stack.reserve(n); + } + bool operator==(const substitutions_map& lhs, const substitutions_map& rhs) { if (lhs.fwd.size() != rhs.fwd.size()) return false; if (lhs.bwd.size() != rhs.bwd.size()) return false; diff --git a/src/dreal/util/pattern_matching/substitutions_map.h b/src/dreal/util/pattern_matching/substitutions_map.h index 57a0c6781..6815c1052 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.h +++ b/src/dreal/util/pattern_matching/substitutions_map.h @@ -18,6 +18,9 @@ namespace dreal std::vector>> insertion_stack{1}; public: + substitutions_map(); + explicit substitutions_map(size_t reserve); + template [[nodiscard]] static T apply_substitution( const T& f, const substitutions_map& subs, bool backward @@ -46,6 +49,8 @@ namespace dreal size_t size() const; + void reserve(size_t n); + static bool verify_substitutions(const substitutions_map& subs) { return true; } // legacy friend bool operator==(const substitutions_map& lhs, const substitutions_map& rhs); From ef097f170b74315c862d8ab742d88646e1c90e3a Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 22:02:05 -0700 Subject: [PATCH 13/79] Add trained 'WORTH IT' heuristic linear regression model. --- .idea/misc.xml | 1 + src/dreal/solver/context_impl.cc | 35 +++++--- src/dreal/util/predicate_heuristic.h | 2 - .../util/predicate_heuristic_trained_model.h | 83 +++++++++++++++++++ 4 files changed, 106 insertions(+), 15 deletions(-) create mode 100644 src/dreal/util/predicate_heuristic_trained_model.h diff --git a/.idea/misc.xml b/.idea/misc.xml index 808f1d1a0..f9ee57f05 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -12,6 +12,7 @@ + \ No newline at end of file diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 0d3bc22dd..bae1d6bc4 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -27,6 +27,7 @@ #include #include #include +#include #include @@ -274,18 +275,15 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const auto ranking_start2 = std::chrono::high_resolution_clock::now(); kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation)); + const double predicted_log2_worth_it = WORTH_IT_REGRESSION_MODEL(kunal_paper_data); const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; - // const auto emc_start = std::chrono::high_resolution_clock::now(); - // kunal_paper_data.estimated_matching_cost = pn_.EstimateMatchingCost(explanation); - // const auto emc_end = std::chrono::high_resolution_clock::now(); - // const std::chrono::duration emc_elapsed = emc_end - emc_start; - DREAL_LOG_INFO("Total lemma info: asserts={}, clause={}, ranking_ms={}", - kunal_paper_data.assertions_size, kunal_paper_data.lemma_size, - (ranking_elapsed1 + ranking_elapsed2).count() + DREAL_LOG_INFO("Total lemma info: Predicted W.I.={}, in {}ms", + predicted_log2_worth_it, (ranking_elapsed1 + ranking_elapsed2).count() ); - if (/* we think its worth it? */ true) { + + if (/* true */ predicted_log2_worth_it > 1) { const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern(pn_, explanation, box); const auto alcp_end = std::chrono::high_resolution_clock::now(); @@ -294,12 +292,23 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.pattern_match_ms = alcp_elapsed.count(); kunal_paper_data.pattern_matching_stats = alcp_result; - const auto bnb_lpms = 1 / tscs_elapsed.count(); - const auto pm_lpms = alcp_result.matches / alcp_elapsed.count(); - DREAL_LOG_INFO("Worth it? {} \t B&B {} lpms v.s. PM {} lpms", - bnb_lpms >= pm_lpms ? "NO" : "YES", bnb_lpms, pm_lpms); + const double bb_lpms = 1 / tscs_elapsed.count(); + const double pm_lpms = (alcp_result.matches - 0.999) / alcp_elapsed.count(); + const double actual_worth_it = pm_lpms / bb_lpms; + const double actual_log2_worth_it = log2(actual_worth_it); + + DREAL_LOG_INFO("Predicted W.I. = {}, Measured W.I. = {}", predicted_log2_worth_it, actual_log2_worth_it); + const bool overestimated = (actual_log2_worth_it < 1) && (predicted_log2_worth_it > 1); + const bool valid_over = (actual_log2_worth_it > 1) && (predicted_log2_worth_it > 1); + const bool valid_under = (actual_log2_worth_it < 1) && (predicted_log2_worth_it < 1); + const bool underestimated = (actual_log2_worth_it > 1) && (predicted_log2_worth_it < 1); + if (overestimated) DREAL_LOG_INFO("OVERESTIMATED. Had high hopes but were disappointed in the end."); + if (valid_over) DREAL_LOG_INFO("VALID_OVER. It was worth it like we thought."); + if (valid_under) DREAL_LOG_INFO("VALID_UNDER. We knew to avoid this one."); + if (underestimated) DREAL_LOG_INFO("UNDERESTIMATED. Sorry we didn't believe in you."); + } else { - std::cout << "Adding lemma" << std::endl; + DREAL_LOG_INFO("Skipped pattern matching. Adding learned clause conventionally."); sat_solver->AddLearnedClause(explanation, box); } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/dreal/util/predicate_heuristic.h b/src/dreal/util/predicate_heuristic.h index f64e90966..3667d0f16 100644 --- a/src/dreal/util/predicate_heuristic.h +++ b/src/dreal/util/predicate_heuristic.h @@ -220,6 +220,4 @@ namespace dreal } } // namespace dreal -// * learned regression model here * - #endif //predicate_heuristic_H diff --git a/src/dreal/util/predicate_heuristic_trained_model.h b/src/dreal/util/predicate_heuristic_trained_model.h new file mode 100644 index 000000000..2908a1a06 --- /dev/null +++ b/src/dreal/util/predicate_heuristic_trained_model.h @@ -0,0 +1,83 @@ + +#pragma once + +// This file was automatically generated on 2025-04-10 21:28:55.533980 by Kunal in the `WORTH_IT_regression` python notebook. +// +// Notes: +// len(df_overestimated) / len(df) = 0.012 +// len(df_valid_over) / len(df) = 0.073 +// len(df_valid_under) / len(df) = 0.893 +// len(df_underestimated) / len(df) = 0.022 +// +// MINIMUM_WEIGHT_THRESHOLD = 0.001 +// r2_score(y_test, y_pred) = 0.8104209494854622 +// len(X_train) = 2946 +// len(X_test) / len(X_train) = 0.25 + +#define WORTH_IT_REGRESSION_MODEL(k) \ +(0.0 * k.lemma_stats.sqrt_cntr \ + + 0.0 * k.assertions_stats.true_cntr \ + + 0.0 * k.assertions_stats.false_cntr \ + + 0.0 * k.lemma_stats.log_cntr \ + + 0.0 * k.lemma_stats.disjunction_cntr \ + + 0.0 * k.lemma_stats.false_cntr \ + + 0.0 * k.lemma_stats.forall_cntr \ + + 0.0 * k.lemma_stats.ifthenelse_cntr \ + + 0.0 * k.assertions_stats.notequalto_cntr \ + + 0.0 * k.lemma_stats.max_cntr \ + + 0.0 * k.assertions_stats.ifthenelse_cntr \ + + 0.0 * k.lemma_stats.true_cntr \ + + 0.0 * k.assertions_stats.uninterpretedfunction_cntr \ + + 0.0 * k.assertions_stats.min_cntr \ + + 0.0 * k.lemma_stats.uninterpretedfunction_cntr \ + + 0.0 * k.lemma_stats.min_cntr \ + + 0.0 * k.assertions_stats.disjunction_cntr \ + + 0.0 * k.lemma_stats.notequalto_cntr \ + + 0.0 * k.lemma_stats.exp_cntr \ + + 0.0 * k.assertions_stats.forall_cntr \ + + 0.0 * k.assertions_stats.max_cntr \ + + 0.0 * k.assertions_stats.exp_cntr \ + + 0.0 * k.assertions_stats.sqrt_cntr \ + + 0.0 * k.theory_checksat_ms \ + + 0.001217835225040596 * k.lemma_stats.addition_cntr \ + + -0.001962464451051034 * k.assertions_stats.realconstant_cntr \ + + -0.00793823796983405 * k.box_boolean_count \ + + -0.018145367826638337 * k.lemma_stats.variable_cntr \ + + 0.01829872636385954 * k.assertions_stats.negation_cntr \ + + -0.0229918912587667 * k.assertions_stats.variable_cntr \ + + -0.026376483705783937 * k.lemma_stats.negation_cntr \ + + 0.03017973232438398 * k.assertions_stats.addition_cntr \ + + -0.04107952767894013 * k.assertions_stats.trigonometry_cntr \ + + 0.05688306599609716 * k.assertions_stats.multiplication_cntr \ + + -0.060369550994358256 * k.assertions_stats.constant_cntr \ + + -0.07187529638117285 * k.box_continuous_count \ + + 0.07715080264816576 * k.assertions_stats.unique_variables \ + + 0.09232150621308066 * k.assertions_stats.pow_cntr \ + + 0.1026319444631465 * k.lemma_stats.pow_cntr \ + + -0.12459598630366009 * k.lemma_stats.constant_cntr \ + + 0.12927570458507232 * k.lemma_stats.trigonometry_cntr \ + + -0.1543638666996886 * k.lemma_stats.realconstant_cntr \ + + 0.15572623801096852 * k.lemma_stats.multiplication_cntr \ + + 0.15676812548357882 * k.lemma_stats.unique_variables \ + + -0.2653378609984196 * log2(1+k.box_boolean_count) \ + + -0.3545373118515116 * log2(1+k.box_continuous_count) \ + + -0.37408199290852107 * k.assertions_stats.division_cntr \ + + 0.5067092831074196 * k.lemma_stats.division_cntr \ + + -0.5157600045238886 * k.box_integer_count \ + + -1.0349214239587998 * k.lemma_stats.inequality_cntr \ + + 1.1187279976413107 * k.lemma_stats.abs_cntr \ + + 1.1380968359246078 * log2(1+k.theory_checksat_ms) \ + + 1.3026143754266153 * k.assertions_stats.log_cntr \ + + -1.451141643731522 * k.lemma_stats.equalto_cntr \ + + 1.6079717697721332 * k.assertions_stats.equalto_cntr \ + + -1.6377938127199587 * log2(1+k.box_integer_count) \ + + 1.6855709083177568 * k.assertions_stats.inequality_cntr \ + + 1.7110196321336344 * k.assertions_stats.abs_cntr \ + + 1.8035404953112604 * log2(1+k.assertions_size) \ + + -1.9480121854993735 * log2(1+k.lemma_size) \ + + -2.4860630676902487 * k.lemma_size \ + + 3.293542678090737 * k.assertions_size \ + + 3.666239777026109 * k.lemma_stats.conjunction_cntr \ + + -4.862501458432937 * k.assertions_stats.conjunction_cntr \ + + -8.42502822088598) + From 8bbb860ba84ee44823807abf225e669ed5ebe382 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 10 Apr 2025 22:09:29 -0700 Subject: [PATCH 14/79] Create option to disable lemma heuristic training CSV generation. --- src/dreal/solver/context_impl.cc | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index bae1d6bc4..55f7c1534 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -135,9 +135,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { //////////////////////////////////////////////////////////////////////////////// + static constexpr bool GENERATE_CSV = false; std::ofstream myfile; - std::string file_name; - { + if (GENERATE_CSV) { std::ostringstream s; s << "./kunal_paper_data_epoch"; s << std::chrono::system_clock::now().time_since_epoch().count(); @@ -148,13 +148,14 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, s << "_random" << dist(rng) << dist(rng) << dist(rng) << dist(rng);; s << ".csv"; - file_name = s.str(); + const auto file_name = s.str(); std::cout << "Logging statistics to " << file_name << std::endl; std::cerr << "Logging statistics to " << file_name << std::endl; + + myfile.open(file_name, std::ios::app); + if (!myfile) throw DREAL_RUNTIME_ERROR("Failed to open log file"); } - myfile.open(file_name, std::ios::app); - if (!myfile) throw DREAL_RUNTIME_ERROR("Failed to open log file"); struct { @@ -184,7 +185,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, } //////////////////////////////////////////////////////////////////////////////// - { + if (GENERATE_CSV) { std::ostringstream s; s << "box_continuous_count,"; s << "box_integer_count,"; @@ -314,7 +315,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// - { + if (GENERATE_CSV) { std::ostringstream s; s << kunal_paper_data.box_continuous_count << ','; s << kunal_paper_data.box_integer_count << ','; @@ -328,7 +329,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, s << kunal_paper_data.pattern_match_ms << ','; s << kunal_paper_data.pattern_matching_stats; myfile << s.str() << std::endl; // also flushes + } + { typeof(kunal_paper_data) reset_data{0}; reset_data.box_boolean_count = kunal_paper_data.box_boolean_count; reset_data.box_integer_count = kunal_paper_data.box_integer_count; From 1acfc1e9b0bf32f478d4c43576ca72c7c355290d Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 13 Apr 2025 00:28:37 -0700 Subject: [PATCH 15/79] Add const getters to substitutions_map.h. --- src/dreal/util/pattern_matching/substitutions_map.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/dreal/util/pattern_matching/substitutions_map.h b/src/dreal/util/pattern_matching/substitutions_map.h index 6815c1052..c42d38180 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.h +++ b/src/dreal/util/pattern_matching/substitutions_map.h @@ -6,7 +6,7 @@ #define substitutions_mapH #include #include -#include +#include namespace dreal { @@ -18,6 +18,9 @@ namespace dreal std::vector>> insertion_stack{1}; public: + const std::unordered_map& get_map() const { return fwd; } + const std::vector>& get_current_frame() const { return insertion_stack.back(); } + substitutions_map(); explicit substitutions_map(size_t reserve); From 040fcc38ec2a1fc590f9ff964b448db0b07dfabe Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 13 Apr 2025 00:58:34 -0700 Subject: [PATCH 16/79] Switch `explanation` learned clause/lemma data structures from set to vector. --- src/dreal/solver/context_impl.cc | 13 ++++++++++--- src/dreal/solver/sat_solver.cc | 12 ++++++++---- src/dreal/solver/sat_solver.h | 4 ++-- src/dreal/util/predicate_normalizer.cc | 7 +------ src/dreal/util/predicate_normalizer.h | 2 +- 5 files changed, 22 insertions(+), 16 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 55f7c1534..e5719e894 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -271,8 +271,15 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, "ContextImpl::CheckSatCore() - size of explanation = {} - stack size = {}", explanation.size(), stack.get_vector().size()); + // ordering the literals like this makes pattern matching fast. + // todo: abstract this away better. should not happen at the top-level like it is now. + std::vector explanation_vec(explanation.begin(), explanation.end()); + std::sort(explanation_vec.begin(), explanation_vec.end(), [](const Formula &a, const Formula &b) { + return a.GetFreeVariables().size() > b.GetFreeVariables().size(); // descending + }); + //////////////////////////////////////////////////////////////////////////////// - kunal_paper_data.lemma_size = explanation.size(); + kunal_paper_data.lemma_size = explanation_vec.size(); const auto ranking_start2 = std::chrono::high_resolution_clock::now(); kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation)); @@ -286,7 +293,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (/* true */ predicted_log2_worth_it > 1) { const auto alcp_start = std::chrono::high_resolution_clock::now(); - const auto alcp_result = sat_solver->AddLearnedClausePattern(pn_, explanation, box); + const auto alcp_result = sat_solver->AddLearnedClausePattern(pn_, explanation_vec, box); const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; @@ -310,7 +317,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, } else { DREAL_LOG_INFO("Skipped pattern matching. Adding learned clause conventionally."); - sat_solver->AddLearnedClause(explanation, box); + sat_solver->AddLearnedClause(explanation_vec, box); } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 28be7abc6..7f537dd29 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -65,8 +65,8 @@ void SatSolver::AddFormula(const Formula& f) { } } -void SatSolver::AddLearnedClause(const set& conflicting_conjunction, const Box& box) { - if (DREAL_LOG_DEBUG_ENABLED) audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(conflicting_conjunction), box); +void SatSolver::AddLearnedClause(const vector& conflicting_conjunction, const Box& box) { + if (DREAL_LOG_DEBUG_ENABLED) audit(!make_conjunction(conflicting_conjunction), box); for (const Formula& f : conflicting_conjunction) { AddLiteral(!predicate_abstractor_.Convert(f)); } @@ -91,11 +91,15 @@ void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( PredicateNormalizer& pn, - const set& base_conflict, const Box& base_box + const vector& base_conflict, const Box& base_box ) { // todo: clean this a little.. avoid duplicates. but some clauses aren't in the trie and don't match to themselves? const auto [all_related_conflicts, match_statistics] = pn.FindSimilar(base_conflict); - DREAL_ASSERT(!all_related_conflicts.empty()); // should AT LEAST match with itself. + if(all_related_conflicts.empty()) { + DREAL_LOG_ERROR("Clause did not match with itself? Adding regularly."); + AddLearnedClause(base_conflict, base_box); + return match_statistics; + } for (const auto& [conflict_clause, subs] : all_related_conflicts) { Box conflict_box = substitutions_map::apply_substitution(base_box, subs, false); diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index d525e038e..70e7e88a5 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -68,10 +68,10 @@ class SatSolver { /// Given a @p formulas = {f₁, ..., fₙ}, adds a clause (¬f₁ ∨ ... ∨ ¬ fₙ) to /// the solver. - void AddLearnedClause(const std::set& conflicting_conjunction, const Box& box); + void AddLearnedClause(const std::vector& conflicting_conjunction, const Box& box); PatternMatchingTrie::matching_stats_t AddLearnedClausePattern( PredicateNormalizer& pn, - const std::set& base_conflict, + const std::vector& base_conflict, const Box& base_box); void AddBox(PredicateNormalizer& pn, const Box& base_box); diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index 7a496d88f..511c18696 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -21,12 +21,7 @@ namespace dreal { std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> - PredicateNormalizer::FindSimilar(const std::set& clause) const { - std::vector ordered_clause(clause.begin(), clause.end()); - std::sort(ordered_clause.begin(), ordered_clause.end(), [&](const Formula &a, const Formula &b) { - return a.GetFreeVariables().size() > b.GetFreeVariables().size(); // descending - // return trie.estimate_branches(a) > trie.estimate_branches(b); - }); + PredicateNormalizer::FindSimilar(const std::vector& ordered_clause) const { if (DREAL_LOG_INFO_ENABLED) { std::ostringstream s; s << "!("; diff --git a/src/dreal/util/predicate_normalizer.h b/src/dreal/util/predicate_normalizer.h index 57c63ee47..b19ecc376 100644 --- a/src/dreal/util/predicate_normalizer.h +++ b/src/dreal/util/predicate_normalizer.h @@ -33,7 +33,7 @@ namespace dreal std::vector, substitutions_map>>, PatternMatchingTrie:: matching_stats_t > - FindSimilar(const std::set& f) const; + FindSimilar(const std::vector& ordered_clause) const; // useless heuristic // uint64_t EstimateMatchingCost(const std::set& f); From 6bc00739457991629e1d8cdd8fda76f8b0fbc71d Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 13 Apr 2025 01:20:28 -0700 Subject: [PATCH 17/79] Sort assertions, and add big, middle, small stats variants to logging. --- src/dreal/solver/context_impl.cc | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index e5719e894..b3713a626 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -164,9 +164,15 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, unsigned box_boolean_count; unsigned assertions_size; PredicateHeuristic::predicate_stats_t assertions_stats; + PredicateHeuristic::predicate_stats_t biggest_assertion_stats; + PredicateHeuristic::predicate_stats_t middle_assertion_stats; + PredicateHeuristic::predicate_stats_t smallest_assertion_stats; double theory_checksat_ms; unsigned lemma_size; PredicateHeuristic::predicate_stats_t lemma_stats; + PredicateHeuristic::predicate_stats_t biggest_literal_stats; + PredicateHeuristic::predicate_stats_t middle_literal_stats; + PredicateHeuristic::predicate_stats_t smallest_literal_stats; uint64_t estimated_matching_cost; double pattern_match_ms; PatternMatchingTrie::matching_stats_t pattern_matching_stats; @@ -192,9 +198,15 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, s << "box_boolean_count,"; s << "assertions_size,"; s << PredicateHeuristic::predicate_stats_csv_header("assertions_stats_") << ','; + s << PredicateHeuristic::predicate_stats_csv_header("biggest_assertion_stats_") << ','; + s << PredicateHeuristic::predicate_stats_csv_header("middle_assertion_stats_") << ','; + s << PredicateHeuristic::predicate_stats_csv_header("smallest_assertion_stats_") << ','; s << "theory_checksat_ms,"; s << "lemma_size,"; s << PredicateHeuristic::predicate_stats_csv_header("lemma_stats_") << ','; + s << PredicateHeuristic::predicate_stats_csv_header("biggest_literal_stats_") << ','; + s << PredicateHeuristic::predicate_stats_csv_header("middle_literal_stats_") << ','; + s << PredicateHeuristic::predicate_stats_csv_header("smallest_literal_stats_") << ','; s << "estimated_matching_cost,"; s << "pattern_match_ms,"; s << PatternMatchingTrie::matching_stats_csv_header("pattern_matching_stats_"); @@ -213,6 +225,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, } //////////////////////////////////////////////////////////////////////////////// + DREAL_LOG_INFO("Initialized. Beginning SAT <=> Theory cycles."); while (true) { // Note that 'DREAL_CHECK_INTERRUPT' is only defined in setup.py, // when we build dReal python package. @@ -241,6 +254,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, assertions.emplace_back( assignment ? sat_solver->theory_literal(sat_var) : !sat_solver->theory_literal(sat_var) ); + std::sort(assertions.begin(), assertions.end(), [](const Formula& a, const Formula& b) { + return a.GetFreeVariables().size() < b.GetFreeVariables().size(); // ascending + }); //////////////////////////////////////////////////////////////////////////////// kunal_paper_data.assertions_size = assertions.size(); @@ -248,6 +264,10 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const auto ranking_start1 = std::chrono::high_resolution_clock::now(); std::set assertions_set(assertions.begin(), assertions.end()); kunal_paper_data.assertions_stats = pn_.heuristic.collect_statistics(make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(assertions_set))); + // cheap because cached. + kunal_paper_data.smallest_assertion_stats = pn_.heuristic.collect_statistics(assertions[0]); + kunal_paper_data.middle_assertion_stats = pn_.heuristic.collect_statistics(assertions[assertions.size()/2]); + kunal_paper_data.biggest_assertion_stats = pn_.heuristic.collect_statistics(assertions[assertions.size()-1]); const auto ranking_end1 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed1 = ranking_end1 - ranking_start1; @@ -283,6 +303,10 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const auto ranking_start2 = std::chrono::high_resolution_clock::now(); kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation)); + // doing individual literals doesn't cost extra because they cache hit after running the entire conjunction + kunal_paper_data.biggest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[0]); + kunal_paper_data.middle_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size() / 2]); + kunal_paper_data.smallest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size()-1]); const double predicted_log2_worth_it = WORTH_IT_REGRESSION_MODEL(kunal_paper_data); const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; @@ -329,9 +353,15 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, s << kunal_paper_data.box_boolean_count << ','; s << kunal_paper_data.assertions_size << ','; s << kunal_paper_data.assertions_stats << ','; + s << kunal_paper_data.biggest_assertion_stats << ','; + s << kunal_paper_data.middle_assertion_stats << ','; + s << kunal_paper_data.smallest_assertion_stats << ','; s << kunal_paper_data.theory_checksat_ms << ','; s << kunal_paper_data.lemma_size << ','; s << kunal_paper_data.lemma_stats << ','; + s << kunal_paper_data.biggest_literal_stats << ','; + s << kunal_paper_data.middle_literal_stats << ','; + s << kunal_paper_data.smallest_literal_stats << ','; s << kunal_paper_data.estimated_matching_cost << ','; s << kunal_paper_data.pattern_match_ms << ','; s << kunal_paper_data.pattern_matching_stats; From 76757e2c97d5101fb5688e08125604eec82af17b Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 13 Apr 2025 04:47:36 -0700 Subject: [PATCH 18/79] Implement timeout mechanism for pattern matching! --- src/dreal/solver/context_impl.cc | 6 +++- src/dreal/solver/sat_solver.cc | 18 ++++++---- src/dreal/solver/sat_solver.h | 2 +- .../pattern_matching/pattern_matching_trie.h | 3 +- .../pattern_matching_trie_general.cc | 36 ++++++++++++++++--- src/dreal/util/predicate_normalizer.cc | 7 ++-- src/dreal/util/predicate_normalizer.h | 5 ++- 7 files changed, 61 insertions(+), 16 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index b3713a626..06c41ffc8 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -317,7 +317,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (/* true */ predicted_log2_worth_it > 1) { const auto alcp_start = std::chrono::high_resolution_clock::now(); - const auto alcp_result = sat_solver->AddLearnedClausePattern(pn_, explanation_vec, box); + const auto alcp_result = sat_solver->AddLearnedClausePattern( + pn_, explanation_vec, box, + // std::chrono::duration_cast(100 * tscs_elapsed) + std::chrono::seconds(30) + ); const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 7f537dd29..42903c1b7 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -91,13 +91,19 @@ void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( PredicateNormalizer& pn, - const vector& base_conflict, const Box& base_box + const vector& base_conflict, const Box& base_box, + const std::chrono::duration timeout ) { - // todo: clean this a little.. avoid duplicates. but some clauses aren't in the trie and don't match to themselves? - const auto [all_related_conflicts, match_statistics] = pn.FindSimilar(base_conflict); - if(all_related_conflicts.empty()) { - DREAL_LOG_ERROR("Clause did not match with itself? Adding regularly."); - AddLearnedClause(base_conflict, base_box); + // the pattern matching is kinda best-effort now. + // it breaks down when one clause pattern matches into 1000s of permutations of itself + // just make the best effort, and at the very minimum make sure the original at least gets inserted + AddLearnedClause(base_conflict, base_box); + const auto [ + all_related_conflicts, + match_statistics + ] = pn.FindSimilar(base_conflict, timeout); + if (all_related_conflicts.empty()) { + DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); return match_statistics; } diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 70e7e88a5..2717b50de 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -72,7 +72,7 @@ class SatSolver { PatternMatchingTrie::matching_stats_t AddLearnedClausePattern( PredicateNormalizer& pn, const std::vector& base_conflict, - const Box& base_box); + const Box& base_box, std::chrono::duration timeout); void AddBox(PredicateNormalizer& pn, const Box& base_box); Formula MakeSatIntervalVar(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv); diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index cc62ca8f5..221d88930 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -37,7 +37,8 @@ namespace dreal [[nodiscard]] std::pair, substitutions_map>>, matching_stats_t> find_matches( - const std::vector& literals + const std::vector& literals, + std::chrono::duration timeout = std::chrono::microseconds{-1} ) const; [[nodiscard]] std::pair>, matching_stats_t> find_matches( diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index 37e064acc..18bbb30d2 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -10,16 +10,22 @@ #include #include #include +#include namespace dreal { std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> - PatternMatchingTrie::find_matches(const std::vector& literals) const { + PatternMatchingTrie::find_matches( + const std::vector& literals, + const std::chrono::duration timeout + ) const { matching_stats_t stats = {0}; std::vector matches_vec; std::vector, substitutions_map>> result; matches_vec.reserve(literals.size()); + const auto start_time = std::chrono::steady_clock::now(); + const f_misses_vec misses = [&](const auto& _) { stats.misses++; }; @@ -42,11 +48,30 @@ namespace dreal const auto ibegin = literals.begin(); const auto iend = literals.end(); + std::unordered_set seen_truncateds; // lexo-compare for nary goes one by one... + seen_truncateds.reserve(1024 * literals.size()); std::function< std::function(typeof(ibegin)) > match_next_literal = [&](const auto& it1) { return [&, /*copy*/ it1](const auto& f, auto& s2) { + if (std::chrono::steady_clock::now() - start_time > timeout) { + DREAL_LOG_ERROR("Pattern matching timed out after {} usec.", timeout.count()); + return; + } + matches_vec.emplace_back(f); + + // avoid re-finding 1000s of permutations of the same clause on fedor_13.smt2, etc. + // copy required. do NOT modify matches_vec... that needs to be a pure stack + std::set matches_vec_set(matches_vec.begin(), matches_vec.end()); + const auto [_, successful_emplace] = seen_truncateds.emplace( + make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(matches_vec_set)) + ); + if (!successful_emplace) { + matches_vec.pop_back(); + return; + } + if (it1 == iend) { DREAL_ASSERT(literals.size() == 1); return all_literals_match(s2); @@ -60,13 +85,16 @@ namespace dreal }; }; - size_t sub_preallocations=0; - for (const auto & literal : literals) sub_preallocations += literal.GetFreeVariables().size(); + size_t sub_preallocations = 0; + for (const auto& literal : literals) sub_preallocations += literal.GetFreeVariables().size(); substitutions_map substitutions(sub_preallocations); recMatchForm(*ibegin, f_root, substitutions, match_next_literal(ibegin), partial_matches, misses); DREAL_ASSERT(result.size() == stats.matches); - DREAL_LOG_INFO("Found {} matches with {} misses.", stats.matches, stats.misses); + DREAL_LOG_INFO( + "Found {} matches of size {} ({} effective literals) with {} misses.", + stats.matches, literals.size(), stats.matches / ::pow(2, literals.size()), stats.misses + ); // if (DREAL_LOG_INFO_ENABLED) { // for (const auto& [matched_clause, _] : result) { // std::ostringstream s; diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index 511c18696..c1d7b1d24 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -21,7 +21,10 @@ namespace dreal { std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> - PredicateNormalizer::FindSimilar(const std::vector& ordered_clause) const { + PredicateNormalizer::FindSimilar( + const std::vector& ordered_clause, + const std::chrono::duration timeout + ) const { if (DREAL_LOG_INFO_ENABLED) { std::ostringstream s; s << "!("; @@ -36,7 +39,7 @@ namespace dreal // Learned clauses MUST be a collection of normalized literals. DREAL_ASSERT(is_equal_to(atom) || is_less_than(atom) || is_less_than_or_equal_to(atom) || is_forall(atom)); } - return trie.find_matches(ordered_clause); + return trie.find_matches(ordered_clause, timeout); } // ended up being completely friggen useless lol :( diff --git a/src/dreal/util/predicate_normalizer.h b/src/dreal/util/predicate_normalizer.h index b19ecc376..42e520e10 100644 --- a/src/dreal/util/predicate_normalizer.h +++ b/src/dreal/util/predicate_normalizer.h @@ -33,7 +33,10 @@ namespace dreal std::vector, substitutions_map>>, PatternMatchingTrie:: matching_stats_t > - FindSimilar(const std::vector& ordered_clause) const; + FindSimilar( + const std::vector& ordered_clause, + std::chrono::duration timeout = std::chrono::microseconds{-1} + ) const; // useless heuristic // uint64_t EstimateMatchingCost(const std::set& f); From 4305c8604ce92ea837b9f85dad6e17a833ef12ab Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 13 Apr 2025 04:58:53 -0700 Subject: [PATCH 19/79] REVERT ME - changes for blasty training. --- src/dreal/solver/context_impl.cc | 5 +++-- src/dreal/solver/sat_solver.cc | 2 ++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 06c41ffc8..73c4c785b 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -135,7 +135,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { //////////////////////////////////////////////////////////////////////////////// - static constexpr bool GENERATE_CSV = false; + static constexpr bool GENERATE_CSV = true; std::ofstream myfile; if (GENERATE_CSV) { std::ostringstream s; @@ -315,7 +315,8 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, predicted_log2_worth_it, (ranking_elapsed1 + ranking_elapsed2).count() ); - if (/* true */ predicted_log2_worth_it > 1) { + // if (/* true */ predicted_log2_worth_it > 1) { + if (true) { const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( pn_, explanation_vec, box, diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 42903c1b7..09179c441 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -107,6 +107,7 @@ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( return match_statistics; } + /* for (const auto& [conflict_clause, subs] : all_related_conflicts) { Box conflict_box = substitutions_map::apply_substitution(base_box, subs, false); @@ -131,6 +132,7 @@ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( cadical->add(0); } + */ return match_statistics; } From 4e22b15f6aaef1a7a1938624ab95beeb6b77a587 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 14 Apr 2025 00:09:18 -0700 Subject: [PATCH 20/79] Move pattern_matching_test.cc from /solver to /util to match it's corresponding /src file. --- test/dreal/{solver => util}/test/pattern_matching_test.cc | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/dreal/{solver => util}/test/pattern_matching_test.cc (100%) diff --git a/test/dreal/solver/test/pattern_matching_test.cc b/test/dreal/util/test/pattern_matching_test.cc similarity index 100% rename from test/dreal/solver/test/pattern_matching_test.cc rename to test/dreal/util/test/pattern_matching_test.cc From a31ba7e7514ee4303b66e2c809cf9d5eda0d2ea2 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 14 Apr 2025 00:10:20 -0700 Subject: [PATCH 21/79] Upgrade regression model to small neural network. --- src/dreal/solver/context_impl.cc | 39 +- .../pattern_matching_heuristic.cc | 488 ++ .../pattern_matching_heuristic.h | 41 + .../util/predicate_heuristic_trained_model.h | 83 - .../test/pattern_matching_heuristic_test.cc | 4407 +++++++++++++++++ 5 files changed, 4946 insertions(+), 112 deletions(-) create mode 100644 src/dreal/util/pattern_matching/pattern_matching_heuristic.cc create mode 100644 src/dreal/util/pattern_matching/pattern_matching_heuristic.h delete mode 100644 src/dreal/util/predicate_heuristic_trained_model.h create mode 100644 test/dreal/util/test/pattern_matching_heuristic_test.cc diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 73c4c785b..5be2d475f 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include @@ -157,26 +157,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (!myfile) throw DREAL_RUNTIME_ERROR("Failed to open log file"); } - struct - { - unsigned box_continuous_count; - unsigned box_integer_count; - unsigned box_boolean_count; - unsigned assertions_size; - PredicateHeuristic::predicate_stats_t assertions_stats; - PredicateHeuristic::predicate_stats_t biggest_assertion_stats; - PredicateHeuristic::predicate_stats_t middle_assertion_stats; - PredicateHeuristic::predicate_stats_t smallest_assertion_stats; - double theory_checksat_ms; - unsigned lemma_size; - PredicateHeuristic::predicate_stats_t lemma_stats; - PredicateHeuristic::predicate_stats_t biggest_literal_stats; - PredicateHeuristic::predicate_stats_t middle_literal_stats; - PredicateHeuristic::predicate_stats_t smallest_literal_stats; - uint64_t estimated_matching_cost; - double pattern_match_ms; - PatternMatchingTrie::matching_stats_t pattern_matching_stats; - } kunal_paper_data = {0}; + PatternMatchingHeuristic::statistics kunal_paper_data; //////////////////////////////////////////////////////////////////////////////// DREAL_LOG_DEBUG("ContextImpl::CheckSatCore()"); @@ -307,12 +288,12 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.biggest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[0]); kunal_paper_data.middle_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size() / 2]); kunal_paper_data.smallest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size()-1]); - const double predicted_log2_worth_it = WORTH_IT_REGRESSION_MODEL(kunal_paper_data); + const double predicted_is_worth_it = PatternMatchingHeuristic::calculate(kunal_paper_data); const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; - DREAL_LOG_INFO("Total lemma info: Predicted W.I.={}, in {}ms", - predicted_log2_worth_it, (ranking_elapsed1 + ranking_elapsed2).count() + DREAL_LOG_INFO("Total lemma info: Predicted P(is W.I.)={}, in {}ms", + predicted_is_worth_it, (ranking_elapsed1 + ranking_elapsed2).count() ); // if (/* true */ predicted_log2_worth_it > 1) { @@ -334,11 +315,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const double actual_worth_it = pm_lpms / bb_lpms; const double actual_log2_worth_it = log2(actual_worth_it); - DREAL_LOG_INFO("Predicted W.I. = {}, Measured W.I. = {}", predicted_log2_worth_it, actual_log2_worth_it); - const bool overestimated = (actual_log2_worth_it < 1) && (predicted_log2_worth_it > 1); - const bool valid_over = (actual_log2_worth_it > 1) && (predicted_log2_worth_it > 1); - const bool valid_under = (actual_log2_worth_it < 1) && (predicted_log2_worth_it < 1); - const bool underestimated = (actual_log2_worth_it > 1) && (predicted_log2_worth_it < 1); + DREAL_LOG_INFO("Predicted P(is W.I.)={}, Measured log2 W.I. ratio = {}", predicted_is_worth_it, actual_log2_worth_it); + const bool overestimated = (actual_log2_worth_it < 1) && (predicted_is_worth_it > 0.5); + const bool valid_over = (actual_log2_worth_it > 1) && (predicted_is_worth_it > 0.5); + const bool valid_under = (actual_log2_worth_it < 1) && (predicted_is_worth_it < 0.5); + const bool underestimated = (actual_log2_worth_it > 1) && (predicted_is_worth_it < 0.5); if (overestimated) DREAL_LOG_INFO("OVERESTIMATED. Had high hopes but were disappointed in the end."); if (valid_over) DREAL_LOG_INFO("VALID_OVER. It was worth it like we thought."); if (valid_under) DREAL_LOG_INFO("VALID_UNDER. We knew to avoid this one."); diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc new file mode 100644 index 000000000..171108635 --- /dev/null +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc @@ -0,0 +1,488 @@ + +// This file was automatically generated on 2025-04-14 00:04:44.271759 by Kunal in the `WORTH_IT_regression` python notebook. +// +// Notes: +// len(df_overestimated) / len(df) = 0.013 +// len(df_valid_over) / len(df) = 0.176 +// len(df_valid_under) / len(df) = 0.798 +// len(df_underestimated) / len(df) = 0.013 +// +// accuracy_score(y_test, y_pred) = 0.9714551659944152 +// len(X_train) = 12890 +// len(X_test) / len(X_train) = 0.25 +// model = Pipeline(steps=[('standardscaler', StandardScaler()), ('mlpclassifier', MLPClassifier(hidden_layer_sizes=(8, 4), max_iter=500, random_state=42))]) + + +#include "pattern_matching_heuristic.h" + +namespace dreal +{ + float relu(const float x) { return x < 0 ? 0 : x; } + float sigmoid(const float x) { return 1 / (1 + expf(-x)); } + + float PatternMatchingHeuristic::calculate(statistics k) { + +const float lemma_stats_equalto_cntr = k.lemma_stats.equalto_cntr; +const float smallest_assertion_stats_notequalto_cntr = k.smallest_assertion_stats.notequalto_cntr; +const float smallest_literal_stats_unique_variables = k.smallest_literal_stats.unique_variables; +const float smallest_literal_stats_constant_cntr = k.smallest_literal_stats.constant_cntr; +const float middle_assertion_stats_constant_cntr = k.middle_assertion_stats.constant_cntr; +const float middle_literal_stats_realconstant_cntr = k.middle_literal_stats.realconstant_cntr; +const float assertions_stats_min_cntr = k.assertions_stats.min_cntr; +const float smallest_literal_stats_pow_cntr = k.smallest_literal_stats.pow_cntr; +const float middle_literal_stats_equalto_cntr = k.middle_literal_stats.equalto_cntr; +const float lemma_stats_multiplication_cntr = k.lemma_stats.multiplication_cntr; +const float middle_literal_stats_multiplication_cntr = k.middle_literal_stats.multiplication_cntr; +const float middle_literal_stats_division_cntr = k.middle_literal_stats.division_cntr; +const float assertions_stats_exp_cntr = k.assertions_stats.exp_cntr; +const float biggest_assertion_stats_realconstant_cntr = k.biggest_assertion_stats.realconstant_cntr; +const float box_continuous_count = k.box_continuous_count; +const float middle_literal_stats_uninterpretedfunction_cntr = k.middle_literal_stats.uninterpretedfunction_cntr; +const float box_integer_count = k.box_integer_count; +const float smallest_assertion_stats_exp_cntr = k.smallest_assertion_stats.exp_cntr; +const float middle_assertion_stats_notequalto_cntr = k.middle_assertion_stats.notequalto_cntr; +const float middle_assertion_stats_log_cntr = k.middle_assertion_stats.log_cntr; +const float middle_assertion_stats_forall_cntr = k.middle_assertion_stats.forall_cntr; +const float middle_literal_stats_addition_cntr = k.middle_literal_stats.addition_cntr; +const float lemma_stats_division_cntr = k.lemma_stats.division_cntr; +const float biggest_assertion_stats_addition_cntr = k.biggest_assertion_stats.addition_cntr; +const float lemma_stats_max_cntr = k.lemma_stats.max_cntr; +const float smallest_literal_stats_false_cntr = k.smallest_literal_stats.false_cntr; +const float lemma_stats_trigonometry_cntr = k.lemma_stats.trigonometry_cntr; +const float middle_assertion_stats_inequality_cntr = k.middle_assertion_stats.inequality_cntr; +const float biggest_assertion_stats_abs_cntr = k.biggest_assertion_stats.abs_cntr; +const float assertions_stats_ifthenelse_cntr = k.assertions_stats.ifthenelse_cntr; +const float biggest_literal_stats_min_cntr = k.biggest_literal_stats.min_cntr; +const float assertions_stats_negation_cntr = k.assertions_stats.negation_cntr; +const float assertions_stats_unique_variables = k.assertions_stats.unique_variables; +const float lemma_stats_conjunction_cntr = k.lemma_stats.conjunction_cntr; +const float biggest_literal_stats_abs_cntr = k.biggest_literal_stats.abs_cntr; +const float middle_assertion_stats_abs_cntr = k.middle_assertion_stats.abs_cntr; +const float assertions_stats_division_cntr = k.assertions_stats.division_cntr; +const float biggest_assertion_stats_conjunction_cntr = k.biggest_assertion_stats.conjunction_cntr; +const float middle_assertion_stats_realconstant_cntr = k.middle_assertion_stats.realconstant_cntr; +const float smallest_literal_stats_forall_cntr = k.smallest_literal_stats.forall_cntr; +const float smallest_assertion_stats_conjunction_cntr = k.smallest_assertion_stats.conjunction_cntr; +const float biggest_literal_stats_unique_variables = k.biggest_literal_stats.unique_variables; +const float smallest_assertion_stats_constant_cntr = k.smallest_assertion_stats.constant_cntr; +const float lemma_stats_ifthenelse_cntr = k.lemma_stats.ifthenelse_cntr; +const float middle_literal_stats_ifthenelse_cntr = k.middle_literal_stats.ifthenelse_cntr; +const float smallest_literal_stats_log_cntr = k.smallest_literal_stats.log_cntr; +const float smallest_literal_stats_notequalto_cntr = k.smallest_literal_stats.notequalto_cntr; +const float biggest_assertion_stats_false_cntr = k.biggest_assertion_stats.false_cntr; +const float assertions_stats_inequality_cntr = k.assertions_stats.inequality_cntr; +const float middle_literal_stats_notequalto_cntr = k.middle_literal_stats.notequalto_cntr; +const float lemma_stats_unique_variables = k.lemma_stats.unique_variables; +const float biggest_literal_stats_variable_cntr = k.biggest_literal_stats.variable_cntr; +const float middle_assertion_stats_disjunction_cntr = k.middle_assertion_stats.disjunction_cntr; +const float middle_assertion_stats_variable_cntr = k.middle_assertion_stats.variable_cntr; +const float lemma_stats_inequality_cntr = k.lemma_stats.inequality_cntr; +const float smallest_literal_stats_abs_cntr = k.smallest_literal_stats.abs_cntr; +const float lemma_stats_notequalto_cntr = k.lemma_stats.notequalto_cntr; +const float biggest_assertion_stats_equalto_cntr = k.biggest_assertion_stats.equalto_cntr; +const float assertions_stats_sqrt_cntr = k.assertions_stats.sqrt_cntr; +const float assertions_stats_uninterpretedfunction_cntr = k.assertions_stats.uninterpretedfunction_cntr; +const float smallest_assertion_stats_forall_cntr = k.smallest_assertion_stats.forall_cntr; +const float middle_assertion_stats_true_cntr = k.middle_assertion_stats.true_cntr; +const float smallest_literal_stats_addition_cntr = k.smallest_literal_stats.addition_cntr; +const float biggest_assertion_stats_max_cntr = k.biggest_assertion_stats.max_cntr; +const float biggest_assertion_stats_ifthenelse_cntr = k.biggest_assertion_stats.ifthenelse_cntr; +const float biggest_literal_stats_notequalto_cntr = k.biggest_literal_stats.notequalto_cntr; +const float biggest_literal_stats_exp_cntr = k.biggest_literal_stats.exp_cntr; +const float biggest_literal_stats_disjunction_cntr = k.biggest_literal_stats.disjunction_cntr; +const float middle_literal_stats_negation_cntr = k.middle_literal_stats.negation_cntr; +const float biggest_assertion_stats_division_cntr = k.biggest_assertion_stats.division_cntr; +const float middle_literal_stats_false_cntr = k.middle_literal_stats.false_cntr; +const float lemma_stats_uninterpretedfunction_cntr = k.lemma_stats.uninterpretedfunction_cntr; +const float biggest_literal_stats_forall_cntr = k.biggest_literal_stats.forall_cntr; +const float biggest_assertion_stats_pow_cntr = k.biggest_assertion_stats.pow_cntr; +const float lemma_stats_pow_cntr = k.lemma_stats.pow_cntr; +const float lemma_stats_disjunction_cntr = k.lemma_stats.disjunction_cntr; +const float middle_assertion_stats_multiplication_cntr = k.middle_assertion_stats.multiplication_cntr; +const float middle_assertion_stats_division_cntr = k.middle_assertion_stats.division_cntr; +const float biggest_assertion_stats_sqrt_cntr = k.biggest_assertion_stats.sqrt_cntr; +const float biggest_literal_stats_uninterpretedfunction_cntr = k.biggest_literal_stats.uninterpretedfunction_cntr; +const float middle_literal_stats_conjunction_cntr = k.middle_literal_stats.conjunction_cntr; +const float lemma_stats_realconstant_cntr = k.lemma_stats.realconstant_cntr; +const float biggest_assertion_stats_exp_cntr = k.biggest_assertion_stats.exp_cntr; +const float assertions_stats_forall_cntr = k.assertions_stats.forall_cntr; +const float lemma_stats_sqrt_cntr = k.lemma_stats.sqrt_cntr; +const float middle_assertion_stats_addition_cntr = k.middle_assertion_stats.addition_cntr; +const float assertions_stats_addition_cntr = k.assertions_stats.addition_cntr; +const float middle_literal_stats_constant_cntr = k.middle_literal_stats.constant_cntr; +const float assertions_stats_realconstant_cntr = k.assertions_stats.realconstant_cntr; +const float lemma_stats_false_cntr = k.lemma_stats.false_cntr; +const float smallest_assertion_stats_addition_cntr = k.smallest_assertion_stats.addition_cntr; +const float lemma_stats_variable_cntr = k.lemma_stats.variable_cntr; +const float assertions_stats_disjunction_cntr = k.assertions_stats.disjunction_cntr; +const float middle_assertion_stats_negation_cntr = k.middle_assertion_stats.negation_cntr; +const float smallest_literal_stats_realconstant_cntr = k.smallest_literal_stats.realconstant_cntr; +const float assertions_stats_constant_cntr = k.assertions_stats.constant_cntr; +const float smallest_assertion_stats_max_cntr = k.smallest_assertion_stats.max_cntr; +const float middle_assertion_stats_false_cntr = k.middle_assertion_stats.false_cntr; +const float middle_literal_stats_true_cntr = k.middle_literal_stats.true_cntr; +const float assertions_stats_false_cntr = k.assertions_stats.false_cntr; +const float middle_literal_stats_pow_cntr = k.middle_literal_stats.pow_cntr; +const float lemma_stats_true_cntr = k.lemma_stats.true_cntr; +const float biggest_literal_stats_division_cntr = k.biggest_literal_stats.division_cntr; +const float middle_assertion_stats_max_cntr = k.middle_assertion_stats.max_cntr; +const float middle_assertion_stats_conjunction_cntr = k.middle_assertion_stats.conjunction_cntr; +const float lemma_stats_min_cntr = k.lemma_stats.min_cntr; +const float biggest_literal_stats_conjunction_cntr = k.biggest_literal_stats.conjunction_cntr; +const float biggest_assertion_stats_notequalto_cntr = k.biggest_assertion_stats.notequalto_cntr; +const float assertions_stats_trigonometry_cntr = k.assertions_stats.trigonometry_cntr; +const float biggest_assertion_stats_min_cntr = k.biggest_assertion_stats.min_cntr; +const float smallest_assertion_stats_equalto_cntr = k.smallest_assertion_stats.equalto_cntr; +const float assertions_stats_abs_cntr = k.assertions_stats.abs_cntr; +const float smallest_literal_stats_true_cntr = k.smallest_literal_stats.true_cntr; +const float biggest_assertion_stats_uninterpretedfunction_cntr = k.biggest_assertion_stats.uninterpretedfunction_cntr; +const float smallest_assertion_stats_disjunction_cntr = k.smallest_assertion_stats.disjunction_cntr; +const float smallest_assertion_stats_inequality_cntr = k.smallest_assertion_stats.inequality_cntr; +const float smallest_literal_stats_trigonometry_cntr = k.smallest_literal_stats.trigonometry_cntr; +const float smallest_assertion_stats_pow_cntr = k.smallest_assertion_stats.pow_cntr; +const float middle_literal_stats_min_cntr = k.middle_literal_stats.min_cntr; +const float smallest_assertion_stats_uninterpretedfunction_cntr = k.smallest_assertion_stats.uninterpretedfunction_cntr; +const float middle_literal_stats_inequality_cntr = k.middle_literal_stats.inequality_cntr; +const float lemma_stats_abs_cntr = k.lemma_stats.abs_cntr; +const float smallest_literal_stats_negation_cntr = k.smallest_literal_stats.negation_cntr; +const float biggest_assertion_stats_negation_cntr = k.biggest_assertion_stats.negation_cntr; +const float biggest_literal_stats_inequality_cntr = k.biggest_literal_stats.inequality_cntr; +const float smallest_literal_stats_min_cntr = k.smallest_literal_stats.min_cntr; +const float lemma_stats_exp_cntr = k.lemma_stats.exp_cntr; +const float middle_literal_stats_variable_cntr = k.middle_literal_stats.variable_cntr; +const float middle_literal_stats_exp_cntr = k.middle_literal_stats.exp_cntr; +const float smallest_literal_stats_conjunction_cntr = k.smallest_literal_stats.conjunction_cntr; +const float biggest_assertion_stats_multiplication_cntr = k.biggest_assertion_stats.multiplication_cntr; +const float assertions_stats_equalto_cntr = k.assertions_stats.equalto_cntr; +const float biggest_literal_stats_constant_cntr = k.biggest_literal_stats.constant_cntr; +const float biggest_assertion_stats_true_cntr = k.biggest_assertion_stats.true_cntr; +const float biggest_assertion_stats_trigonometry_cntr = k.biggest_assertion_stats.trigonometry_cntr; +const float smallest_assertion_stats_trigonometry_cntr = k.smallest_assertion_stats.trigonometry_cntr; +const float assertions_stats_multiplication_cntr = k.assertions_stats.multiplication_cntr; +const float LOG2P1_box_boolean_count = log2(1+k.box_boolean_count); +const float biggest_literal_stats_log_cntr = k.biggest_literal_stats.log_cntr; +const float middle_assertion_stats_min_cntr = k.middle_assertion_stats.min_cntr; +const float smallest_assertion_stats_unique_variables = k.smallest_assertion_stats.unique_variables; +const float biggest_literal_stats_equalto_cntr = k.biggest_literal_stats.equalto_cntr; +const float middle_literal_stats_unique_variables = k.middle_literal_stats.unique_variables; +const float smallest_assertion_stats_false_cntr = k.smallest_assertion_stats.false_cntr; +const float biggest_literal_stats_false_cntr = k.biggest_literal_stats.false_cntr; +const float LOG2P1_assertions_size = log2(1+k.assertions_size); +const float smallest_literal_stats_uninterpretedfunction_cntr = k.smallest_literal_stats.uninterpretedfunction_cntr; +const float smallest_literal_stats_equalto_cntr = k.smallest_literal_stats.equalto_cntr; +const float smallest_assertion_stats_min_cntr = k.smallest_assertion_stats.min_cntr; +const float biggest_literal_stats_true_cntr = k.biggest_literal_stats.true_cntr; +const float middle_assertion_stats_unique_variables = k.middle_assertion_stats.unique_variables; +const float assertions_stats_log_cntr = k.assertions_stats.log_cntr; +const float assertions_stats_notequalto_cntr = k.assertions_stats.notequalto_cntr; +const float middle_literal_stats_disjunction_cntr = k.middle_literal_stats.disjunction_cntr; +const float middle_assertion_stats_trigonometry_cntr = k.middle_assertion_stats.trigonometry_cntr; +const float smallest_assertion_stats_variable_cntr = k.smallest_assertion_stats.variable_cntr; +const float LOG2P1_theory_checksat_ms = log2(1+k.theory_checksat_ms); +const float middle_assertion_stats_ifthenelse_cntr = k.middle_assertion_stats.ifthenelse_cntr; +const float biggest_assertion_stats_forall_cntr = k.biggest_assertion_stats.forall_cntr; +const float lemma_stats_negation_cntr = k.lemma_stats.negation_cntr; +const float smallest_assertion_stats_division_cntr = k.smallest_assertion_stats.division_cntr; +const float smallest_assertion_stats_log_cntr = k.smallest_assertion_stats.log_cntr; +const float lemma_stats_log_cntr = k.lemma_stats.log_cntr; +const float LOG2P1_box_integer_count = log2(1+k.box_integer_count); +const float smallest_literal_stats_inequality_cntr = k.smallest_literal_stats.inequality_cntr; +const float lemma_size = k.lemma_size; +const float biggest_assertion_stats_log_cntr = k.biggest_assertion_stats.log_cntr; +const float biggest_literal_stats_ifthenelse_cntr = k.biggest_literal_stats.ifthenelse_cntr; +const float smallest_literal_stats_variable_cntr = k.smallest_literal_stats.variable_cntr; +const float middle_literal_stats_sqrt_cntr = k.middle_literal_stats.sqrt_cntr; +const float biggest_assertion_stats_variable_cntr = k.biggest_assertion_stats.variable_cntr; +const float biggest_literal_stats_sqrt_cntr = k.biggest_literal_stats.sqrt_cntr; +const float middle_assertion_stats_uninterpretedfunction_cntr = k.middle_assertion_stats.uninterpretedfunction_cntr; +const float assertions_stats_pow_cntr = k.assertions_stats.pow_cntr; +const float lemma_stats_addition_cntr = k.lemma_stats.addition_cntr; +const float middle_literal_stats_abs_cntr = k.middle_literal_stats.abs_cntr; +const float biggest_assertion_stats_disjunction_cntr = k.biggest_assertion_stats.disjunction_cntr; +const float middle_literal_stats_forall_cntr = k.middle_literal_stats.forall_cntr; +const float LOG2P1_lemma_size = log2(1+k.lemma_size); +const float smallest_literal_stats_division_cntr = k.smallest_literal_stats.division_cntr; +const float assertions_stats_true_cntr = k.assertions_stats.true_cntr; +const float assertions_stats_variable_cntr = k.assertions_stats.variable_cntr; +const float theory_checksat_ms = k.theory_checksat_ms; +const float box_boolean_count = k.box_boolean_count; +const float biggest_literal_stats_pow_cntr = k.biggest_literal_stats.pow_cntr; +const float middle_literal_stats_log_cntr = k.middle_literal_stats.log_cntr; +const float assertions_stats_max_cntr = k.assertions_stats.max_cntr; +const float biggest_literal_stats_realconstant_cntr = k.biggest_literal_stats.realconstant_cntr; +const float smallest_literal_stats_exp_cntr = k.smallest_literal_stats.exp_cntr; +const float smallest_assertion_stats_realconstant_cntr = k.smallest_assertion_stats.realconstant_cntr; +const float smallest_assertion_stats_multiplication_cntr = k.smallest_assertion_stats.multiplication_cntr; +const float middle_literal_stats_trigonometry_cntr = k.middle_literal_stats.trigonometry_cntr; +const float middle_assertion_stats_exp_cntr = k.middle_assertion_stats.exp_cntr; +const float smallest_literal_stats_max_cntr = k.smallest_literal_stats.max_cntr; +const float biggest_assertion_stats_unique_variables = k.biggest_assertion_stats.unique_variables; +const float biggest_literal_stats_multiplication_cntr = k.biggest_literal_stats.multiplication_cntr; +const float middle_assertion_stats_sqrt_cntr = k.middle_assertion_stats.sqrt_cntr; +const float LOG2P1_box_continuous_count = log2(1+k.box_continuous_count); +const float lemma_stats_constant_cntr = k.lemma_stats.constant_cntr; +const float smallest_literal_stats_multiplication_cntr = k.smallest_literal_stats.multiplication_cntr; +const float smallest_assertion_stats_ifthenelse_cntr = k.smallest_assertion_stats.ifthenelse_cntr; +const float middle_assertion_stats_pow_cntr = k.middle_assertion_stats.pow_cntr; +const float smallest_assertion_stats_sqrt_cntr = k.smallest_assertion_stats.sqrt_cntr; +const float smallest_assertion_stats_negation_cntr = k.smallest_assertion_stats.negation_cntr; +const float middle_assertion_stats_equalto_cntr = k.middle_assertion_stats.equalto_cntr; +const float biggest_literal_stats_negation_cntr = k.biggest_literal_stats.negation_cntr; +const float biggest_literal_stats_max_cntr = k.biggest_literal_stats.max_cntr; +const float smallest_literal_stats_ifthenelse_cntr = k.smallest_literal_stats.ifthenelse_cntr; +const float biggest_literal_stats_addition_cntr = k.biggest_literal_stats.addition_cntr; +const float assertions_stats_conjunction_cntr = k.assertions_stats.conjunction_cntr; +const float smallest_assertion_stats_true_cntr = k.smallest_assertion_stats.true_cntr; +const float smallest_literal_stats_sqrt_cntr = k.smallest_literal_stats.sqrt_cntr; +const float biggest_assertion_stats_constant_cntr = k.biggest_assertion_stats.constant_cntr; +const float assertions_size = k.assertions_size; +const float biggest_assertion_stats_inequality_cntr = k.biggest_assertion_stats.inequality_cntr; +const float middle_literal_stats_max_cntr = k.middle_literal_stats.max_cntr; +const float smallest_literal_stats_disjunction_cntr = k.smallest_literal_stats.disjunction_cntr; +const float biggest_literal_stats_trigonometry_cntr = k.biggest_literal_stats.trigonometry_cntr; +const float smallest_assertion_stats_abs_cntr = k.smallest_assertion_stats.abs_cntr; +const float lemma_stats_forall_cntr = k.lemma_stats.forall_cntr; + +float x0[220]; +float x1[8]; +float x2[4]; +float x3_result[1]; + +x0[0] = 0.012060021933562159*lemma_stats_equalto_cntr - 0.13077405009633181; +x0[1] = 1.0*smallest_assertion_stats_notequalto_cntr; +x0[2] = 2.0912591059314334*smallest_literal_stats_unique_variables - 2.1616707779232285; +x0[3] = 0.11355810049368795*smallest_literal_stats_constant_cntr - 0.10184989913169329; +x0[4] = 1.0784956699158499*middle_assertion_stats_constant_cntr - 0.86756567892610137; +x0[5] = 0.8177201550461547*middle_literal_stats_realconstant_cntr - 0.47692941238456099; +x0[6] = 1.0*assertions_stats_min_cntr; +x0[7] = 0.22574457632123524*smallest_literal_stats_pow_cntr - 0.025429102002981659; +x0[8] = 2.0941748701487657*middle_literal_stats_equalto_cntr - 1.3575582013159881; +x0[9] = 0.0060158430467202326*lemma_stats_multiplication_cntr - 0.066145337728903422; +x0[10] = 0.22583392755190518*middle_literal_stats_multiplication_cntr - 0.076229900603439829; +x0[11] = 2.1822255594854378*middle_literal_stats_division_cntr - 0.028611025566566251; +x0[12] = 1.0*assertions_stats_exp_cntr; +x0[13] = 0.35521064491361387*biggest_assertion_stats_realconstant_cntr - 0.024828920951680846; +x0[14] = 0.0017334600017936373*box_continuous_count - 0.58442534836576887; +x0[15] = 1.0*middle_literal_stats_uninterpretedfunction_cntr; +x0[16] = 1.9432202120985784*box_integer_count - 1.0727661000227684; +x0[17] = 1.0*smallest_assertion_stats_exp_cntr; +x0[18] = 1.0*middle_assertion_stats_notequalto_cntr; +x0[19] = 1.0*middle_assertion_stats_log_cntr; +x0[20] = 1.0*middle_assertion_stats_forall_cntr; +x0[21] = 0.20061847213954173*middle_literal_stats_addition_cntr - 0.056870434227919743; +x0[22] = 1.2301038566497999*lemma_stats_division_cntr - 0.082070544353671684; +x0[23] = 0.17207873187544159*biggest_assertion_stats_addition_cntr - 0.60721498210663005; +x0[24] = 1.0*lemma_stats_max_cntr; +x0[25] = 1.0*smallest_literal_stats_false_cntr; +x0[26] = 1.6013170000800234*lemma_stats_trigonometry_cntr - 0.087084811253382188; +x0[27] = 2.8897480514079743*middle_assertion_stats_inequality_cntr - 0.40196417813611313; +x0[28] = 1.0*biggest_assertion_stats_abs_cntr; +x0[29] = 1.0*assertions_stats_ifthenelse_cntr; +x0[30] = 1.0*biggest_literal_stats_min_cntr; +x0[31] = 0.0018080221517174668*assertions_stats_negation_cntr - 1.3687231241606317; +x0[32] = 0.0017343103870421793*assertions_stats_unique_variables - 0.58538074892671133; +x0[33] = 0.0069435562741672532*lemma_stats_conjunction_cntr - 0.12134793808236284; +x0[34] = 113.53854005396379*biggest_literal_stats_abs_cntr - 0.008808265326141488; +x0[35] = 1.0*middle_assertion_stats_abs_cntr; +x0[36] = 0.9253024882411206*assertions_stats_division_cntr - 0.12138762665754345; +x0[37] = 1.0*biggest_assertion_stats_conjunction_cntr; +x0[38] = 2.4313917659418705*middle_assertion_stats_realconstant_cntr - 0.52438084633967419; +x0[39] = 1.0*smallest_literal_stats_forall_cntr; +x0[40] = 1.0*smallest_assertion_stats_conjunction_cntr; +x0[41] = 0.80039329263014425*biggest_literal_stats_unique_variables - 1.143463342419248; +x0[42] = 1.0948904341294901*smallest_assertion_stats_constant_cntr - 0.73040828883471565; +x0[43] = 1.0*lemma_stats_ifthenelse_cntr; +x0[44] = 1.0*middle_literal_stats_ifthenelse_cntr; +x0[45] = 1.0*smallest_literal_stats_log_cntr; +x0[46] = 1.0*smallest_literal_stats_notequalto_cntr; +x0[47] = 1.0*biggest_assertion_stats_false_cntr; +x0[48] = 0.0025642491676076151*assertions_stats_inequality_cntr - 0.51189793807800077; +x0[49] = 1.0*middle_literal_stats_notequalto_cntr; +x0[50] = 0.0071331690118607658*lemma_stats_unique_variables - 0.099029303944258809; +x0[51] = 0.13558170815879236*biggest_literal_stats_variable_cntr - 0.25090504782155415; +x0[52] = 1.0*middle_assertion_stats_disjunction_cntr; +x0[53] = 1.5084382293634835*middle_assertion_stats_variable_cntr - 2.0544718040888532; +x0[54] = 0.015500544957062002*lemma_stats_inequality_cntr - 0.10334257816291656; +x0[55] = 50.783859522963766*smallest_literal_stats_abs_cntr - 0.019698936975548396; +x0[56] = 1.0*lemma_stats_notequalto_cntr; +x0[57] = 3.5430778127515832*biggest_assertion_stats_equalto_cntr - 3.2338487561693077; +x0[58] = 1.0*assertions_stats_sqrt_cntr; +x0[59] = 1.0*assertions_stats_uninterpretedfunction_cntr; +x0[60] = 1.0*smallest_assertion_stats_forall_cntr; +x0[61] = 1.0*middle_assertion_stats_true_cntr; +x0[62] = 0.20071092487784711*smallest_literal_stats_addition_cntr - 0.055308394504741114; +x0[63] = 1.0*biggest_assertion_stats_max_cntr; +x0[64] = 1.0*biggest_assertion_stats_ifthenelse_cntr; +x0[65] = 1.0*biggest_literal_stats_notequalto_cntr; +x0[66] = 1.0*biggest_literal_stats_exp_cntr; +x0[67] = 1.0*biggest_literal_stats_disjunction_cntr; +x0[68] = 2.654159976993224*middle_literal_stats_negation_cntr - 0.45464586727703943; +x0[69] = 2.7356197699342837*biggest_assertion_stats_division_cntr - 0.095078173539996827; +x0[70] = 1.0*middle_literal_stats_false_cntr; +x0[71] = 1.0*lemma_stats_uninterpretedfunction_cntr; +x0[72] = 1.0*biggest_literal_stats_forall_cntr; +x0[73] = 0.25624222226326016*biggest_assertion_stats_pow_cntr - 0.038625185248837436; +x0[74] = 0.12499452918035249*lemma_stats_pow_cntr - 0.11069143138818648; +x0[75] = 1.0*lemma_stats_disjunction_cntr; +x0[76] = 1.1689261602120784*middle_assertion_stats_multiplication_cntr - 0.34106526676164678; +x0[77] = 1.0*middle_assertion_stats_division_cntr; +x0[78] = 1.0*biggest_assertion_stats_sqrt_cntr; +x0[79] = 1.0*biggest_literal_stats_uninterpretedfunction_cntr; +x0[80] = 1.0*middle_literal_stats_conjunction_cntr; +x0[81] = 0.2443203750225911*lemma_stats_realconstant_cntr - 0.2661367250343058; +x0[82] = 1.0*biggest_assertion_stats_exp_cntr; +x0[83] = 1.0*assertions_stats_forall_cntr; +x0[84] = 1.0*lemma_stats_sqrt_cntr; +x0[85] = 2.1747340130869697*middle_assertion_stats_addition_cntr - 0.24041861665236089; +x0[86] = 0.0014571485659065975*assertions_stats_addition_cntr - 0.82981615138931808; +x0[87] = 0.11347593501396197*middle_literal_stats_constant_cntr - 0.098959114467955508; +x0[88] = 0.0014053437737330519*assertions_stats_realconstant_cntr - 1.0952587585298792; +x0[89] = 1.0*lemma_stats_false_cntr; +x0[90] = 1.5985510467578241*smallest_assertion_stats_addition_cntr - 0.1887505580423125; +x0[91] = 0.0022576329729095328*lemma_stats_variable_cntr - 0.086744599107285048; +x0[92] = 1.0*assertions_stats_disjunction_cntr; +x0[93] = 2.0000404701721601*middle_assertion_stats_negation_cntr - 1.0063818843705687; +x0[94] = 0.81788635256080222*smallest_literal_stats_realconstant_cntr - 0.4769628946624942; +x0[95] = 0.0013256836187079536*assertions_stats_constant_cntr - 1.5256195401983568; +x0[96] = 1.0*smallest_assertion_stats_max_cntr; +x0[97] = 1.0*middle_assertion_stats_false_cntr; +x0[98] = 1.0*middle_literal_stats_true_cntr; +x0[99] = 1.0*assertions_stats_false_cntr; +x0[100] = 0.22567669484734096*middle_literal_stats_pow_cntr - 0.028555367672305126; +x0[101] = 1.0*lemma_stats_true_cntr; +x0[102] = 1.7741310128313188*biggest_literal_stats_division_cntr - 0.053540493715390457; +x0[103] = 1.0*middle_assertion_stats_max_cntr; +x0[104] = 1.0*middle_assertion_stats_conjunction_cntr; +x0[105] = 1.0*lemma_stats_min_cntr; +x0[106] = 1.0*biggest_literal_stats_conjunction_cntr; +x0[107] = 1.0*biggest_assertion_stats_notequalto_cntr; +x0[108] = 1.3563299976310219*assertions_stats_trigonometry_cntr - 0.11406219685275623; +x0[109] = 1.0*biggest_assertion_stats_min_cntr; +x0[110] = 2.043518255782228*smallest_assertion_stats_equalto_cntr - 1.2315011490237662; +x0[111] = 34.237746428327789*assertions_stats_abs_cntr - 0.018593035298548839; +x0[112] = 1.0*smallest_literal_stats_true_cntr; +x0[113] = 1.0*biggest_assertion_stats_uninterpretedfunction_cntr; +x0[114] = 1.0*smallest_assertion_stats_disjunction_cntr; +x0[115] = 2.043518255782228*smallest_assertion_stats_inequality_cntr - 0.81201710675846184; +x0[116] = 3.8762142277239313*smallest_literal_stats_trigonometry_cntr - 0.035785065407226362; +x0[117] = 2.1255726952317442*smallest_assertion_stats_pow_cntr - 0.041884830456855163; +x0[118] = 1.0*middle_literal_stats_min_cntr; +x0[119] = 1.0*smallest_assertion_stats_uninterpretedfunction_cntr; +x0[120] = 2.0941748701487657*middle_literal_stats_inequality_cntr - 0.73661666883277765; +x0[121] = 34.237746428327789*lemma_stats_abs_cntr - 0.018593035298548839; +x0[122] = 2.1270398568572664*smallest_literal_stats_negation_cntr - 0.701477612994588; +x0[123] = 4.2960917448574234*biggest_assertion_stats_negation_cntr - 0.24696694980134606; +x0[124] = 2.3076136167747214*biggest_literal_stats_inequality_cntr - 0.57824608085200546; +x0[125] = 1.0*smallest_literal_stats_min_cntr; +x0[126] = 1.0*lemma_stats_exp_cntr; +x0[127] = 0.17824090761400588*middle_literal_stats_variable_cntr - 0.2492192302503668; +x0[128] = 1.0*middle_literal_stats_exp_cntr; +x0[129] = 1.0*smallest_literal_stats_conjunction_cntr; +x0[130] = 0.11279171999706769*biggest_assertion_stats_multiplication_cntr - 0.50845527338010954; +x0[131] = 0.0010478373585679356*assertions_stats_equalto_cntr - 1.7290093555637649; +x0[132] = 0.081392968854540143*biggest_literal_stats_constant_cntr - 0.0982272322343853; +x0[133] = 1.0*biggest_assertion_stats_true_cntr; +x0[134] = 5.2805429361484739*biggest_assertion_stats_trigonometry_cntr - 0.039737212164965244; +x0[135] = 19.473165433281935*smallest_assertion_stats_trigonometry_cntr - 0.015107188078574037; +x0[136] = 0.0020926462044186691*assertions_stats_multiplication_cntr - 0.8290502543065239; +x0[137] = 0.18680874324467026*LOG2P1_box_boolean_count - 0.69856632169121324; +x0[138] = 1.0*biggest_literal_stats_log_cntr; +x0[139] = 1.0*middle_assertion_stats_min_cntr; +x0[140] = 2.9017916017956864*smallest_assertion_stats_unique_variables - 2.929706431789687; +x0[141] = 2.307613616774721*biggest_literal_stats_equalto_cntr - 1.7293675359227159; +x0[142] = 1.8027957745963139*middle_literal_stats_unique_variables - 2.0233550404255141; +x0[143] = 1.0*smallest_assertion_stats_false_cntr; +x0[144] = 1.0*biggest_literal_stats_false_cntr; +x0[145] = 0.40207252399068183*LOG2P1_assertions_size - 4.0220936053549838; +x0[146] = 1.0*smallest_literal_stats_uninterpretedfunction_cntr; +x0[147] = 2.0232375396769844*smallest_literal_stats_equalto_cntr - 1.1644995583292124; +x0[148] = 1.0*smallest_assertion_stats_min_cntr; +x0[149] = 1.0*biggest_literal_stats_true_cntr; +x0[150] = 1.7255138236253043*middle_assertion_stats_unique_variables - 2.312509798535852; +x0[151] = 113.53854005396381*assertions_stats_log_cntr - 0.0088082653261414897; +x0[152] = 1.0*assertions_stats_notequalto_cntr; +x0[153] = 1.0*middle_literal_stats_disjunction_cntr; +x0[154] = 24.795385773122163*middle_assertion_stats_trigonometry_cntr - 0.040395896139299101; +x0[155] = 2.4887119517086012*smallest_assertion_stats_variable_cntr - 2.5369802207487218; +x0[156] = 0.6120128546931537*LOG2P1_theory_checksat_ms - 0.46818793319187496; +x0[157] = 1.0*middle_assertion_stats_ifthenelse_cntr; +x0[158] = 1.0*biggest_assertion_stats_forall_cntr; +x0[159] = 0.017639538853394594*lemma_stats_negation_cntr - 0.080831236730291578; +x0[160] = 13.768821746778553*smallest_assertion_stats_division_cntr - 0.01068178568407956; +x0[161] = 1.0*smallest_assertion_stats_log_cntr; +x0[162] = 1.0*lemma_stats_log_cntr; +x0[163] = 2.0017011220528755*LOG2P1_box_integer_count - 1.1020477768850323; +x0[164] = 2.0232375396769844*smallest_literal_stats_inequality_cntr - 0.85873798134777202; +x0[165] = 0.0069437513556026937*lemma_size - 0.12158944964901437; +x0[166] = 113.53854005396381*biggest_assertion_stats_log_cntr - 0.0088082653261414897; +x0[167] = 1.0*biggest_literal_stats_ifthenelse_cntr; +x0[168] = 0.17837794866259055*smallest_literal_stats_variable_cntr - 0.23355195031641121; +x0[169] = 1.0*middle_literal_stats_sqrt_cntr; +x0[170] = 0.14428401100058252*biggest_assertion_stats_variable_cntr - 0.94809930300700862; +x0[171] = 1.0*biggest_literal_stats_sqrt_cntr; +x0[172] = 1.0*middle_assertion_stats_uninterpretedfunction_cntr; +x0[173] = 0.042312206432987762*assertions_stats_pow_cntr - 0.60818298458376063; +x0[174] = 0.0056719421304003053*lemma_stats_addition_cntr - 0.058215071521321174; +x0[175] = 113.53854005396379*middle_literal_stats_abs_cntr - 0.008808265326141488; +x0[176] = 1.0*biggest_assertion_stats_disjunction_cntr; +x0[177] = 1.0*middle_literal_stats_forall_cntr; +x0[178] = 0.72401355669048295*LOG2P1_lemma_size - 1.5712693625351697; +x0[179] = 2.1838186991523911*smallest_literal_stats_division_cntr - 0.028293073914542229; +x0[180] = 1.0*assertions_stats_true_cntr; +x0[181] = 0.00055485511013681366*assertions_stats_variable_cntr - 1.3260489594876443; +x0[182] = 0.00047923755762088971*theory_checksat_ms - 0.041050603750268734; +x0[183] = 0.00046717948643324586*box_boolean_count - 0.56646527549706782; +x0[184] = 0.18678289239706466*biggest_literal_stats_pow_cntr - 0.028937582320941669; +x0[185] = 1.0*middle_literal_stats_log_cntr; +x0[186] = 1.0*assertions_stats_max_cntr; +x0[187] = 0.33209312111402756*biggest_literal_stats_realconstant_cntr - 0.18163355344095378; +x0[188] = 1.0*smallest_literal_stats_exp_cntr; +x0[189] = 1.7377524285899715*smallest_assertion_stats_realconstant_cntr - 0.81589431325263828; +x0[190] = 1.8510384775237294*smallest_assertion_stats_multiplication_cntr - 0.19630485638285014; +x0[191] = 3.8238820163722336*middle_literal_stats_trigonometry_cntr - 0.040641725077036152; +x0[192] = 1.0*middle_assertion_stats_exp_cntr; +x0[193] = 1.0*smallest_literal_stats_max_cntr; +x0[194] = 0.47112727137981791*biggest_assertion_stats_unique_variables - 2.5308927778662134; +x0[195] = 0.11754320648445506*biggest_literal_stats_multiplication_cntr - 0.078295265389878285; +x0[196] = 1.0*middle_assertion_stats_sqrt_cntr; +x0[197] = 0.37596563832047197*LOG2P1_box_continuous_count - 2.2589678491559266; +x0[198] = 0.0056245581232980957*lemma_stats_constant_cntr - 0.097673135366731514; +x0[199] = 0.22628710605841132*smallest_literal_stats_multiplication_cntr - 0.0662534940468925; +x0[200] = 1.0*smallest_assertion_stats_ifthenelse_cntr; +x0[201] = 4.6194934013477793*middle_assertion_stats_pow_cntr - 0.21896900451695062; +x0[202] = 1.0*smallest_assertion_stats_sqrt_cntr; +x0[203] = 2.0821013133084607*smallest_assertion_stats_negation_cntr - 1.3305095824454454; +x0[204] = 2.8897480514079743*middle_assertion_stats_equalto_cntr - 2.4877838732718613; +x0[205] = 4.1326787755776833*biggest_literal_stats_negation_cntr - 0.2580920414538429; +x0[206] = 1.0*biggest_literal_stats_max_cntr; +x0[207] = 1.0*smallest_literal_stats_ifthenelse_cntr; +x0[208] = 0.15392647098224665*biggest_literal_stats_addition_cntr - 0.094959138654059375; +x0[209] = 0.0010007277390044853*assertions_stats_conjunction_cntr - 1.8510488937317557; +x0[210] = 1.0*smallest_assertion_stats_true_cntr; +x0[211] = 1.0*smallest_literal_stats_sqrt_cntr; +x0[212] = 0.092383493135436215*biggest_assertion_stats_constant_cntr - 0.43437442734362935; +x0[213] = 0.0010007280265520134*assertions_size - 1.8510495808812195; +x0[214] = 3.5430778127515832*biggest_assertion_stats_inequality_cntr - 0.30922905658227551; +x0[215] = 1.0*middle_literal_stats_max_cntr; +x0[216] = 1.0*smallest_literal_stats_disjunction_cntr; +x0[217] = 3.2848954335701617*biggest_literal_stats_trigonometry_cntr - 0.034658322650546317; +x0[218] = 113.53854005396379*smallest_assertion_stats_abs_cntr - 0.008808265326141488; +x0[219] = 1.0*lemma_stats_forall_cntr; +x1[0] = relu(0.69722515599675816*x0[0] + 7.4258130304407669e-316*x0[1] - 0.013004996057516337*x0[2] + 0.16119898473116079*x0[3] + 0.17111355461967018*x0[4] + 0.067592103332607942*x0[5] + 3.7380792043419031e-315*x0[6] + 0.023509776025002763*x0[7] + 0.15221754833028134*x0[8] + 0.20445016213956199*x0[9] + 0.16659145941531447*x0[10] + 0.12953018352946197*x0[11] + 1.8006001664747104e-315*x0[12] + 0.14073655496056112*x0[13] + 0.1558580238299343*x0[14] - 7.4568552066707891e-304*x0[15] - 0.29177410475856747*x0[16] + 5.3575783978726722e-316*x0[17] - 1.2311787552695656e-310*x0[18] - 1.9734734692516225e-300*x0[19] + 3.9946215256428514e-314*x0[20] - 0.13006053098856374*x0[21] + 0.14769995413896575*x0[22] - 0.1630750850603922*x0[23] + 5.0153717554927963e-299*x0[24] + 2.1971739949198347e-313*x0[25] - 0.023368479948913484*x0[26] - 0.041164747752068784*x0[27] - 3.1644271681534095e-309*x0[28] - 9.8271127791251607e-316*x0[29] + 2.7125229451569316e-294*x0[30] + 0.18512559454726801*x0[31] + 0.16064932299205728*x0[32] + 0.57388140921224795*x0[33] - 0.017372520301574195*x0[34] + 5.8042784665486045e-299*x0[35] + 0.26196016555378832*x0[36] + 1.2276417037748935e-305*x0[37] - 0.056849558449800212*x0[38] - 7.0778413612731949e-292*x0[39] + 1.9643030673000898e-315*x0[40] + 0.65924896073661587*x0[41] + 0.31937351674131337*x0[42] - 3.5192241606050949e-317*x0[43] + 1.3103225835698773e-312*x0[44] - 2.2141050688777758e-315*x0[45] + 2.2491516939381426e-303*x0[46] - 7.0816177356514876e-301*x0[47] + 0.15103797925233989*x0[48] - 4.0990965784373166e-315*x0[49] + 0.52492489010212684*x0[50] + 0.23927650696410449*x0[51] + 2.5296422792422378e-310*x0[52] + 0.028712629027192207*x0[53] - 0.2375344361697832*x0[54] - 0.26624788617942302*x0[55] - 5.7182962693735768e-315*x0[56] - 0.044723061428655494*x0[57] - 6.1830531177035017e-293*x0[58] + 7.0399898100316262e-293*x0[59] - 5.9512959629510822e-315*x0[60] + 1.2414112782574945e-294*x0[61] + 0.068047429172219898*x0[62] + 1.7258373290016286e-311*x0[63] - 1.0836396389562363e-294*x0[64] - 1.5351826124594674e-316*x0[65] - 7.4994245837527376e-294*x0[66] - 1.1809502743576548e-300*x0[67] - 0.068801329690522342*x0[68] + 0.052770257648257303*x0[69] + 1.1457436741742238e-310*x0[70] - 4.56084836064003e-297*x0[71] - 1.6556208626813975e-301*x0[72] + 0.1757794900750366*x0[73] + 0.55203784126626843*x0[74] - 3.393285790618427e-302*x0[75] + 0.49087123305203456*x0[76] - 9.5869667785670187e-295*x0[77] - 2.0706583704068981e-316*x0[78] - 1.7865982917243484e-316*x0[79] + 1.957898909061027e-291*x0[80] + 0.034224391212281706*x0[81] - 2.7124074890955309e-310*x0[82] - 8.8665176119003892e-298*x0[83] - 1.0930865845322962e-295*x0[84] - 0.011611902071943011*x0[85] + 0.21276406371955056*x0[86] - 0.046876552984425779*x0[87] - 0.27382164881483329*x0[88] - 7.9039096346968264e-316*x0[89] + 0.38924739387862994*x0[90] + 0.32124213310515021*x0[91] + 1.2467668461025249e-315*x0[92] + 0.14082962089324677*x0[93] + 0.23503997489633549*x0[94] - 0.21063216486986247*x0[95] - 6.8489169738404794e-313*x0[96] - 1.4318928498449223e-305*x0[97] - 3.5673543359587292e-303*x0[98] - 6.5266282781659443e-316*x0[99] + 0.28114551068291338*x0[100] - 2.2600394043314621e-315*x0[101] + 0.057544401505819014*x0[102] - 1.79495619768813e-315*x0[103] - 5.1001340126008118e-300*x0[104] + 7.2495003913079863e-291*x0[105] - 1.5902438818766566e-315*x0[106] + 1.3690114499345883e-293*x0[107] + 0.075089598177098288*x0[108] + 2.78850247132903e-313*x0[109] - 0.04679987500421199*x0[110] - 0.26129900332789546*x0[111] + 2.6185989938132592e-310*x0[112] + 2.092430455094657e-315*x0[113] + 6.2126108353685111e-315*x0[114] + 0.079084758312359157*x0[115] + 0.13815237964890761*x0[116] + 0.25717554431996764*x0[117] - 4.4297874206431973e-304*x0[118] + 5.0264693290475013e-302*x0[119] - 0.3585864190868458*x0[120] - 0.11303912961498307*x0[121] + 0.025656318684385487*x0[122] - 0.042176241711434831*x0[123] + 0.058390538366545536*x0[124] - 1.1265596247835723e-302*x0[125] - 4.9572427191756153e-307*x0[126] - 0.10295293804430956*x0[127] + 8.4386004108186635e-294*x0[128] - 1.226938186318174e-305*x0[129] - 0.14246321510051124*x0[130] - 0.062219415689560784*x0[131] + 0.17343899942134239*x0[132] + 2.1743009467973374e-315*x0[133] - 0.049045767530342309*x0[134] + 0.072485997284349971*x0[135] + 0.10554528722054038*x0[136] + 0.13906972368345522*x0[137] + 2.8972233028691631e-290*x0[138] + 1.087695529983541e-306*x0[139] + 0.032759930896729038*x0[140] - 0.17358613683444757*x0[141] + 0.37641626060699063*x0[142] - 1.2281546967584665e-308*x0[143] + 1.40323409088604e-310*x0[144] + 0.25554422176444086*x0[145] - 1.8040972568671866e-290*x0[146] + 0.24100858694328889*x0[147] - 9.4962713589558044e-298*x0[148] + 1.0404208500004574e-312*x0[149] + 0.20571724578670025*x0[150] - 0.20131571278957816*x0[151] - 7.1999152942670498e-296*x0[152] + 7.8393393061236714e-316*x0[153] - 0.22774987052120615*x0[154] + 0.095739270660818679*x0[155] - 0.60156864187736681*x0[156] + 7.3284128101546478e-304*x0[157] + 5.9604168417430698e-291*x0[158] - 0.29482838533669514*x0[159] + 0.004985992059779322*x0[160] - 2.4539459963266822e-292*x0[161] - 9.7409933825442511e-302*x0[162] - 0.064044367789539702*x0[163] - 0.13481068611791625*x0[164] + 0.37041495618324988*x0[165] - 0.081956890361633603*x0[166] + 1.1370700303127477e-303*x0[167] - 0.0018319900388832639*x0[168] + 2.5693389352262539e-316*x0[169] - 0.013768589878768823*x0[170] + 9.7522794458912587e-303*x0[171] + 4.2105960881079674e-315*x0[172] - 0.018122288160148461*x0[173] - 0.14592361871444004*x0[174] - 0.2343523889624021*x0[175] + 6.0245735414248802e-316*x0[176] + 8.8966829901884493e-293*x0[177] + 1.0037408707878128*x0[178] + 9.2360255380799099e-5*x0[179] + 6.1059703276866036e-292*x0[180] + 0.12995302692079069*x0[181] - 0.29813758308694072*x0[182] + 0.44672427808738369*x0[183] + 0.25296527223291809*x0[184] + 6.22541250807761e-303*x0[185] - 2.0695000680848185e-315*x0[186] - 0.0018602728284304172*x0[187] + 4.139865719418525e-316*x0[188] + 0.090597186842315061*x0[189] - 0.018271261731276033*x0[190] + 0.21253650765601187*x0[191] - 1.041326964712663e-303*x0[192] - 3.6547860573760376e-293*x0[193] - 0.26644182488039375*x0[194] + 0.11363345276207512*x0[195] + 5.4282857974502395e-315*x0[196] - 0.047850342409283347*x0[197] + 0.37271321188217438*x0[198] + 0.049208282218349164*x0[199] - 6.6784019473983824e-305*x0[200] - 0.15617896203945889*x0[201] + 2.2300800144761096e-290*x0[202] + 0.13758288253363865*x0[203] + 0.038022547543690187*x0[204] + 0.13305839495482166*x0[205] - 8.271097632223156e-305*x0[206] - 4.286996299801863e-315*x0[207] + 0.072026313277703036*x0[208] + 0.017861024030143786*x0[209] + 1.0613866888320882e-312*x0[210] - 2.0223948662196788e-315*x0[211] - 0.31987796762783011*x0[212] - 0.12110255085441921*x0[213] - 0.022665932635410196*x0[214] - 4.3399403329487182e-300*x0[215] + 1.0560620844719169e-302*x0[216] + 0.056532698885382066*x0[217] - 0.15713833463597332*x0[218] + 6.5994250004956283e-291*x0[219] + 0.12205422900729977); +x1[1] = relu(0.13188903818913203*x0[0] - 4.1766158879268582e-310*x0[1] + 0.047365417074651021*x0[2] + 0.13131424304773226*x0[3] - 0.11314384158972304*x0[4] - 0.09857774788530789*x0[5] - 1.1321515059370275e-302*x0[6] - 0.063691896677178034*x0[7] + 0.10694749712140737*x0[8] - 0.0077213625888383191*x0[9] + 0.026145518191593369*x0[10] - 0.0072636694082904912*x0[11] + 4.0890961907591875e-315*x0[12] - 0.28541937796618361*x0[13] + 0.071378076871395787*x0[14] + 8.8747542970547235e-298*x0[15] + 0.10419981196040423*x0[16] + 2.1374772094065107e-310*x0[17] + 2.8936131307677879e-293*x0[18] - 7.3927445744792727e-316*x0[19] - 4.1277699183096172e-314*x0[20] - 0.03521222658253971*x0[21] - 0.034034876816773474*x0[22] + 0.048689962559718636*x0[23] - 4.9971629938542174e-314*x0[24] - 3.9653003469008237e-296*x0[25] - 0.092971176107231698*x0[26] + 0.07774574958848679*x0[27] + 2.5602810805506524e-307*x0[28] + 2.0866896593228046e-315*x0[29] - 3.1014887507359946e-293*x0[30] + 0.11224318781162088*x0[31] + 0.035706429819991586*x0[32] + 0.056678390746622891*x0[33] + 0.15576054912789808*x0[34] - 3.6748221617903044e-312*x0[35] + 0.014540068520243525*x0[36] + 7.8079683557152564e-305*x0[37] + 0.68577929000428872*x0[38] - 4.6897521666516918e-293*x0[39] + 2.20313573849424e-311*x0[40] - 0.11098302813272121*x0[41] + 0.13078489883554167*x0[42] + 1.9077228128173876e-315*x0[43] - 2.7084777310115989e-301*x0[44] + 2.6867959964572087e-313*x0[45] + 7.7943241709830317e-295*x0[46] - 1.3707328078675466e-292*x0[47] + 0.084260496986270084*x0[48] - 3.5497432049868978e-306*x0[49] + 0.10920060858602389*x0[50] - 0.27857369531073323*x0[51] + 1.1967195477484896e-311*x0[52] - 0.051307335550402608*x0[53] - 0.1408940975323324*x0[54] + 0.16998158331306684*x0[55] - 5.0892944200407966e-296*x0[56] - 0.01808052112065869*x0[57] - 7.1336079831471368e-315*x0[58] + 1.6040239645699751e-298*x0[59] + 2.5456241667171692e-311*x0[60] + 7.7723447256915074e-299*x0[61] - 0.11894645355033386*x0[62] - 2.7176276491347895e-301*x0[63] - 5.6045915030490587e-300*x0[64] - 5.7195051491958211e-316*x0[65] - 1.5278733536714545e-300*x0[66] - 5.4588253196865909e-307*x0[67] - 0.043107574128245792*x0[68] - 0.046787961930795617*x0[69] - 2.2860219360067425e-305*x0[70] + 9.2358300642618408e-313*x0[71] - 1.4130162301470954e-295*x0[72] - 0.081023492428876603*x0[73] - 0.057904729039643464*x0[74] + 6.2365388768781412e-310*x0[75] + 0.10977260463313593*x0[76] + 1.0006643938956263e-309*x0[77] + 2.5131602162930428e-314*x0[78] - 3.7311549039593768e-316*x0[79] - 1.5253393561920826e-311*x0[80] + 0.46532655660967776*x0[81] + 3.5361781936947851e-314*x0[82] + 1.1458882613981187e-300*x0[83] + 2.7838869962800363e-315*x0[84] + 0.18654021369091828*x0[85] + 0.0739793684375563*x0[86] + 0.032488508355859778*x0[87] + 0.34149839210168353*x0[88] - 1.5384704711128472e-315*x0[89] + 0.14179637473893111*x0[90] - 0.13509970676322205*x0[91] + 9.9858052600376213e-303*x0[92] - 0.12173515331136096*x0[93] - 0.13960503238956892*x0[94] + 0.050918789700772411*x0[95] - 1.8401390452208834e-302*x0[96] - 8.7186277519807703e-310*x0[97] - 1.1621806931907162e-296*x0[98] + 1.7614515212866096e-315*x0[99] - 0.10479405035625809*x0[100] + 4.2772119544977707e-299*x0[101] - 0.091113760467844945*x0[102] + 1.1049383731956345e-295*x0[103] + 4.1940631543866977e-302*x0[104] + 3.7009367084597761e-312*x0[105] + 3.3346644564041597e-316*x0[106] - 1.0826566474400268e-315*x0[107] + 0.0062152519121483575*x0[108] + 3.3961592609165482e-315*x0[109] + 0.14490280995104451*x0[110] - 0.057646709134404811*x0[111] + 9.1132913553210959e-298*x0[112] + 3.6024683160087478e-298*x0[113] + 1.588440789302159e-315*x0[114] - 0.093944990852156698*x0[115] - 0.071445093461574488*x0[116] + 0.15217144512393815*x0[117] + 4.8258595087332005e-291*x0[118] + 1.7946903252312902e-296*x0[119] - 0.060387349722643965*x0[120] + 0.015182330288086262*x0[121] - 0.24786137873274192*x0[122] - 0.0054395481161765057*x0[123] + 0.0064010914686194378*x0[124] - 1.6320776799774319e-316*x0[125] - 6.6005845200328392e-316*x0[126] - 0.011465852257561485*x0[127] - 2.665050666115864e-315*x0[128] - 2.0783054137349389e-299*x0[129] + 0.13485341716046639*x0[130] + 0.03860151892019232*x0[131] - 0.42571693799756072*x0[132] - 3.4001242628835975e-308*x0[133] - 0.092526980349317625*x0[134] - 0.050005322689762759*x0[135] - 0.15084224640780608*x0[136] - 0.09471600736856163*x0[137] + 5.6149226046074698e-302*x0[138] - 1.7306934249795111e-315*x0[139] + 0.1492692680160998*x0[140] - 0.054127052996083121*x0[141] + 0.020355632105904353*x0[142] + 1.8781253707302802e-299*x0[143] + 3.3376020477791789e-311*x0[144] - 0.082504762020360611*x0[145] + 2.8146590185935598e-310*x0[146] - 0.0019869137412539257*x0[147] - 3.208640829096398e-295*x0[148] - 1.0199721427337656e-316*x0[149] - 0.21512559170752391*x0[150] + 0.11852093815002847*x0[151] + 3.5506435206052254e-311*x0[152] + 2.2493912931331756e-314*x0[153] - 0.12723587076360929*x0[154] + 0.10537441385801902*x0[155] - 1.6310471162947606*x0[156] + 3.4960501893505437e-315*x0[157] + 2.6498321575017871e-295*x0[158] - 0.16654701878311046*x0[159] + 0.05209510294022509*x0[160] - 1.2105811000722141e-295*x0[161] - 8.0484720466206567e-298*x0[162] + 0.24596219149432563*x0[163] - 0.022245793912551357*x0[164] - 0.11160737748953074*x0[165] - 0.035003032335390975*x0[166] + 3.3929211443334048e-311*x0[167] - 0.015235671965961798*x0[168] - 1.6485599047271477e-310*x0[169] - 0.028187419983455784*x0[170] + 3.1126345068715092e-306*x0[171] - 1.6897684458122915e-315*x0[172] - 0.076835783133370403*x0[173] - 0.057949656677018513*x0[174] - 0.079291824679221606*x0[175] - 1.2543519645891605e-299*x0[176] - 1.5426459976035344e-299*x0[177] + 0.024256621434399942*x0[178] + 0.03704141292799773*x0[179] + 8.2221150558574622e-297*x0[180] + 0.11012856247939676*x0[181] + 0.056741691440239508*x0[182] - 0.14700962678920115*x0[183] + 0.0079436122529228468*x0[184] - 2.09905805119182e-299*x0[185] - 6.3044666704504048e-316*x0[186] + 0.74734837408757882*x0[187] - 4.0900031816498534e-316*x0[188] - 0.13058327400665767*x0[189] + 0.39719627136275487*x0[190] - 0.0035161590048638177*x0[191] + 3.8229472923172832e-311*x0[192] + 1.3537276266583116e-315*x0[193] + 0.24667437999904679*x0[194] - 0.24395192066407112*x0[195] - 2.9413417601438184e-315*x0[196] + 0.082182957938739351*x0[197] - 0.21655416700037342*x0[198] - 0.088405433052956825*x0[199] - 4.3305760647445362e-312*x0[200] + 0.0028546265146047853*x0[201] + 3.6114357344291392e-312*x0[202] - 0.23937862194584048*x0[203] + 0.093963457271977996*x0[204] + 0.020135552370165295*x0[205] - 4.8205950260232526e-310*x0[206] + 4.4439965210674443e-311*x0[207] - 0.014897294509042517*x0[208] + 0.20624494143342201*x0[209] + 5.1216079656969837e-292*x0[210] - 1.40745364896784e-306*x0[211] - 0.10043860125361821*x0[212] - 0.014229872158952181*x0[213] - 0.0045250991291347657*x0[214] - 1.8726307876428225e-299*x0[215] + 2.4371810735280124e-315*x0[216] - 0.088435901945379758*x0[217] + 0.019607968060725973*x0[218] + 1.7931544446692049e-306*x0[219] + 0.14658031699384014); +x1[2] = relu(0.56676726022035162*x0[0] + 1.5195987676909284e-291*x0[1] - 0.50703017830251551*x0[2] + 0.39129155332608501*x0[3] + 0.028266196624322511*x0[4] - 0.16596761592554793*x0[5] + 5.722778128614084e-292*x0[6] + 0.16081201790576*x0[7] - 0.00044953974716607537*x0[8] + 0.42218934421275134*x0[9] + 0.18160349035808665*x0[10] - 0.14894003718089927*x0[11] - 7.1774247723062513e-292*x0[12] - 0.11357503481784909*x0[13] + 0.04054993539318677*x0[14] - 3.9492262501033565e-311*x0[15] - 0.067398755318403406*x0[16] + 4.6835721411692416e-314*x0[17] - 3.420624349220094e-315*x0[18] - 7.1704463541513338e-291*x0[19] - 5.4054662333172884e-314*x0[20] - 0.15027911197878974*x0[21] + 0.3815104485542356*x0[22] + 0.13885657889464656*x0[23] - 3.1361422960406976e-312*x0[24] - 2.5626142840377193e-301*x0[25] + 0.27379531438297905*x0[26] + 0.065159476153904008*x0[27] + 8.2622900123440444e-292*x0[28] + 2.2243823793901135e-303*x0[29] + 2.4093853825921663e-296*x0[30] - 0.016093797578588542*x0[31] + 0.02217376683509489*x0[32] + 0.43517869712994045*x0[33] - 0.051507892642627819*x0[34] - 6.5611844942441344e-315*x0[35] - 0.070171526868440012*x0[36] + 3.4564001663450432e-315*x0[37] - 0.05312994113207746*x0[38] + 2.5047129798870712e-301*x0[39] + 2.5664068912776179e-312*x0[40] + 0.043153578626596599*x0[41] + 0.09425002261822657*x0[42] - 5.9111748063566922e-314*x0[43] + 5.6615906609404247e-295*x0[44] + 7.1014632323171074e-316*x0[45] - 6.4405941975992443e-298*x0[46] + 1.104337530137812e-302*x0[47] - 0.24039656530010015*x0[48] - 1.7343554216613101e-312*x0[49] + 0.45909181355491835*x0[50] + 0.081195666655328833*x0[51] - 1.2655843993622565e-311*x0[52] + 0.092945392887204381*x0[53] - 0.066599001477281858*x0[54] + 0.024762336770923668*x0[55] - 1.2442429141225486e-305*x0[56] - 0.23933878089901853*x0[57] + 3.6268176216844801e-311*x0[58] + 1.6116358275158488e-315*x0[59] - 3.3318264741652572e-315*x0[60] - 2.4415707578594957e-315*x0[61] - 0.04249708232857035*x0[62] - 9.1412459540075776e-297*x0[63] + 4.2156764051231945e-293*x0[64] + 6.1086785803086228e-292*x0[65] + 8.9433060851216973e-303*x0[66] - 2.0084367360415996e-315*x0[67] + 0.065674987172501212*x0[68] + 0.23666004829443896*x0[69] - 1.2229840876411486e-300*x0[70] - 1.7840540463338679e-315*x0[71] + 2.919261082053667e-315*x0[72] + 0.84682825602349221*x0[73] + 0.70575419391184357*x0[74] + 3.5912846240884066e-302*x0[75] + 0.064510876768065814*x0[76] - 1.7407356247859508e-303*x0[77] + 1.3305847420141967e-315*x0[78] - 3.8414996309637649e-298*x0[79] - 1.2580525924301655e-304*x0[80] - 0.17028998088444211*x0[81] + 1.9732770626994503e-313*x0[82] - 3.6838407389730286e-307*x0[83] - 4.313476345910156e-315*x0[84] - 0.11109191966911952*x0[85] + 0.018824357692983181*x0[86] + 0.17495345171971152*x0[87] - 0.10987115892866536*x0[88] + 8.0378408123741892e-313*x0[89] - 0.0066554808451750368*x0[90] + 0.25044024828315187*x0[91] - 3.0634396103217906e-316*x0[92] + 0.012404920555427615*x0[93] - 0.13728379427662377*x0[94] - 0.20508077770952399*x0[95] - 1.8087504213143985e-299*x0[96] - 1.5540267443906421e-310*x0[97] + 1.4853368729227545e-315*x0[98] + 3.8964307993603727e-291*x0[99] + 0.35524322088623633*x0[100] - 6.7253525528393477e-291*x0[101] - 0.023788451587746683*x0[102] + 1.0749830821381533e-312*x0[103] + 2.4989925988226674e-315*x0[104] + 2.5465751001268105e-302*x0[105] + 1.1014274711318193e-294*x0[106] + 2.1295890631491867e-315*x0[107] - 0.20540001446014403*x0[108] - 7.1303168500008709e-292*x0[109] - 0.012470781837617829*x0[110] + 0.13172983248533174*x0[111] + 7.2178884525927568e-291*x0[112] + 7.706338521991377e-303*x0[113] - 5.5200656699390851e-316*x0[114] - 0.01533995631419712*x0[115] - 0.095976343998114999*x0[116] + 0.62967681782731222*x0[117] - 2.2811789528587539e-300*x0[118] - 2.733187536010592e-315*x0[119] - 0.19863090138456513*x0[120] + 0.11284848454706177*x0[121] - 0.056486003613272627*x0[122] - 0.11381696554325728*x0[123] - 0.070720974846582865*x0[124] - 1.3314475659524725e-299*x0[125] + 3.7047472738160238e-305*x0[126] + 0.19200930137510253*x0[127] + 3.9565261919575645e-300*x0[128] - 1.0013754400882037e-295*x0[129] - 0.038915321551300945*x0[130] + 0.043740078791025629*x0[131] + 0.17938394097421834*x0[132] + 3.0017667461395827e-306*x0[133] + 0.34575009070195195*x0[134] - 0.082330216955655816*x0[135] + 0.28958416035891382*x0[136] + 0.16203695121056078*x0[137] + 1.7406949885338774e-315*x0[138] - 3.5500963959576956e-316*x0[139] + 0.055782156841501132*x0[140] + 0.098096670288083998*x0[141] + 0.01068058722046897*x0[142] - 3.8009850077794398e-305*x0[143] - 4.9190972122642785e-316*x0[144] - 0.28507138287106581*x0[145] + 9.2467851489694867e-316*x0[146] + 0.24310023414980333*x0[147] - 5.4371092908709795e-311*x0[148] + 3.5210934640593288e-293*x0[149] - 0.10966184932587805*x0[150] + 0.05243879780005628*x0[151] - 9.8380160461784643e-313*x0[152] + 5.4054867083857833e-316*x0[153] + 0.11488270828040921*x0[154] + 0.19984465094535356*x0[155] - 2.6439446885174891*x0[156] + 9.0790790289609173e-295*x0[157] + 1.1375182945736703e-315*x0[158] - 0.073452459754715677*x0[159] - 0.036588849962578156*x0[160] + 1.412895125064652e-315*x0[161] - 4.5286494360727197e-314*x0[162] + 0.019728562304634694*x0[163] - 0.17389700488482077*x0[164] + 0.49159192054574141*x0[165] + 0.093955986407026196*x0[166] + 3.007046519709186e-295*x0[167] - 0.062346818150180193*x0[168] + 1.0381999437572967e-315*x0[169] + 0.049302153067670614*x0[170] + 7.5926114109949815e-292*x0[171] - 1.4819576817387436e-313*x0[172] + 0.014981020965614876*x0[173] + 0.14233111124588563*x0[174] - 0.20110142557468616*x0[175] - 4.3368632873272777e-304*x0[176] - 3.6542178701786489e-315*x0[177] + 0.0062893752867007099*x0[178] - 0.15181536058146655*x0[179] - 1.2624501839158661e-311*x0[180] - 0.025434463249188372*x0[181] - 0.18379616651021669*x0[182] + 0.34479249804990736*x0[183] + 0.31536076543694502*x0[184] + 2.6699238233257416e-315*x0[185] + 3.1127446948033079e-306*x0[186] - 0.098272010788282099*x0[187] - 1.0943762748712414e-315*x0[188] - 0.13712724137188886*x0[189] + 0.037283853398585809*x0[190] + 0.068492992952496098*x0[191] - 2.7127767126337722e-303*x0[192] - 1.8528148997133443e-303*x0[193] - 0.34353294745180513*x0[194] + 0.26182853191800826*x0[195] + 1.0052871530588377e-315*x0[196] - 0.049351723597124461*x0[197] + 0.37945083063656004*x0[198] + 0.36072482502823849*x0[199] - 1.5824232394200448e-305*x0[200] + 0.015221474740180787*x0[201] - 3.6359854348193598e-315*x0[202] - 0.11529369028257372*x0[203] + 0.12193877251519732*x0[204] + 0.088710738298767258*x0[205] - 6.3106647805016904e-294*x0[206] + 1.2887923416738865e-315*x0[207] + 0.0032110400170396718*x0[208] - 0.047199073582661469*x0[209] + 1.6072346639149304e-313*x0[210] + 5.3444334590759866e-302*x0[211] + 0.16830269235550019*x0[212] - 0.095592099807365744*x0[213] - 0.047813530238305736*x0[214] - 8.9424891718664719e-311*x0[215] + 7.443383621631767e-311*x0[216] + 0.14023837300027631*x0[217] - 0.20661000999659626*x0[218] + 4.3888939459809299e-292*x0[219] - 0.073001075177664979); +x1[3] = relu(-0.3301773625163486*x0[0] + 6.1034431169823794e-292*x0[1] + 0.30941380248218514*x0[2] - 0.22621523483708914*x0[3] + 0.67917197564864307*x0[4] - 0.047611996543197699*x0[5] + 8.0093024232296984e-306*x0[6] - 0.47273288335334873*x0[7] - 0.21566515671585781*x0[8] + 0.014257971839646819*x0[9] - 0.20506173713074841*x0[10] + 0.15013217108481167*x0[11] - 2.7895737874361374e-298*x0[12] + 0.13828015908826405*x0[13] + 0.18324737692054305*x0[14] - 5.3958985724861787e-299*x0[15] - 0.13369831240955127*x0[16] + 7.8708251919619201e-292*x0[17] - 1.251020642618776e-315*x0[18] + 1.2745473108489786e-306*x0[19] - 1.8388052055671319e-315*x0[20] + 0.3459705766982118*x0[21] - 0.06603956998284298*x0[22] + 0.11303340413254331*x0[23] + 7.307525125099867e-313*x0[24] + 8.2765744886787041e-298*x0[25] + 0.088661234807330458*x0[26] + 0.081528707676250381*x0[27] + 1.6404976455269876e-315*x0[28] - 9.1613946271413103e-310*x0[29] + 9.9309094200059427e-315*x0[30] - 0.087635238570021659*x0[31] - 0.061248833036351459*x0[32] - 0.11206964269282155*x0[33] - 0.030524334531878181*x0[34] + 8.0681776449296848e-297*x0[35] - 0.16700416408740812*x0[36] - 2.1139639466395169e-296*x0[37] - 0.038666465048678933*x0[38] + 3.9670612568259305e-311*x0[39] + 1.6486584393580824e-310*x0[40] - 0.12929808197496587*x0[41] - 0.16345622862538781*x0[42] + 4.1004346181313918e-293*x0[43] + 2.3869080102407646e-313*x0[44] + 3.7514026923759298e-315*x0[45] + 3.7787267779556256e-291*x0[46] - 2.7174657805829064e-310*x0[47] + 0.43319682049168501*x0[48] - 8.0001864256060127e-295*x0[49] - 0.18226624717815809*x0[50] + 0.070184410905144781*x0[51] + 5.5916617800485828e-307*x0[52] - 0.086021480595807193*x0[53] + 0.32228238238475437*x0[54] - 0.094757384830887387*x0[55] - 3.8960011912649879e-315*x0[56] + 0.19879447460150385*x0[57] - 1.342527211095991e-299*x0[58] + 1.3189803437405145e-290*x0[59] + 5.9055482904390511e-315*x0[60] - 1.6370663102100555e-316*x0[61] + 0.44604865773079877*x0[62] - 3.1332327255753811e-302*x0[63] - 8.0853139430986465e-292*x0[64] - 1.2913331945611559e-301*x0[65] + 6.4616626974698827e-290*x0[66] + 1.6725211395467563e-299*x0[67] - 0.22973740566975842*x0[68] + 0.2424113772866367*x0[69] + 7.0864009650824734e-291*x0[70] - 8.3794589441378167e-305*x0[71] + 9.4754477505416538e-308*x0[72] - 0.96098550537479732*x0[73] - 0.61003854813697356*x0[74] + 7.8110234742263784e-297*x0[75] + 0.37724384209531808*x0[76] + 2.8209142332668326e-307*x0[77] + 1.9614958829366871e-307*x0[78] + 2.2112529662427151e-315*x0[79] + 1.2659787118824774e-311*x0[80] + 0.068129902806637763*x0[81] - 6.853708233641958e-316*x0[82] - 2.1085865844757618e-301*x0[83] - 4.4143662133029095e-291*x0[84] + 0.48465302178233965*x0[85] - 0.092514218651382013*x0[86] - 0.27179233523753832*x0[87] + 0.053793192907162557*x0[88] - 5.8332677060510688e-295*x0[89] - 0.088370211465489415*x0[90] - 0.057042841253399756*x0[91] - 3.7517642545562129e-315*x0[92] + 0.01547522979260498*x0[93] - 0.08570584943740249*x0[94] + 0.21175251806027184*x0[95] - 1.0357623603277429e-300*x0[96] + 1.7024293268456127e-313*x0[97] + 1.6601689779105989e-315*x0[98] - 1.5524907715601424e-299*x0[99] - 0.28037663017974351*x0[100] + 2.3502864851945779e-301*x0[101] + 0.021529601868563897*x0[102] + 1.073975549328277e-312*x0[103] - 1.6444947650589112e-315*x0[104] - 8.4341096143202698e-293*x0[105] + 4.6308865326241674e-307*x0[106] + 1.1346926560314449e-294*x0[107] - 0.39241279892106856*x0[108] + 4.7752583873982623e-301*x0[109] - 0.0067511250766370276*x0[110] + 0.063704433828372292*x0[111] - 1.8982932245560725e-296*x0[112] - 8.9303249889990914e-313*x0[113] - 3.0946039669281514e-315*x0[114] - 0.024390512721123966*x0[115] + 0.090473733849815899*x0[116] - 0.65620212688993018*x0[117] + 2.9027264688246884e-298*x0[118] - 1.2104011541216929e-315*x0[119] + 0.27776497769152642*x0[120] + 0.089657438817019472*x0[121] + 0.096081950374108591*x0[122] + 0.0055041255486634232*x0[123] + 0.0062965311757509895*x0[124] + 1.3141673464265164e-308*x0[125] - 6.8034518044035908e-291*x0[126] + 0.073076208759424055*x0[127] - 6.3477475517306291e-301*x0[128] + 6.0146064818119765e-311*x0[129] + 0.10059668783865254*x0[130] - 0.094983121329170708*x0[131] + 0.11248265589408005*x0[132] - 2.6873220934572261e-299*x0[133] - 0.062825728688899324*x0[134] + 0.10391634667900121*x0[135] - 0.26819469252947192*x0[136] - 0.063385155651598107*x0[137] - 1.451511097425571e-306*x0[138] - 1.6994467520958967e-315*x0[139] + 0.061050485039482863*x0[140] - 0.14008354754921798*x0[141] + 0.21252111580940206*x0[142] + 1.1099287407927574e-312*x0[143] + 5.4182313771491149e-307*x0[144] + 0.36111704149021484*x0[145] - 3.1643293275956642e-291*x0[146] - 0.19291032911576567*x0[147] + 1.0187043302554989e-294*x0[148] - 1.6404472970444403e-299*x0[149] - 0.17647056147813533*x0[150] - 0.061562796283219562*x0[151] - 1.8691012931018131e-309*x0[152] - 4.0387035437901648e-310*x0[153] - 0.018206945089238754*x0[154] + 0.06131843200625408*x0[155] + 0.090328501692888169*x0[156] + 3.8755326246739342e-315*x0[157] + 1.3210934395775424e-315*x0[158] + 0.082967002822415314*x0[159] - 0.15541223924220454*x0[160] + 9.5621946802275906e-300*x0[161] - 2.081229533544995e-310*x0[162] + 0.056524137958292059*x0[163] + 0.25284990485592429*x0[164] - 0.2687822863658238*x0[165] + 0.023602545399483078*x0[166] - 5.4392778000261548e-292*x0[167] + 0.17148451149802912*x0[168] - 1.1509832704576647e-299*x0[169] + 0.091289374272108634*x0[170] + 3.0041893386078983e-305*x0[171] - 8.1255297464645239e-316*x0[172] - 0.027578756712721243*x0[173] + 0.10774839820082316*x0[174] + 0.04434990394547144*x0[175] + 2.9489673698819085e-299*x0[176] - 1.1441588377462915e-294*x0[177] - 0.034261819294818981*x0[178] - 0.068337743109327942*x0[179] + 3.0230537951125646e-315*x0[180] + 0.027079362254110697*x0[181] + 0.42883017095062087*x0[182] - 0.28342206236575718*x0[183] - 0.32071089379687528*x0[184] - 2.3158778184499351e-290*x0[185] - 6.237366557788223e-315*x0[186] + 0.1674113680451052*x0[187] - 1.0667626297231608e-315*x0[188] - 0.18463267889761345*x0[189] - 0.12824610335749623*x0[190] + 0.041569211150060993*x0[191] + 2.7252893087237011e-315*x0[192] + 8.4702062451696903e-316*x0[193] + 0.10403259913659586*x0[194] - 0.025958696092445912*x0[195] - 7.2767868955227435e-302*x0[196] + 0.16533395984307539*x0[197] + 0.011907666283349248*x0[198] - 0.068058396127240239*x0[199] - 2.5721841887280795e-313*x0[200] - 0.25378088561148721*x0[201] + 1.1452448437854093e-308*x0[202] - 0.090755115274649148*x0[203] - 0.054334826488165337*x0[204] + 0.19970656944210233*x0[205] - 9.9422217387696257e-311*x0[206] + 2.2120136840582733e-315*x0[207] - 0.054328090567976009*x0[208] + 0.063402711363887379*x0[209] - 3.075256170348635e-302*x0[210] - 1.2160847815576649e-315*x0[211] + 0.078422077505329341*x0[212] + 0.034663220469209492*x0[213] - 0.16194604497042148*x0[214] - 7.2904452949781917e-298*x0[215] + 5.4881447308466218e-315*x0[216] - 0.075496699767859277*x0[217] - 0.10757173607958728*x0[218] - 1.5822535420222168e-303*x0[219] - 0.028295303789500972); +x1[4] = relu(-0.91737010512049932*x0[0] + 9.3868954459496187e-302*x0[1] - 0.19883873349444059*x0[2] - 0.00025275325937560681*x0[3] + 0.21926458786889694*x0[4] - 0.22122948239527487*x0[5] + 1.5524519874775617e-294*x0[6] - 0.10652048914758162*x0[7] - 0.33027340410427841*x0[8] - 0.44449346134082057*x0[9] + 0.059493183931284714*x0[10] + 0.081770698645681636*x0[11] - 4.4962580825549927e-292*x0[12] - 0.10592779765759568*x0[13] + 0.43227326522074561*x0[14] - 1.6496550574916085e-305*x0[15] - 0.32807240101022417*x0[16] - 5.3623007459156579e-293*x0[17] - 8.4968604942405368e-294*x0[18] - 1.2651671790857026e-311*x0[19] + 1.1554245533884035e-296*x0[20] - 0.13302274799768607*x0[21] - 0.12292154455455952*x0[22] + 0.055090114283501815*x0[23] + 6.243756106413042e-310*x0[24] - 2.0771014261470927e-315*x0[25] - 0.028933237108577575*x0[26] - 0.18816349037873856*x0[27] + 2.7051484950223807e-298*x0[28] - 7.5206761924429584e-311*x0[29] + 6.505572887962374e-291*x0[30] - 0.21156608311407527*x0[31] + 0.37343201373249896*x0[32] - 0.62262868961250739*x0[33] - 0.0066856258392070681*x0[34] - 1.9892481799038221e-315*x0[35] + 0.16824462680839422*x0[36] - 8.9223468543753382e-294*x0[37] - 0.073566399157809839*x0[38] + 4.2565722808031694e-315*x0[39] - 4.3296790962710752e-293*x0[40] - 1.5156124575285874*x0[41] + 0.11724761204185415*x0[42] - 7.8192448065143971e-315*x0[43] - 8.153121472254113e-292*x0[44] + 4.1302449394690582e-294*x0[45] + 7.183588821856412e-297*x0[46] - 1.2251636709710984e-299*x0[47] - 0.012615869413672268*x0[48] + 4.7743207315303337e-300*x0[49] - 0.86966774008846337*x0[50] - 0.28329303483390111*x0[51] + 3.6688541924442407e-304*x0[52] + 0.042260387584008657*x0[53] - 0.085259170636202725*x0[54] - 0.030136994750701591*x0[55] + 1.0252982593277505e-315*x0[56] + 0.45410527666105865*x0[57] + 3.4527861375154092e-306*x0[58] + 9.9136232680039596e-296*x0[59] + 9.1549100354460923e-316*x0[60] + 9.4716140613235784e-310*x0[61] - 0.14073783826464914*x0[62] + 4.2921972579667691e-294*x0[63] - 4.3860743025035042e-315*x0[64] + 2.5755985434150502e-301*x0[65] + 4.481880152729131e-290*x0[66] - 3.2556837766691076e-293*x0[67] + 0.28074952126026981*x0[68] + 0.14307422947732168*x0[69] + 4.0784601652465098e-313*x0[70] + 1.6779358453304989e-315*x0[71] - 3.1638553649287375e-315*x0[72] - 0.2493261071661671*x0[73] - 0.51142824169953216*x0[74] - 2.0691133452176765e-299*x0[75] + 0.46833074500612681*x0[76] - 1.126913951965611e-302*x0[77] + 1.9953841879559114e-293*x0[78] - 6.8180423263605825e-316*x0[79] - 2.0572843337489162e-299*x0[80] - 0.071769087211718097*x0[81] - 2.7855734224162204e-313*x0[82] - 9.8305603436053175e-303*x0[83] + 3.195965786843356e-299*x0[84] - 0.63171873275632906*x0[85] + 0.13959106014641431*x0[86] + 0.16401701642910632*x0[87] - 0.28198733803980924*x0[88] + 1.7353450101981971e-302*x0[89] - 0.12752704437895479*x0[90] - 0.52528094315125962*x0[91] + 1.8183955513636883e-315*x0[92] - 0.2085169688029006*x0[93] - 0.10383292554698635*x0[94] + 0.041206934699393218*x0[95] + 1.4626088618336835e-299*x0[96] - 6.6943500705387659e-311*x0[97] + 1.4114235900637655e-315*x0[98] - 1.0128422840770335e-294*x0[99] - 0.078075152283202401*x0[100] + 1.0171444756108222e-300*x0[101] + 0.05843009012474551*x0[102] - 3.2570463788922733e-308*x0[103] + 2.3830780970476784e-296*x0[104] + 7.1513084138371544e-301*x0[105] - 2.5177752973968704e-304*x0[106] + 4.9960848698208248e-306*x0[107] + 0.80540489103119706*x0[108] + 2.4317941569385289e-310*x0[109] - 0.16168042689170223*x0[110] - 0.021348919829896035*x0[111] - 3.9972643621016074e-304*x0[112] + 8.6056954619345883e-308*x0[113] + 7.2284369200214613e-311*x0[114] + 0.2346531048974097*x0[115] + 0.11747269552618986*x0[116] - 0.17834228583194803*x0[117] - 9.3943962937661396e-300*x0[118] + 6.0848339377431037e-316*x0[119] + 0.1238522951975741*x0[120] - 0.052164062817718404*x0[121] - 0.14174849983679452*x0[122] - 0.24173976533874308*x0[123] - 0.11304070215755344*x0[124] - 1.5109000515597176e-303*x0[125] + 8.1453779598204084e-294*x0[126] + 0.032123979605647154*x0[127] - 3.7421076479198608e-311*x0[128] - 2.50858736710349e-312*x0[129] + 0.010695902554491925*x0[130] + 0.2787079358927802*x0[131] + 0.21524405583670403*x0[132] - 2.3865095430365604e-313*x0[133] - 0.10750155505080006*x0[134] + 0.022623390301426835*x0[135] + 0.84671305236510963*x0[136] - 0.10047334630704308*x0[137] + 4.2647258458096534e-311*x0[138] + 1.1662238870814786e-296*x0[139] - 0.038080631671953323*x0[140] + 0.11250895845762231*x0[141] + 0.40112575185309934*x0[142] - 9.8142075014304711e-301*x0[143] + 1.1278688403590614e-302*x0[144] - 0.31965550566858308*x0[145] - 3.448436785633304e-314*x0[146] - 0.15069407174590627*x0[147] - 2.3598814946726574e-310*x0[148] + 8.1530064142229783e-292*x0[149] + 0.13496818505705166*x0[150] - 0.25628157400770313*x0[151] - 1.4886097611158738e-294*x0[152] - 6.0258118571724665e-291*x0[153] + 0.13792514427908412*x0[154] - 0.027898208088228304*x0[155] + 0.10458820771298882*x0[156] - 1.2136070178114805e-308*x0[157] + 3.2903957150557334e-315*x0[158] + 0.13856859970297583*x0[159] - 0.16433437171098583*x0[160] + 2.0753837229381658e-315*x0[161] - 4.3060043135295148e-292*x0[162] - 0.25593853582542564*x0[163] + 0.30932335628125068*x0[164] - 0.42435139658139515*x0[165] - 0.23775026827725063*x0[166] + 9.3407533852734777e-308*x0[167] - 0.078774525905862799*x0[168] - 1.4809771461006482e-298*x0[169] + 0.0043458616493127142*x0[170] + 1.3187723758715172e-300*x0[171] - 2.6276438037531775e-301*x0[172] + 0.39752468435240029*x0[173] - 0.35757602411104206*x0[174] - 0.049039942474399988*x0[175] - 1.0549048520880622e-308*x0[176] - 2.9234721032773582e-311*x0[177] - 0.11842506618813795*x0[178] - 0.059979974566185368*x0[179] - 1.2178497176161376e-299*x0[180] + 0.38757855898391524*x0[181] - 0.72258253658701088*x0[182] - 0.18633876726962101*x0[183] + 0.018205258333340257*x0[184] + 4.0057420438743483e-312*x0[185] - 1.6571021961820542e-305*x0[186] - 0.075235899814306367*x0[187] - 7.0363557061672292e-316*x0[188] - 0.16072221516374943*x0[189] - 0.16034501587747474*x0[190] + 0.02596907580832232*x0[191] - 5.0403776954195189e-310*x0[192] + 6.7064520261638312e-293*x0[193] - 0.0081340093097222541*x0[194] - 0.021292992072801935*x0[195] - 2.2057238808822584e-308*x0[196] + 0.060211475725052685*x0[197] - 0.41630118182377251*x0[198] - 0.28583114711413293*x0[199] + 7.6851272334894707e-295*x0[200] - 0.20350456920361798*x0[201] + 1.5708501798014129e-315*x0[202] + 0.054749432408175591*x0[203] + 0.20661820202386338*x0[204] + 0.25007079940089028*x0[205] + 2.2274552013516172e-308*x0[206] + 1.8839916985559906e-315*x0[207] - 0.5174781664409881*x0[208] - 0.084015072258515316*x0[209] + 1.0167061792019848e-299*x0[210] - 5.3295261904134042e-316*x0[211] + 0.041792690055187515*x0[212] + 0.090463945956839598*x0[213] - 0.72086877149012896*x0[214] - 1.1052975304739337e-310*x0[215] + 1.9576489467159918e-315*x0[216] + 0.029897031559524428*x0[217] - 0.01865441985938136*x0[218] - 9.3058021447453372e-293*x0[219] + 0.061633860578985039); +x1[5] = relu(0.34332491628346334*x0[0] - 6.1649444061272463e-305*x0[1] - 0.086537173603283335*x0[2] - 0.1224501081126828*x0[3] - 0.019650995211879393*x0[4] - 0.019445574660193331*x0[5] + 7.1290454942981929e-298*x0[6] - 0.20066060998522103*x0[7] + 0.23810838536793602*x0[8] + 0.043048287431689716*x0[9] - 0.30781447595295924*x0[10] - 0.0045077382520432871*x0[11] - 4.5180371718073672e-314*x0[12] - 0.23641998628762445*x0[13] - 0.13127479589456167*x0[14] + 3.3978726015258223e-315*x0[15] - 0.11333579322367715*x0[16] - 2.7741882741241601e-307*x0[17] + 6.0482522113025485e-310*x0[18] - 3.0928237702078446e-306*x0[19] + 2.2730117997276523e-301*x0[20] + 0.15468487575841613*x0[21] - 0.15404731584527925*x0[22] - 0.28858116363778907*x0[23] + 9.5295786198942705e-298*x0[24] - 8.7957467184588079e-292*x0[25] - 0.32011362816559741*x0[26] - 0.071287033350181675*x0[27] - 2.5968935993115997e-314*x0[28] - 4.9253422858663275e-292*x0[29] - 3.7960927971296665e-295*x0[30] - 0.099592729163544794*x0[31] + 0.12990278564849195*x0[32] + 0.22787728354529987*x0[33] + 0.0046214050468984576*x0[34] - 1.8671074502231197e-293*x0[35] + 0.13139390117055749*x0[36] + 4.5791104834825664e-316*x0[37] - 0.14614536467247438*x0[38] + 5.5398145088372436e-302*x0[39] - 3.9679191251499464e-308*x0[40] + 1.4169433660052146*x0[41] + 0.043168145296298324*x0[42] + 8.1431309190887781e-315*x0[43] + 7.9419800112568174e-316*x0[44] - 2.6568752284764045e-315*x0[45] + 3.6266510821166186e-311*x0[46] + 9.0262902697704909e-311*x0[47] + 0.82499820200876595*x0[48] + 2.6638047116075557e-315*x0[49] + 0.5958987662652816*x0[50] + 0.53611508675401465*x0[51] + 2.119912571204184e-304*x0[52] - 0.08709944801783133*x0[53] - 0.039367946620469871*x0[54] + 0.15192668766365827*x0[55] - 8.6990136246279718e-297*x0[56] - 0.090604733333519136*x0[57] - 2.4194943541672408e-293*x0[58] - 3.9657717534462239e-315*x0[59] - 5.1726108324995709e-298*x0[60] - 6.9514249169446545e-303*x0[61] - 0.051632925593666307*x0[62] + 3.2435255638614366e-310*x0[63] + 4.2060391988251786e-303*x0[64] - 3.2144007755298085e-316*x0[65] - 3.2739999736755156e-315*x0[66] - 2.1870647622084117e-315*x0[67] - 0.062280734076554184*x0[68] + 0.011907829409582318*x0[69] + 2.3650717280957754e-315*x0[70] + 1.2007271956157711e-315*x0[71] - 2.0507515872543403e-291*x0[72] - 0.28419460872239904*x0[73] + 0.69294425053490361*x0[74] + 4.9628756280438026e-316*x0[75] - 0.18873074377722854*x0[76] - 2.9746130456111093e-304*x0[77] - 2.0590665193652675e-307*x0[78] + 1.0309444768759671e-306*x0[79] + 9.9929817556494847e-299*x0[80] - 0.012239087967330716*x0[81] - 7.3212312040163852e-291*x0[82] - 7.8665962421219266e-311*x0[83] + 4.3209184468521498e-316*x0[84] - 0.080312313531080023*x0[85] - 0.026825419670853768*x0[86] - 0.98546664695208153*x0[87] - 0.0047777334383954781*x0[88] + 8.387884199989169e-293*x0[89] + 0.05113388167264106*x0[90] + 0.28124663136998035*x0[91] - 2.1349622318073378e-310*x0[92] + 0.046227429356342831*x0[93] - 0.058317941437523578*x0[94] + 0.18684856979304751*x0[95] + 9.7540975840938996e-316*x0[96] + 7.39452988069052e-316*x0[97] + 1.0225237385769367e-293*x0[98] + 1.6518591346528447e-315*x0[99] + 0.010155907216657762*x0[100] + 1.1978835619632999e-295*x0[101] - 0.19015073086089018*x0[102] - 3.6466671340824475e-315*x0[103] + 1.4892210534946296e-314*x0[104] - 8.1753790432738869e-316*x0[105] + 9.0803657917915694e-298*x0[106] - 3.3065271659000213e-315*x0[107] + 0.95738709571303204*x0[108] + 1.5037764435204856e-312*x0[109] - 0.22200719706403943*x0[110] - 0.021238795376861623*x0[111] - 8.1615388503556403e-292*x0[112] + 5.5339798925032184e-316*x0[113] + 8.6460557597802263e-294*x0[114] - 0.037006380116838024*x0[115] + 0.005731250376909359*x0[116] - 0.0030237371255670883*x0[117] + 1.2635537194919294e-316*x0[118] + 2.0494348235384706e-293*x0[119] - 0.12704873494194008*x0[120] - 0.078524062334555042*x0[121] + 0.27676957405148078*x0[122] + 0.06120816110865171*x0[123] - 0.030653955783984665*x0[124] + 1.385651239120222e-312*x0[125] + 8.9674366401638071e-293*x0[126] + 0.13146847688632488*x0[127] - 3.0370191217905949e-302*x0[128] - 5.499792972751421e-310*x0[129] - 0.12668970956843162*x0[130] - 0.21650653618523377*x0[131] - 1.6753311670096205*x0[132] + 3.1461384170567422e-310*x0[133] - 0.093844848880841422*x0[134] + 0.0080575457027025951*x0[135] - 0.50441937938963066*x0[136] + 0.2433606841118017*x0[137] + 9.7029419884791802e-301*x0[138] + 1.2997957750520076e-299*x0[139] - 0.014961321682527758*x0[140] - 0.17782059251523696*x0[141] + 0.5343086718799781*x0[142] - 9.5939298002963138e-300*x0[143] + 1.8587574213524213e-299*x0[144] + 0.79049160085658488*x0[145] + 8.0851132926527238e-308*x0[146] - 0.19359329878036427*x0[147] - 4.283934483927812e-310*x0[148] + 4.8698506922179331e-292*x0[149] + 0.11197958315705754*x0[150] + 0.081664281112760695*x0[151] + 1.245551968991828e-300*x0[152] + 2.0831835619923439e-315*x0[153] + 0.061035899286967399*x0[154] + 0.033242379691083186*x0[155] - 0.43178777407789565*x0[156] - 7.4415174085741841e-305*x0[157] + 4.4535832769133581e-310*x0[158] - 0.46219705210494316*x0[159] + 0.017803221221160747*x0[160] - 9.1936458928824028e-311*x0[161] - 7.7819950108956995e-295*x0[162] + 0.038990110017185671*x0[163] + 0.21740763359292939*x0[164] + 0.24148476764337551*x0[165] + 0.14447448001486843*x0[166] + 1.4474095086046087e-315*x0[167] - 0.17202096645598813*x0[168] + 1.583617745170739e-315*x0[169] - 0.25925137321100084*x0[170] + 2.4765373646257474e-315*x0[171] - 5.1958032720281749e-316*x0[172] + 0.018952614558090955*x0[173] - 0.012641116457482287*x0[174] - 0.046328229684442584*x0[175] - 6.3886384244291651e-294*x0[176] - 1.5411957174526817e-315*x0[177] - 0.46484239312981102*x0[178] + 0.041081016841581872*x0[179] + 3.4513773406243426e-302*x0[180] - 0.030656705280588996*x0[181] - 0.16541019746815705*x0[182] + 0.35945949655308096*x0[183] - 0.083679479724937403*x0[184] + 5.4266271454613692e-314*x0[185] + 1.6685413207804645e-295*x0[186] - 0.10331328887378895*x0[187] - 1.3034899456756183e-306*x0[188] + 0.064263370876221734*x0[189] - 0.12107206013366183*x0[190] - 0.168278947535348*x0[191] - 4.3062638424319836e-298*x0[192] - 5.0092070944517474e-314*x0[193] - 0.11508062187179663*x0[194] - 0.55299435049641865*x0[195] + 2.8528180561862747e-300*x0[196] + 0.13969122832864506*x0[197] + 0.16558623629407906*x0[198] - 0.12637496999450654*x0[199] + 7.6707944433932927e-316*x0[200] + 0.07832352685239713*x0[201] - 1.9616637642729483e-294*x0[202] + 0.40081944746596099*x0[203] - 0.019248452288723562*x0[204] + 0.20633132026473261*x0[205] - 9.3966853620562159e-314*x0[206] - 1.854754459823203e-315*x0[207] - 0.13668805877397217*x0[208] + 0.12602750776027508*x0[209] + 3.9907632032310799e-300*x0[210] - 6.831954888668953e-301*x0[211] - 0.20300441284085669*x0[212] + 0.2061424038277255*x0[213] + 0.20202055926911341*x0[214] + 2.7164600451660742e-296*x0[215] + 1.9348077286739147e-315*x0[216] - 0.087208557394858166*x0[217] - 0.1444071363853584*x0[218] + 5.3701858168035554e-316*x0[219] - 0.011834126227198753); +x1[6] = relu(-0.72192868411527034*x0[0] - 4.7032422419769877e-303*x0[1] - 0.06037427720467848*x0[2] - 0.1182224582006268*x0[3] - 0.090829699230284*x0[4] + 0.0037438699230031461*x0[5] - 1.8261276935430732e-316*x0[6] + 0.1581952615340298*x0[7] - 0.027567560201468271*x0[8] - 0.44064226073061874*x0[9] + 0.31433338718955811*x0[10] + 0.22810784131389503*x0[11] - 3.3786007278867598e-313*x0[12] + 0.038320352405971612*x0[13] + 0.16877899957117642*x0[14] + 5.446027005586015e-303*x0[15] + 0.17567488528348194*x0[16] + 1.4095529241308861e-315*x0[17] - 1.1480862599242671e-296*x0[18] + 3.1236970251738447e-306*x0[19] - 2.6551610597696302e-311*x0[20] + 0.17307308678658881*x0[21] + 0.22139664314808694*x0[22] - 0.18185167429994387*x0[23] - 4.2066925154898767e-299*x0[24] - 8.3290934518426505e-298*x0[25] - 0.020463947767595955*x0[26] - 0.045964042219736816*x0[27] + 4.0013340075091928e-304*x0[28] + 2.312097047998117e-313*x0[29] + 3.1877874947388014e-315*x0[30] - 0.10628377748935867*x0[31] - 0.072522773195709767*x0[32] - 0.26263367380838148*x0[33] - 0.0019938524317998623*x0[34] + 1.5095548394715634e-315*x0[35] - 0.048581618313695188*x0[36] + 2.1248113890660244e-315*x0[37] - 0.0098828022389013774*x0[38] + 4.1534112942960095e-301*x0[39] - 4.3302706945127821e-315*x0[40] - 1.7516377580693749*x0[41] - 0.16783715625997478*x0[42] - 1.325117470865195e-315*x0[43] + 2.4179081384514187e-294*x0[44] - 8.263310534914144e-293*x0[45] + 4.5987433793316692e-295*x0[46] - 2.2777423001315386e-315*x0[47] + 0.2017196653152753*x0[48] + 5.3436669083869197e-307*x0[49] - 0.55849305849346564*x0[50] - 0.77114963282671389*x0[51] + 1.1794056200550605e-296*x0[52] + 0.0026456521929826902*x0[53] + 0.28367804507796657*x0[54] + 0.11573806686467231*x0[55] + 7.8606856898016963e-300*x0[56] + 0.55164554764344709*x0[57] + 6.6344965472148094e-291*x0[58] + 5.3851163948133758e-292*x0[59] + 3.9097726853090683e-293*x0[60] + 1.5445994740252629e-315*x0[61] - 0.047568029572745987*x0[62] + 3.0766817158626344e-315*x0[63] - 7.0867434336840284e-291*x0[64] - 6.6646125621531189e-316*x0[65] + 9.1441642603587164e-306*x0[66] - 1.5601163748200959e-305*x0[67] + 0.20715481968274518*x0[68] + 0.2499683638499092*x0[69] + 9.601474826712353e-316*x0[70] + 3.5309169872821212e-300*x0[71] + 1.752838731796795e-315*x0[72] - 0.16648963704487085*x0[73] - 0.5594393710661707*x0[74] - 4.4270030774726669e-304*x0[75] + 0.076624814038149747*x0[76] + 7.1171630031846545e-315*x0[77] - 2.1340719118179334e-310*x0[78] - 1.1669909538863922e-308*x0[79] - 1.9395081506526933e-316*x0[80] - 0.0096304736676950508*x0[81] - 2.0353117975150557e-315*x0[82] + 5.5623641834273094e-302*x0[83] + 5.5867506612396881e-292*x0[84] - 0.40971203009813983*x0[85] - 0.17719351502424235*x0[86] + 0.011893173178716975*x0[87] + 0.12417672269776185*x0[88] - 1.4003508016007901e-300*x0[89] - 0.10402186981943054*x0[90] - 0.40554516580402417*x0[91] + 2.1084873132944382e-307*x0[92] + 0.076150495610869312*x0[93] + 0.19590662645274909*x0[94] + 0.15504729247106*x0[95] - 3.5922272407474005e-306*x0[96] - 2.7555490131975223e-307*x0[97] + 1.0700456256868402e-300*x0[98] + 8.4403005189982052e-311*x0[99] + 0.20338141490352135*x0[100] - 1.6035940897251149e-299*x0[101] + 0.08075994019262922*x0[102] - 6.0617260053572186e-306*x0[103] + 7.8007567317086368e-316*x0[104] - 2.1109616011146681e-296*x0[105] - 3.9652523215139982e-304*x0[106] + 2.8010861921541776e-315*x0[107] + 0.71603351356491007*x0[108] - 8.2641358436689141e-292*x0[109] + 0.0054653177291721375*x0[110] + 0.025926652229075097*x0[111] - 2.6967136918675047e-303*x0[112] - 8.6837775829075526e-316*x0[113] - 2.6514029904355337e-306*x0[114] - 0.030952531792437007*x0[115] + 0.0068344813507494875*x0[116] + 0.013744338912799713*x0[117] + 2.2934320562884445e-315*x0[118] - 1.5583230895811462e-301*x0[119] + 0.18692867589034518*x0[120] - 0.17901379620200114*x0[121] - 0.28787116259157536*x0[122] + 0.11412968232470498*x0[123] + 0.23201128257735409*x0[124] - 1.0924369091617895e-310*x0[125] - 7.8090820408554749e-311*x0[126] + 0.2131579388448481*x0[127] + 3.3934462097951782e-293*x0[128] + 1.1104672235472532e-294*x0[129] + 0.04691141086683713*x0[130] + 0.30129073160455294*x0[131] + 0.11529514953676551*x0[132] - 1.5520336395976461e-310*x0[133] - 0.12166149395523777*x0[134] + 0.080267980450978341*x0[135] - 0.15560145662953462*x0[136] + 0.0086069383911220251*x0[137] + 1.1057898089961567e-302*x0[138] - 6.1326225980436589e-309*x0[139] - 0.030043237308129595*x0[140] - 0.026521473507425647*x0[141] + 0.14031252204577854*x0[142] - 4.4787887744129046e-310*x0[143] - 1.6016693138763874e-299*x0[144] + 0.12272824518088413*x0[145] - 5.7311124458617973e-314*x0[146] - 0.11010100021335466*x0[147] + 1.0756988779944252e-294*x0[148] + 4.3316718270585498e-307*x0[149] + 0.14673413987130662*x0[150] + 0.018460495009877193*x0[151] - 2.2830531748003493e-315*x0[152] + 5.9240040195691321e-298*x0[153] + 0.08037857505354111*x0[154] - 0.041160042942350122*x0[155] + 0.84363077474170678*x0[156] + 9.5324955962311491e-311*x0[157] - 1.9050563365594352e-311*x0[158] + 0.12871918949936756*x0[159] - 0.085903816854955434*x0[160] - 1.1912972967493313e-303*x0[161] - 9.4272782727503136e-294*x0[162] - 0.099315610574513741*x0[163] + 0.017415318759995795*x0[164] - 0.46498074415988366*x0[165] + 0.10857929046983511*x0[166] - 1.2546939523870135e-299*x0[167] + 0.098430254618694979*x0[168] + 1.0021781884393253e-309*x0[169] + 0.15201224709429687*x0[170] - 5.3827093763042028e-307*x0[171] + 5.5171614693078321e-292*x0[172] - 0.040347236138016072*x0[173] - 0.087011510696257163*x0[174] + 0.043598928334743249*x0[175] + 6.8892875312156174e-316*x0[176] + 8.7694603864354665e-293*x0[177] - 0.45180328873762071*x0[178] + 0.047244189881718274*x0[179] - 1.0409147910095933e-310*x0[180] - 0.074485571270448928*x0[181] - 0.43719063431765953*x0[182] - 0.24129072257061585*x0[183] + 0.1389647984878184*x0[184] + 1.4145842663385928e-315*x0[185] - 1.2441227352230505e-315*x0[186] - 0.12754325443740699*x0[187] + 9.0935715653720048e-303*x0[188] - 0.043378244018076592*x0[189] - 0.062004749688555905*x0[190] + 0.0234758668641919*x0[191] + 1.6582743053279881e-315*x0[192] - 5.298690904313084e-294*x0[193] + 0.27715977543335718*x0[194] - 0.58870052814676399*x0[195] + 8.5914241936260256e-305*x0[196] - 0.016011967507429198*x0[197] - 0.2189467505257941*x0[198] - 0.12591013812441323*x0[199] + 1.0466467869813753e-294*x0[200] + 0.033289720149023608*x0[201] + 2.7912624230631238e-315*x0[202] - 0.073656846753050717*x0[203] + 0.073909769633181882*x0[204] + 0.20547161486374987*x0[205] + 2.1503265517421012e-297*x0[206] + 1.0387275117080965e-295*x0[207] - 0.32456579684535575*x0[208] + 0.077330548554642012*x0[209] + 1.070450671629128e-295*x0[210] + 4.3310180913303972e-314*x0[211] + 0.057387197621120094*x0[212] + 0.070357985337507201*x0[213] - 0.3150937514904274*x0[214] + 2.5130600360842326e-315*x0[215] + 1.5016264109175041e-299*x0[216] + 0.063869944038173712*x0[217] - 0.055426717881951082*x0[218] - 7.7724844383855067e-299*x0[219] + 0.032506528660508439); +x1[7] = relu(0.18309769774453794*x0[0] - 9.993653744522845e-303*x0[1] - 0.0013821538482420245*x0[2] + 0.14384539776301578*x0[3] - 0.11014887026359878*x0[4] - 0.10692896161059576*x0[5] + 1.1925172168790443e-295*x0[6] + 0.061679410671786665*x0[7] + 0.018983300522459869*x0[8] - 0.096850976257836702*x0[9] + 0.10530352007373586*x0[10] + 0.10114051588867733*x0[11] - 2.4884447122990993e-315*x0[12] - 0.18212408786214329*x0[13] + 0.025898098642517131*x0[14] + 5.0370733732919005e-300*x0[15] - 0.032230159403651273*x0[16] - 2.4025277720702926e-310*x0[17] + 2.7047721918301941e-306*x0[18] + 5.1592230565732832e-309*x0[19] - 9.9040851084150954e-303*x0[20] - 0.0436479799107009*x0[21] + 0.14088814154913501*x0[22] + 0.16694570471674425*x0[23] - 5.4843660375155694e-305*x0[24] + 3.7132662807408267e-312*x0[25] - 0.052555241840744484*x0[26] - 0.010926356114517*x0[27] - 1.3246877572697246e-315*x0[28] + 3.4907896572590126e-302*x0[29] + 2.305676871384803e-292*x0[30] + 0.1278902322502565*x0[31] + 0.019104030251283918*x0[32] + 0.062299013572876566*x0[33] + 0.11209523418246051*x0[34] + 7.8672205174629138e-316*x0[35] + 0.016762363719336912*x0[36] - 2.0388581928158538e-314*x0[37] + 0.46581851226787707*x0[38] - 4.4361714767138168e-307*x0[39] + 2.3597329436586312e-315*x0[40] - 0.042081778170924886*x0[41] + 0.1399431823589459*x0[42] + 3.2764689713606991e-300*x0[43] - 1.096994649871224e-315*x0[44] - 6.7855245837737524e-297*x0[45] - 3.7904674099870277e-311*x0[46] + 1.306451947655739e-299*x0[47] - 0.19396607915737271*x0[48] + 2.5315492659898182e-307*x0[49] - 0.086864608831563592*x0[50] - 0.063137943204648272*x0[51] + 5.6599327392894316e-316*x0[52] + 0.032465728045641087*x0[53] - 0.34538442376025602*x0[54] + 0.10088737957512034*x0[55] + 1.8488002968615376e-315*x0[56] + 0.036051283766200787*x0[57] + 6.0676396535009768e-292*x0[58] + 2.2833728056292698e-315*x0[59] - 1.2005542237659624e-310*x0[60] - 1.1837416529460451e-313*x0[61] + 0.1815256528354583*x0[62] - 4.1483786187160634e-315*x0[63] + 1.189739855973341e-300*x0[64] - 1.6061173996534963e-309*x0[65] + 9.0926158145569786e-294*x0[66] - 1.2384605485019375e-311*x0[67] + 0.43650209756488628*x0[68] + 0.081994396101374323*x0[69] - 3.9976693578182342e-315*x0[70] + 5.4511168742915894e-294*x0[71] + 1.1845622901276273e-311*x0[72] + 0.14745057029078057*x0[73] - 0.11886328707807645*x0[74] + 5.5150367679216033e-314*x0[75] + 0.37839088708364421*x0[76] + 1.3702207335553553e-315*x0[77] + 7.7194655881833967e-298*x0[78] - 3.3861166355663561e-315*x0[79] + 2.5579228962032509e-311*x0[80] + 0.27651311634809594*x0[81] + 3.0477967107474773e-306*x0[82] + 9.4156424294209428e-298*x0[83] - 3.8443309641331774e-300*x0[84] + 0.36627164826519526*x0[85] + 0.32777930499602531*x0[86] + 0.1254272112622867*x0[87] + 0.10421545180878071*x0[88] + 1.1884699435893995e-308*x0[89] + 0.6810573858962321*x0[90] + 0.13420457647019549*x0[91] - 1.0939284784731332e-315*x0[92] - 0.047933591723003814*x0[93] - 0.012289459299888082*x0[94] + 0.62368437878855076*x0[95] + 1.1051123028748301e-300*x0[96] + 1.0161593505766136e-312*x0[97] + 9.3866369516913766e-316*x0[98] + 1.1192285130160915e-295*x0[99] + 0.22324346615375062*x0[100] + 9.3350507176974942e-317*x0[101] + 0.0170483446542989*x0[102] - 3.3349937462164564e-315*x0[103] - 4.0779352409027147e-314*x0[104] + 4.694417503437873e-290*x0[105] - 1.8610712687246793e-303*x0[106] + 3.9367372002039862e-315*x0[107] - 0.051380902741830811*x0[108] + 2.4987860950617769e-305*x0[109] - 0.17941736126726737*x0[110] - 0.047556092806359446*x0[111] + 1.4331762727936122e-315*x0[112] - 1.3135595919989867e-308*x0[113] - 5.2195814935197048e-300*x0[114] + 0.10824210118284226*x0[115] + 0.029058901431878458*x0[116] + 0.12252923410244296*x0[117] + 2.4765372626901233e-312*x0[118] - 4.2197754885370608e-308*x0[119] - 0.18196738047678529*x0[120] - 0.032038763974502137*x0[121] - 0.4610247294404235*x0[122] + 0.046319050003475172*x0[123] - 0.63184724920614599*x0[124] - 1.2301976927869574e-300*x0[125] - 1.2027942072858561e-296*x0[126] + 0.20622373142130443*x0[127] + 1.4741810682659175e-316*x0[128] - 1.7602963308612096e-311*x0[129] - 0.12759540895733248*x0[130] + 0.32639391294814923*x0[131] - 0.42168582583801822*x0[132] - 1.5709029132008783e-306*x0[133] + 0.23985914850764453*x0[134] - 0.050912751440663651*x0[135] + 0.064157363185994187*x0[136] + 0.065480240911991144*x0[137] - 4.7318499757597033e-306*x0[138] + 1.660756011490196e-299*x0[139] + 0.0010011124712062617*x0[140] + 0.47758458935754183*x0[141] + 0.020355599680096269*x0[142] + 2.7045369128582411e-301*x0[143] - 7.0147997355862962e-292*x0[144] + 0.11218401140555799*x0[145] + 3.2164754559898251e-316*x0[146] + 0.16945095715972078*x0[147] + 2.6454576184338362e-315*x0[148] + 1.6059088301772674e-299*x0[149] - 0.065511737257634636*x0[150] - 0.015417672900505259*x0[151] + 7.4863409380075065e-294*x0[152] - 1.2428278760527253e-305*x0[153] - 0.069854028495537901*x0[154] - 0.12367766573201791*x0[155] - 1.8232554827118814*x0[156] - 2.7303900720953049e-315*x0[157] + 5.2051056643272121e-300*x0[158] + 0.16206408653824869*x0[159] + 0.0067895721581206847*x0[160] + 8.8414227877314974e-304*x0[161] - 1.492682962087792e-315*x0[162] + 0.15216869460620019*x0[163] - 0.17191461423066987*x0[164] + 0.059726842096976311*x0[165] + 0.079832026363421738*x0[166] + 2.706573766988795e-309*x0[167] + 0.10609411552561*x0[168] - 8.1919501038485315e-316*x0[169] + 0.1612733700656831*x0[170] - 1.6712487501021969e-299*x0[171] + 9.4817478127955928e-308*x0[172] - 0.13663345515141267*x0[173] + 0.11483689279032465*x0[174] + 0.11428546057848456*x0[175] - 6.2643255744534254e-295*x0[176] + 5.7292553735347266e-301*x0[177] - 1.0077668701513576*x0[178] + 0.15547607363666019*x0[179] + 2.6316851344367326e-301*x0[180] + 0.58128551851410937*x0[181] + 0.014144340307851522*x0[182] - 0.11599836458415103*x0[183] + 0.084048922720026245*x0[184] + 8.3699588937175653e-312*x0[185] - 4.4107125248627603e-312*x0[186] + 0.6522063721470851*x0[187] + 2.7424685866090645e-310*x0[188] + 0.066843396721615364*x0[189] + 0.45889442208964804*x0[190] - 0.020240504533116852*x0[191] + 7.6171147388492941e-308*x0[192] - 2.3960190268419488e-316*x0[193] + 0.16079427256160683*x0[194] - 0.22536742626413026*x0[195] + 4.786873966216728e-297*x0[196] - 0.034233480959635083*x0[197] + 0.078000462743437748*x0[198] + 0.20241705823326142*x0[199] - 1.0946800951692939e-303*x0[200] + 0.27870574631092965*x0[201] - 7.9949832535320307e-293*x0[202] + 0.039367625925130087*x0[203] + 0.10574628593042708*x0[204] + 0.1456623426356953*x0[205] - 4.6385850773975923e-295*x0[206] + 8.7209832457741923e-316*x0[207] + 0.050389193756523475*x0[208] + 0.36215184519429355*x0[209] + 9.274869520102299e-316*x0[210] + 9.7249872664501816e-295*x0[211] + 0.0058621179138875759*x0[212] + 0.15757268000783289*x0[213] - 0.093007260048802054*x0[214] + 4.5359783285525304e-290*x0[215] - 4.2626623863436382e-299*x0[216] - 0.052461985357654416*x0[217] - 0.016644774888109549*x0[218] + 3.480752810248252e-315*x0[219] - 0.023875997656202658); +x2[0] = relu(0.55800284880946083*x1[0] + 1.1966704325228015*x1[1] + 1.0294981891171815*x1[2] - 1.1519814591285755*x1[3] + 0.50659827991669171*x1[4] - 1.3033184163654803*x1[5] + 0.010475672155849283*x1[6] + 0.90831836409432853*x1[7] + 1.1844337554371509); +x2[1] = relu(-0.514451625589187*x1[0] + 0.46195256454288375*x1[1] - 1.5756023756440205*x1[2] + 0.66169009017998015*x1[3] + 0.87166307777297725*x1[4] + 0.016569343156980634*x1[5] + 0.88918417765469338*x1[6] - 0.87685208073834064*x1[7] + 0.20858959902658483); +x2[2] = relu(-0.09325394725844903*x1[0] + 0.21518897768520051*x1[1] - 0.012365545872623134*x1[2] - 0.035668886264491294*x1[3] + 0.015594067868800543*x1[4] - 0.055419604207940183*x1[5] - 0.10341197784511584*x1[6] - 0.020884845337471751*x1[7] - 0.38572717126414052); +x2[3] = relu(0.84462456618632009*x1[0] - 0.29033469115580413*x1[1] + 2.3120512091783882*x1[2] - 0.0042852475244832397*x1[3] - 0.031942099107773493*x1[4] + 0.54240512137966213*x1[5] - 1.3029761574303527*x1[6] - 0.81111520375999824*x1[7] - 0.36957780638258436); +x3_result[0] = sigmoid(-1.6586703209380282*x2[0] + 1.0957227401539915*x2[1] + 0.20946670824801569*x2[2] - 2.128419282564376*x2[3] - 1.0187430367351187); + + return x3_result[0]; + } +} + diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.h b/src/dreal/util/pattern_matching/pattern_matching_heuristic.h new file mode 100644 index 000000000..bb6bdc1c6 --- /dev/null +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.h @@ -0,0 +1,41 @@ +// +// Created by Kunal Sheth on 4/13/25. +// + +#ifndef PATTERN_MATCHING_HEURISTIC_H +#define PATTERN_MATCHING_HEURISTIC_H +#include + +#include "pattern_matching_trie.h" + +namespace dreal +{ + class PatternMatchingHeuristic + { + public: + using statistics = struct + { + unsigned box_continuous_count; + unsigned box_integer_count; + unsigned box_boolean_count; + unsigned assertions_size; + PredicateHeuristic::predicate_stats_t assertions_stats; + PredicateHeuristic::predicate_stats_t biggest_assertion_stats; + PredicateHeuristic::predicate_stats_t middle_assertion_stats; + PredicateHeuristic::predicate_stats_t smallest_assertion_stats; + double theory_checksat_ms; + unsigned lemma_size; + PredicateHeuristic::predicate_stats_t lemma_stats; + PredicateHeuristic::predicate_stats_t biggest_literal_stats; + PredicateHeuristic::predicate_stats_t middle_literal_stats; + PredicateHeuristic::predicate_stats_t smallest_literal_stats; + uint64_t estimated_matching_cost; + double pattern_match_ms; + PatternMatchingTrie::matching_stats_t pattern_matching_stats; + }; + + static float calculate(statistics k); + }; +} + +#endif //PATTERN_MATCHING_HEURISTIC_H diff --git a/src/dreal/util/predicate_heuristic_trained_model.h b/src/dreal/util/predicate_heuristic_trained_model.h deleted file mode 100644 index 2908a1a06..000000000 --- a/src/dreal/util/predicate_heuristic_trained_model.h +++ /dev/null @@ -1,83 +0,0 @@ - -#pragma once - -// This file was automatically generated on 2025-04-10 21:28:55.533980 by Kunal in the `WORTH_IT_regression` python notebook. -// -// Notes: -// len(df_overestimated) / len(df) = 0.012 -// len(df_valid_over) / len(df) = 0.073 -// len(df_valid_under) / len(df) = 0.893 -// len(df_underestimated) / len(df) = 0.022 -// -// MINIMUM_WEIGHT_THRESHOLD = 0.001 -// r2_score(y_test, y_pred) = 0.8104209494854622 -// len(X_train) = 2946 -// len(X_test) / len(X_train) = 0.25 - -#define WORTH_IT_REGRESSION_MODEL(k) \ -(0.0 * k.lemma_stats.sqrt_cntr \ - + 0.0 * k.assertions_stats.true_cntr \ - + 0.0 * k.assertions_stats.false_cntr \ - + 0.0 * k.lemma_stats.log_cntr \ - + 0.0 * k.lemma_stats.disjunction_cntr \ - + 0.0 * k.lemma_stats.false_cntr \ - + 0.0 * k.lemma_stats.forall_cntr \ - + 0.0 * k.lemma_stats.ifthenelse_cntr \ - + 0.0 * k.assertions_stats.notequalto_cntr \ - + 0.0 * k.lemma_stats.max_cntr \ - + 0.0 * k.assertions_stats.ifthenelse_cntr \ - + 0.0 * k.lemma_stats.true_cntr \ - + 0.0 * k.assertions_stats.uninterpretedfunction_cntr \ - + 0.0 * k.assertions_stats.min_cntr \ - + 0.0 * k.lemma_stats.uninterpretedfunction_cntr \ - + 0.0 * k.lemma_stats.min_cntr \ - + 0.0 * k.assertions_stats.disjunction_cntr \ - + 0.0 * k.lemma_stats.notequalto_cntr \ - + 0.0 * k.lemma_stats.exp_cntr \ - + 0.0 * k.assertions_stats.forall_cntr \ - + 0.0 * k.assertions_stats.max_cntr \ - + 0.0 * k.assertions_stats.exp_cntr \ - + 0.0 * k.assertions_stats.sqrt_cntr \ - + 0.0 * k.theory_checksat_ms \ - + 0.001217835225040596 * k.lemma_stats.addition_cntr \ - + -0.001962464451051034 * k.assertions_stats.realconstant_cntr \ - + -0.00793823796983405 * k.box_boolean_count \ - + -0.018145367826638337 * k.lemma_stats.variable_cntr \ - + 0.01829872636385954 * k.assertions_stats.negation_cntr \ - + -0.0229918912587667 * k.assertions_stats.variable_cntr \ - + -0.026376483705783937 * k.lemma_stats.negation_cntr \ - + 0.03017973232438398 * k.assertions_stats.addition_cntr \ - + -0.04107952767894013 * k.assertions_stats.trigonometry_cntr \ - + 0.05688306599609716 * k.assertions_stats.multiplication_cntr \ - + -0.060369550994358256 * k.assertions_stats.constant_cntr \ - + -0.07187529638117285 * k.box_continuous_count \ - + 0.07715080264816576 * k.assertions_stats.unique_variables \ - + 0.09232150621308066 * k.assertions_stats.pow_cntr \ - + 0.1026319444631465 * k.lemma_stats.pow_cntr \ - + -0.12459598630366009 * k.lemma_stats.constant_cntr \ - + 0.12927570458507232 * k.lemma_stats.trigonometry_cntr \ - + -0.1543638666996886 * k.lemma_stats.realconstant_cntr \ - + 0.15572623801096852 * k.lemma_stats.multiplication_cntr \ - + 0.15676812548357882 * k.lemma_stats.unique_variables \ - + -0.2653378609984196 * log2(1+k.box_boolean_count) \ - + -0.3545373118515116 * log2(1+k.box_continuous_count) \ - + -0.37408199290852107 * k.assertions_stats.division_cntr \ - + 0.5067092831074196 * k.lemma_stats.division_cntr \ - + -0.5157600045238886 * k.box_integer_count \ - + -1.0349214239587998 * k.lemma_stats.inequality_cntr \ - + 1.1187279976413107 * k.lemma_stats.abs_cntr \ - + 1.1380968359246078 * log2(1+k.theory_checksat_ms) \ - + 1.3026143754266153 * k.assertions_stats.log_cntr \ - + -1.451141643731522 * k.lemma_stats.equalto_cntr \ - + 1.6079717697721332 * k.assertions_stats.equalto_cntr \ - + -1.6377938127199587 * log2(1+k.box_integer_count) \ - + 1.6855709083177568 * k.assertions_stats.inequality_cntr \ - + 1.7110196321336344 * k.assertions_stats.abs_cntr \ - + 1.8035404953112604 * log2(1+k.assertions_size) \ - + -1.9480121854993735 * log2(1+k.lemma_size) \ - + -2.4860630676902487 * k.lemma_size \ - + 3.293542678090737 * k.assertions_size \ - + 3.666239777026109 * k.lemma_stats.conjunction_cntr \ - + -4.862501458432937 * k.assertions_stats.conjunction_cntr \ - + -8.42502822088598) - diff --git a/test/dreal/util/test/pattern_matching_heuristic_test.cc b/test/dreal/util/test/pattern_matching_heuristic_test.cc new file mode 100644 index 000000000..f43e7ae0a --- /dev/null +++ b/test/dreal/util/test/pattern_matching_heuristic_test.cc @@ -0,0 +1,4407 @@ + +// This file was automatically generated on 2025-04-14 00:05:27.500595 by Kunal in the `WORTH_IT_regression` python notebook. + + +#include +#include + +namespace dreal +{ + namespace + { + class PatternMatchingHeuristicTest : public ::testing::Test + { + protected: + void SetUp() override {} + }; + + TEST_F(PatternMatchingHeuristicTest, Generated) { + PatternMatchingHeuristic::statistics k; + float expected_value = -1E9; + float calculated_value = -1E9; + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1079; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 538; +k.assertions_stats.unique_variables = 1079; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 862; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 902; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1569; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1207; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 536; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 46; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 3722; +k.theory_checksat_ms = 0.426912; +k.box_boolean_count = 5725; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2069; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 2069; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.7555246294934173; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 15980: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1301; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 419; +k.assertions_stats.unique_variables = 1301; +k.lemma_stats.conjunction_cntr = 4; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 721; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 4; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 1142; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 4; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1581; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1465; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 584; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 4; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 58; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 4124; +k.theory_checksat_ms = 0.107627; +k.box_boolean_count = 4384; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 4; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2186; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 2186; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.521368718251169; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 3267: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 941; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 410; +k.assertions_stats.unique_variables = 941; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 745; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 822; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1369; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1057; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 424; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 42; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 3200; +k.theory_checksat_ms = 0.633665; +k.box_boolean_count = 4924; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 1802; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 1802; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.5851091945741282; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 14862: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 761; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 342; +k.assertions_stats.unique_variables = 761; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 607; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 662; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1113; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; +k.assertions_stats.equalto_cntr = 853; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 344; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 34; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2588; +k.theory_checksat_ms = 0.228382; +k.box_boolean_count = 3994; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 1460; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; +k.assertions_size = 1460; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.5626372673913672; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 12973: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 311; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 134; +k.assertions_stats.unique_variables = 311; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 262; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 262; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 473; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 343; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 144; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 14; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 1058; +k.theory_checksat_ms = 0.188873; +k.box_boolean_count = 1669; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 605; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 605; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.5449244520084344; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 1523: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1173; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 546; +k.assertions_stats.unique_variables = 1173; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 935; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 982; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1703; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1313; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 582; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 50; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 4046; +k.theory_checksat_ms = 0.798768; +k.box_boolean_count = 6218; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2248; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 2248; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.9865325448134941; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 115: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 58; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 19; +k.assertions_stats.unique_variables = 58; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 2; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 42; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 2; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 1; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 17; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 4; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 85; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 2; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 3; +k.assertions_stats.equalto_cntr = 56; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 52; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 6; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 2; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 198; +k.theory_checksat_ms = 0.133798; +k.box_boolean_count = 22; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 6; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 2; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 98; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 3; +k.assertions_size = 98; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.9176756792767737; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 13267: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1031; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 468; +k.assertions_stats.unique_variables = 1031; +k.lemma_stats.conjunction_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 814; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 902; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 2; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1497; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1159; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 464; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 2; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 46; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 3506; +k.theory_checksat_ms = 0.400875; +k.box_boolean_count = 5389; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 2; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 1973; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 1973; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.8427251964625254; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 1379: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 2379; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 1188; +k.assertions_stats.unique_variables = 2379; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 1092; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 1670; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 3379; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 2777; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 1866; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 94; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 7792; +k.theory_checksat_ms = 80.867; +k.box_boolean_count = 6491; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 3869; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 3869; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.9999859625552632; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 989: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 761; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 329; +k.assertions_stats.unique_variables = 761; +k.lemma_stats.conjunction_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 607; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 2; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 662; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 2; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1113; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; +k.assertions_stats.equalto_cntr = 853; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 344; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 2; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 34; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2588; +k.theory_checksat_ms = 0.552686; +k.box_boolean_count = 3994; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 2; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 1460; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; +k.assertions_size = 1460; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.9947370775745865; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 13030: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 2; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 1; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 23; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 1255; +k.assertions_stats.unique_variables = 24; +k.lemma_stats.conjunction_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 7; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 2; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 467; +k.middle_literal_stats.constant_cntr = 0; +k.assertions_stats.realconstant_cntr = 1363; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 2; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 1; +k.assertions_stats.constant_cntr = 1198; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.assertions_stats.equalto_cntr = 2221; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 345; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 0; +k.lemma_size = 2; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2263; +k.theory_checksat_ms = 0.0640391; +k.box_boolean_count = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2228; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 6; +k.assertions_size = 2228; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 5.133294085747257e-05; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 7242: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 161; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.lemma_stats.multiplication_cntr = 141; +k.middle_literal_stats.multiplication_cntr = 1; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1315; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 543; +k.assertions_stats.unique_variables = 1315; +k.lemma_stats.conjunction_cntr = 233; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 3; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 609; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 184; +k.biggest_literal_stats.variable_cntr = 3; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 72; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 13; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 914; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 467; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 1881; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 2; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1531; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 1040; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 2; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 34; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 233; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 52; +k.lemma_stats.addition_cntr = 74; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 4306; +k.theory_checksat_ms = 37.6658; +k.box_boolean_count = 3572; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 234; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 2; +k.assertions_stats.conjunction_cntr = 2140; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 2140; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 1.4067878668063158e-13; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 13904: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 2; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 1; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 23; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 1095; +k.assertions_stats.unique_variables = 24; +k.lemma_stats.conjunction_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 1; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 7; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 2; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 554; +k.middle_literal_stats.constant_cntr = 0; +k.assertions_stats.realconstant_cntr = 1474; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 1; +k.lemma_stats.variable_cntr = 2; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 1; +k.assertions_stats.constant_cntr = 1311; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.assertions_stats.equalto_cntr = 2425; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 365; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 0; +k.lemma_size = 2; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2467; +k.theory_checksat_ms = 0.0255911; +k.box_boolean_count = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2432; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 6; +k.assertions_size = 2432; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 1.207162311518787e-09; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 5991: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 2; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 1; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 23; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 673; +k.assertions_stats.unique_variables = 24; +k.lemma_stats.conjunction_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 7; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 2; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 1; +k.assertions_stats.addition_cntr = 784; +k.middle_literal_stats.constant_cntr = 0; +k.assertions_stats.realconstant_cntr = 1653; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 1; +k.lemma_stats.variable_cntr = 2; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; +k.assertions_stats.constant_cntr = 1618; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.assertions_stats.equalto_cntr = 2859; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 417; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 0; +k.lemma_size = 2; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2901; +k.theory_checksat_ms = 0.101; +k.box_boolean_count = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2866; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 6; +k.assertions_size = 2866; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 5.4670130632985314e-08; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 4506: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 2; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 1; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 23; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 1345; +k.assertions_stats.unique_variables = 24; +k.lemma_stats.conjunction_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 1; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 7; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 407; +k.middle_literal_stats.constant_cntr = 0; +k.assertions_stats.realconstant_cntr = 1333; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 2; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; +k.assertions_stats.constant_cntr = 1129; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.assertions_stats.equalto_cntr = 2131; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 336; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 0; +k.lemma_size = 2; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2173; +k.theory_checksat_ms = 0.0527811; +k.box_boolean_count = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 1; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2138; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 6; +k.assertions_size = 2138; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 2.765947552768804e-07; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 8614: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 761; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 241; +k.assertions_stats.unique_variables = 761; +k.lemma_stats.conjunction_cntr = 4; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 427; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 4; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 662; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 4; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 933; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 853; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 344; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 4; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 34; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 2408; +k.theory_checksat_ms = 0.105549; +k.box_boolean_count = 2554; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 4; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 1280; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 1280; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.4372270207842434; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 1277: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1455; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 727; +k.assertions_stats.unique_variables = 1455; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 1154; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 1222; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 2105; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; +k.assertions_stats.equalto_cntr = 1631; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 720; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 62; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 5018; +k.theory_checksat_ms = 0.158808; +k.box_boolean_count = 7697; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2785; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; +k.assertions_size = 2785; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.3981107348641727; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 15578: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 1391; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 640; +k.assertions_stats.unique_variables = 1391; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 1090; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 1222; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 2009; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 1567; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 624; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 62; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 4730; +k.theory_checksat_ms = 0.194292; +k.box_boolean_count = 7249; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 2657; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 2657; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.10349768981386948; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 12694: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 555; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 221; +k.assertions_stats.unique_variables = 555; +k.lemma_stats.conjunction_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 264; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 2; +k.lemma_stats.inequality_cntr = 3; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 374; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 3; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 811; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 641; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 450; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 3; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 22; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 1816; +k.theory_checksat_ms = 0.127112; +k.box_boolean_count = 1487; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 905; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 905; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.48373694190302663; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 602: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.lemma_stats.equalto_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.assertions_stats.exp_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.box_continuous_count = 581; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.box_integer_count = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.assertions_stats.negation_cntr = 260; +k.assertions_stats.unique_variables = 581; +k.lemma_stats.conjunction_cntr = 6; +k.biggest_literal_stats.abs_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 2; +k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.assertions_stats.inequality_cntr = 469; +k.middle_literal_stats.notequalto_cntr = 0; +k.lemma_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.variable_cntr = 1; +k.lemma_stats.inequality_cntr = 5; +k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.assertions_stats.addition_cntr = 502; +k.middle_literal_stats.constant_cntr = 1; +k.assertions_stats.realconstant_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.variable_cntr = 7; +k.assertions_stats.disjunction_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.assertions_stats.constant_cntr = 857; +k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.assertions_stats.abs_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.lemma_stats.abs_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.assertions_stats.equalto_cntr = 649; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.assertions_stats.multiplication_cntr = 264; +k.biggest_literal_stats.log_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.biggest_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.unique_variables = 1; +k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.notequalto_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.lemma_size = 6; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.variable_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.pow_cntr = 26; +k.lemma_stats.addition_cntr = 0; +k.middle_literal_stats.abs_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.variable_cntr = 1976; +k.theory_checksat_ms = 1.08095; +k.box_boolean_count = 3064; +k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.multiplication_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.lemma_stats.constant_cntr = 5; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 1118; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.assertions_size = 1118; +k.biggest_assertion_stats.inequality_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.abs_cntr = 0; +k.lemma_stats.forall_cntr = 0; +expected_value = 0.19428732097796983; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 3222: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + + + } + } // namespace +} // namespace dreal + From fa82b669dc1d50852985bbe5223f5367c532a24f Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 14 Apr 2025 00:16:15 -0700 Subject: [PATCH 22/79] Revert "REVERT ME - changes for blasty training." This reverts commit 4305c8604ce92ea837b9f85dad6e17a833ef12ab. --- src/dreal/solver/context_impl.cc | 5 ++--- src/dreal/solver/sat_solver.cc | 2 -- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 5be2d475f..a5a364fcc 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -135,7 +135,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { //////////////////////////////////////////////////////////////////////////////// - static constexpr bool GENERATE_CSV = true; + static constexpr bool GENERATE_CSV = false; std::ofstream myfile; if (GENERATE_CSV) { std::ostringstream s; @@ -296,8 +296,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, predicted_is_worth_it, (ranking_elapsed1 + ranking_elapsed2).count() ); - // if (/* true */ predicted_log2_worth_it > 1) { - if (true) { + if (predicted_is_worth_it >= 0.5) { const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( pn_, explanation_vec, box, diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 09179c441..42903c1b7 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -107,7 +107,6 @@ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( return match_statistics; } - /* for (const auto& [conflict_clause, subs] : all_related_conflicts) { Box conflict_box = substitutions_map::apply_substitution(base_box, subs, false); @@ -132,7 +131,6 @@ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( cadical->add(0); } - */ return match_statistics; } From 6d58de6f7f569877c451a352800f06845bb5fcde Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 14 Apr 2025 00:31:08 -0700 Subject: [PATCH 23/79] Fix subtle segfault in trace mode. --- src/dreal/util/pattern_matching/substitutions_map.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/dreal/util/pattern_matching/substitutions_map.cc b/src/dreal/util/pattern_matching/substitutions_map.cc index 5b5880549..ab1928ce5 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.cc +++ b/src/dreal/util/pattern_matching/substitutions_map.cc @@ -70,8 +70,11 @@ namespace dreal } DREAL_LOG_TRACE( - "Substitution failed. New 'a' {} is already {}, while new 'aP' {} is already {}.", - a.get_name(), it_aP->second.get_name(), aP.get_name(), it_a->second.get_name() + "Substitution failed. New 'a' {} is {}, while new 'aP' {} is {}.", + a.get_name(), + has_aP ? it_aP->second.get_name() : "unmapped", + aP.get_name(), + has_a ? it_a->second.get_name() : "unmapped" ); return false; } From ecf80673d42c1b7c895b367f583b9ace9ac8ebd5 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 14 Apr 2025 01:20:45 -0700 Subject: [PATCH 24/79] Improve logging for benchmarking run! --- src/dreal/solver/context_impl.cc | 47 +- .../pattern_matching_heuristic.cc | 870 +- .../pattern_matching_heuristic.h | 8 +- .../test/pattern_matching_heuristic_test.cc | 7714 ++++++++--------- 4 files changed, 4324 insertions(+), 4315 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index a5a364fcc..490d5bb13 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -157,7 +157,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (!myfile) throw DREAL_RUNTIME_ERROR("Failed to open log file"); } - PatternMatchingHeuristic::statistics kunal_paper_data; + PatternMatchingHeuristic::statistics kunal_paper_data{0}; //////////////////////////////////////////////////////////////////////////////// DREAL_LOG_DEBUG("ContextImpl::CheckSatCore()"); @@ -288,20 +288,17 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.biggest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[0]); kunal_paper_data.middle_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size() / 2]); kunal_paper_data.smallest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size()-1]); - const double predicted_is_worth_it = PatternMatchingHeuristic::calculate(kunal_paper_data); + const float predicted_is_worth_it = PatternMatchingHeuristic::calculate(kunal_paper_data); const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; - DREAL_LOG_INFO("Total lemma info: Predicted P(is W.I.)={}, in {}ms", - predicted_is_worth_it, (ranking_elapsed1 + ranking_elapsed2).count() - ); - if (predicted_is_worth_it >= 0.5) { + // if (false) { const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( pn_, explanation_vec, box, // std::chrono::duration_cast(100 * tscs_elapsed) - std::chrono::seconds(30) + std::chrono::seconds(10) // based on information from WORTH_IT_regression_4.ipynb ); const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; @@ -309,23 +306,29 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.pattern_match_ms = alcp_elapsed.count(); kunal_paper_data.pattern_matching_stats = alcp_result; - const double bb_lpms = 1 / tscs_elapsed.count(); - const double pm_lpms = (alcp_result.matches - 0.999) / alcp_elapsed.count(); - const double actual_worth_it = pm_lpms / bb_lpms; - const double actual_log2_worth_it = log2(actual_worth_it); - - DREAL_LOG_INFO("Predicted P(is W.I.)={}, Measured log2 W.I. ratio = {}", predicted_is_worth_it, actual_log2_worth_it); - const bool overestimated = (actual_log2_worth_it < 1) && (predicted_is_worth_it > 0.5); - const bool valid_over = (actual_log2_worth_it > 1) && (predicted_is_worth_it > 0.5); - const bool valid_under = (actual_log2_worth_it < 1) && (predicted_is_worth_it < 0.5); - const bool underestimated = (actual_log2_worth_it > 1) && (predicted_is_worth_it < 0.5); - if (overestimated) DREAL_LOG_INFO("OVERESTIMATED. Had high hopes but were disappointed in the end."); - if (valid_over) DREAL_LOG_INFO("VALID_OVER. It was worth it like we thought."); - if (valid_under) DREAL_LOG_INFO("VALID_UNDER. We knew to avoid this one."); - if (underestimated) DREAL_LOG_INFO("UNDERESTIMATED. Sorry we didn't believe in you."); + // const double bb_lpms = 1 / tscs_elapsed.count(); + // const double pm_lpms = (alcp_result.matches - 0.999) / alcp_elapsed.count(); + // const double actual_worth_it = pm_lpms / bb_lpms; + // const double actual_log2_worth_it = log2(actual_worth_it); + + std::cerr << "P(is W.I.)=" << predicted_is_worth_it; + std::cerr << ". Matched " << alcp_result.matches << " size " << explanation_vec.size() << " in " << alcp_elapsed.count(); + std::cerr << " ms. TSCS " << tscs_elapsed.count() << " ms." << std::endl; + + // DREAL_LOG_INFO("Predicted P(is W.I.)={}, Measured log2 W.I. ratio = {}", predicted_is_worth_it, actual_log2_worth_it); + // const bool overestimated = (actual_log2_worth_it < 1) && (predicted_is_worth_it > 0.5); + // const bool valid_over = (actual_log2_worth_it > 1) && (predicted_is_worth_it > 0.5); + // const bool valid_under = (actual_log2_worth_it < 1) && (predicted_is_worth_it < 0.5); + // const bool underestimated = (actual_log2_worth_it > 1) && (predicted_is_worth_it < 0.5); + // if (overestimated) DREAL_LOG_INFO("OVERESTIMATED. Had high hopes but were disappointed in the end."); + // if (valid_over) DREAL_LOG_INFO("VALID_OVER. It was worth it like we thought."); + // if (valid_under) DREAL_LOG_INFO("VALID_UNDER. We knew to avoid this one."); + // if (underestimated) DREAL_LOG_INFO("UNDERESTIMATED. Sorry we didn't believe in you."); } else { - DREAL_LOG_INFO("Skipped pattern matching. Adding learned clause conventionally."); + std::cerr << "P(is W.I.)=" << predicted_is_worth_it; + std::cerr << ". Adding 1 size " << explanation_vec.size() << " directly. "; + std::cerr << "TSCS " << tscs_elapsed.count() << " ms." << std::endl; sat_solver->AddLearnedClause(explanation_vec, box); } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc index 171108635..ba307588a 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc @@ -1,16 +1,16 @@ -// This file was automatically generated on 2025-04-14 00:04:44.271759 by Kunal in the `WORTH_IT_regression` python notebook. +// This file was automatically generated on 2025-04-14 01:52:12.066920 by Kunal in the `WORTH_IT_regression` python notebook. // // Notes: -// len(df_overestimated) / len(df) = 0.013 -// len(df_valid_over) / len(df) = 0.176 -// len(df_valid_under) / len(df) = 0.798 -// len(df_underestimated) / len(df) = 0.013 +// len(df_overestimated) / len(df) = 0.015 +// len(df_valid_over) / len(df) = 0.189 +// len(df_valid_under) / len(df) = 0.784 +// len(df_underestimated) / len(df) = 0.012 // -// accuracy_score(y_test, y_pred) = 0.9714551659944152 -// len(X_train) = 12890 +// accuracy_score(y_test, y_pred) = 0.966657085369359 +// len(X_train) = 13913 // len(X_test) / len(X_train) = 0.25 -// model = Pipeline(steps=[('standardscaler', StandardScaler()), ('mlpclassifier', MLPClassifier(hidden_layer_sizes=(8, 4), max_iter=500, random_state=42))]) +// model = Pipeline(steps=[('standardscaler', StandardScaler()), ('mlpclassifier', MLPClassifier(hidden_layer_sizes=(8, 4), max_iter=1000, random_state=42))]) #include "pattern_matching_heuristic.h" @@ -20,467 +20,467 @@ namespace dreal float relu(const float x) { return x < 0 ? 0 : x; } float sigmoid(const float x) { return 1 / (1 + expf(-x)); } - float PatternMatchingHeuristic::calculate(statistics k) { + float PatternMatchingHeuristic::calculate(const statistics& k) { -const float lemma_stats_equalto_cntr = k.lemma_stats.equalto_cntr; -const float smallest_assertion_stats_notequalto_cntr = k.smallest_assertion_stats.notequalto_cntr; -const float smallest_literal_stats_unique_variables = k.smallest_literal_stats.unique_variables; -const float smallest_literal_stats_constant_cntr = k.smallest_literal_stats.constant_cntr; -const float middle_assertion_stats_constant_cntr = k.middle_assertion_stats.constant_cntr; -const float middle_literal_stats_realconstant_cntr = k.middle_literal_stats.realconstant_cntr; -const float assertions_stats_min_cntr = k.assertions_stats.min_cntr; -const float smallest_literal_stats_pow_cntr = k.smallest_literal_stats.pow_cntr; -const float middle_literal_stats_equalto_cntr = k.middle_literal_stats.equalto_cntr; -const float lemma_stats_multiplication_cntr = k.lemma_stats.multiplication_cntr; -const float middle_literal_stats_multiplication_cntr = k.middle_literal_stats.multiplication_cntr; -const float middle_literal_stats_division_cntr = k.middle_literal_stats.division_cntr; +const float LOG2P1_assertions_size = log2(1+k.assertions_size); +const float LOG2P1_box_boolean_count = log2(1+k.box_boolean_count); +const float LOG2P1_box_continuous_count = log2(1+k.box_continuous_count); +const float LOG2P1_box_integer_count = log2(1+k.box_integer_count); +const float LOG2P1_lemma_size = log2(1+k.lemma_size); +const float LOG2P1_theory_checksat_ms = log2(1+k.theory_checksat_ms); +const float assertions_size = k.assertions_size; +const float assertions_stats_abs_cntr = k.assertions_stats.abs_cntr; +const float assertions_stats_addition_cntr = k.assertions_stats.addition_cntr; +const float assertions_stats_conjunction_cntr = k.assertions_stats.conjunction_cntr; +const float assertions_stats_constant_cntr = k.assertions_stats.constant_cntr; +const float assertions_stats_disjunction_cntr = k.assertions_stats.disjunction_cntr; +const float assertions_stats_division_cntr = k.assertions_stats.division_cntr; +const float assertions_stats_equalto_cntr = k.assertions_stats.equalto_cntr; const float assertions_stats_exp_cntr = k.assertions_stats.exp_cntr; -const float biggest_assertion_stats_realconstant_cntr = k.biggest_assertion_stats.realconstant_cntr; -const float box_continuous_count = k.box_continuous_count; -const float middle_literal_stats_uninterpretedfunction_cntr = k.middle_literal_stats.uninterpretedfunction_cntr; -const float box_integer_count = k.box_integer_count; -const float smallest_assertion_stats_exp_cntr = k.smallest_assertion_stats.exp_cntr; -const float middle_assertion_stats_notequalto_cntr = k.middle_assertion_stats.notequalto_cntr; -const float middle_assertion_stats_log_cntr = k.middle_assertion_stats.log_cntr; -const float middle_assertion_stats_forall_cntr = k.middle_assertion_stats.forall_cntr; -const float middle_literal_stats_addition_cntr = k.middle_literal_stats.addition_cntr; -const float lemma_stats_division_cntr = k.lemma_stats.division_cntr; -const float biggest_assertion_stats_addition_cntr = k.biggest_assertion_stats.addition_cntr; -const float lemma_stats_max_cntr = k.lemma_stats.max_cntr; -const float smallest_literal_stats_false_cntr = k.smallest_literal_stats.false_cntr; -const float lemma_stats_trigonometry_cntr = k.lemma_stats.trigonometry_cntr; -const float middle_assertion_stats_inequality_cntr = k.middle_assertion_stats.inequality_cntr; -const float biggest_assertion_stats_abs_cntr = k.biggest_assertion_stats.abs_cntr; +const float assertions_stats_false_cntr = k.assertions_stats.false_cntr; +const float assertions_stats_forall_cntr = k.assertions_stats.forall_cntr; const float assertions_stats_ifthenelse_cntr = k.assertions_stats.ifthenelse_cntr; -const float biggest_literal_stats_min_cntr = k.biggest_literal_stats.min_cntr; +const float assertions_stats_inequality_cntr = k.assertions_stats.inequality_cntr; +const float assertions_stats_log_cntr = k.assertions_stats.log_cntr; +const float assertions_stats_max_cntr = k.assertions_stats.max_cntr; +const float assertions_stats_min_cntr = k.assertions_stats.min_cntr; +const float assertions_stats_multiplication_cntr = k.assertions_stats.multiplication_cntr; const float assertions_stats_negation_cntr = k.assertions_stats.negation_cntr; +const float assertions_stats_notequalto_cntr = k.assertions_stats.notequalto_cntr; +const float assertions_stats_pow_cntr = k.assertions_stats.pow_cntr; +const float assertions_stats_realconstant_cntr = k.assertions_stats.realconstant_cntr; +const float assertions_stats_sqrt_cntr = k.assertions_stats.sqrt_cntr; +const float assertions_stats_trigonometry_cntr = k.assertions_stats.trigonometry_cntr; +const float assertions_stats_true_cntr = k.assertions_stats.true_cntr; +const float assertions_stats_uninterpretedfunction_cntr = k.assertions_stats.uninterpretedfunction_cntr; const float assertions_stats_unique_variables = k.assertions_stats.unique_variables; -const float lemma_stats_conjunction_cntr = k.lemma_stats.conjunction_cntr; -const float biggest_literal_stats_abs_cntr = k.biggest_literal_stats.abs_cntr; -const float middle_assertion_stats_abs_cntr = k.middle_assertion_stats.abs_cntr; -const float assertions_stats_division_cntr = k.assertions_stats.division_cntr; +const float assertions_stats_variable_cntr = k.assertions_stats.variable_cntr; +const float biggest_assertion_stats_abs_cntr = k.biggest_assertion_stats.abs_cntr; +const float biggest_assertion_stats_addition_cntr = k.biggest_assertion_stats.addition_cntr; const float biggest_assertion_stats_conjunction_cntr = k.biggest_assertion_stats.conjunction_cntr; -const float middle_assertion_stats_realconstant_cntr = k.middle_assertion_stats.realconstant_cntr; -const float smallest_literal_stats_forall_cntr = k.smallest_literal_stats.forall_cntr; -const float smallest_assertion_stats_conjunction_cntr = k.smallest_assertion_stats.conjunction_cntr; -const float biggest_literal_stats_unique_variables = k.biggest_literal_stats.unique_variables; -const float smallest_assertion_stats_constant_cntr = k.smallest_assertion_stats.constant_cntr; -const float lemma_stats_ifthenelse_cntr = k.lemma_stats.ifthenelse_cntr; -const float middle_literal_stats_ifthenelse_cntr = k.middle_literal_stats.ifthenelse_cntr; -const float smallest_literal_stats_log_cntr = k.smallest_literal_stats.log_cntr; -const float smallest_literal_stats_notequalto_cntr = k.smallest_literal_stats.notequalto_cntr; -const float biggest_assertion_stats_false_cntr = k.biggest_assertion_stats.false_cntr; -const float assertions_stats_inequality_cntr = k.assertions_stats.inequality_cntr; -const float middle_literal_stats_notequalto_cntr = k.middle_literal_stats.notequalto_cntr; -const float lemma_stats_unique_variables = k.lemma_stats.unique_variables; -const float biggest_literal_stats_variable_cntr = k.biggest_literal_stats.variable_cntr; -const float middle_assertion_stats_disjunction_cntr = k.middle_assertion_stats.disjunction_cntr; -const float middle_assertion_stats_variable_cntr = k.middle_assertion_stats.variable_cntr; -const float lemma_stats_inequality_cntr = k.lemma_stats.inequality_cntr; -const float smallest_literal_stats_abs_cntr = k.smallest_literal_stats.abs_cntr; -const float lemma_stats_notequalto_cntr = k.lemma_stats.notequalto_cntr; +const float biggest_assertion_stats_constant_cntr = k.biggest_assertion_stats.constant_cntr; +const float biggest_assertion_stats_disjunction_cntr = k.biggest_assertion_stats.disjunction_cntr; +const float biggest_assertion_stats_division_cntr = k.biggest_assertion_stats.division_cntr; const float biggest_assertion_stats_equalto_cntr = k.biggest_assertion_stats.equalto_cntr; -const float assertions_stats_sqrt_cntr = k.assertions_stats.sqrt_cntr; -const float assertions_stats_uninterpretedfunction_cntr = k.assertions_stats.uninterpretedfunction_cntr; -const float smallest_assertion_stats_forall_cntr = k.smallest_assertion_stats.forall_cntr; -const float middle_assertion_stats_true_cntr = k.middle_assertion_stats.true_cntr; -const float smallest_literal_stats_addition_cntr = k.smallest_literal_stats.addition_cntr; -const float biggest_assertion_stats_max_cntr = k.biggest_assertion_stats.max_cntr; +const float biggest_assertion_stats_exp_cntr = k.biggest_assertion_stats.exp_cntr; +const float biggest_assertion_stats_false_cntr = k.biggest_assertion_stats.false_cntr; +const float biggest_assertion_stats_forall_cntr = k.biggest_assertion_stats.forall_cntr; const float biggest_assertion_stats_ifthenelse_cntr = k.biggest_assertion_stats.ifthenelse_cntr; -const float biggest_literal_stats_notequalto_cntr = k.biggest_literal_stats.notequalto_cntr; -const float biggest_literal_stats_exp_cntr = k.biggest_literal_stats.exp_cntr; -const float biggest_literal_stats_disjunction_cntr = k.biggest_literal_stats.disjunction_cntr; -const float middle_literal_stats_negation_cntr = k.middle_literal_stats.negation_cntr; -const float biggest_assertion_stats_division_cntr = k.biggest_assertion_stats.division_cntr; -const float middle_literal_stats_false_cntr = k.middle_literal_stats.false_cntr; -const float lemma_stats_uninterpretedfunction_cntr = k.lemma_stats.uninterpretedfunction_cntr; -const float biggest_literal_stats_forall_cntr = k.biggest_literal_stats.forall_cntr; +const float biggest_assertion_stats_inequality_cntr = k.biggest_assertion_stats.inequality_cntr; +const float biggest_assertion_stats_log_cntr = k.biggest_assertion_stats.log_cntr; +const float biggest_assertion_stats_max_cntr = k.biggest_assertion_stats.max_cntr; +const float biggest_assertion_stats_min_cntr = k.biggest_assertion_stats.min_cntr; +const float biggest_assertion_stats_multiplication_cntr = k.biggest_assertion_stats.multiplication_cntr; +const float biggest_assertion_stats_negation_cntr = k.biggest_assertion_stats.negation_cntr; +const float biggest_assertion_stats_notequalto_cntr = k.biggest_assertion_stats.notequalto_cntr; const float biggest_assertion_stats_pow_cntr = k.biggest_assertion_stats.pow_cntr; -const float lemma_stats_pow_cntr = k.lemma_stats.pow_cntr; -const float lemma_stats_disjunction_cntr = k.lemma_stats.disjunction_cntr; -const float middle_assertion_stats_multiplication_cntr = k.middle_assertion_stats.multiplication_cntr; -const float middle_assertion_stats_division_cntr = k.middle_assertion_stats.division_cntr; +const float biggest_assertion_stats_realconstant_cntr = k.biggest_assertion_stats.realconstant_cntr; const float biggest_assertion_stats_sqrt_cntr = k.biggest_assertion_stats.sqrt_cntr; +const float biggest_assertion_stats_trigonometry_cntr = k.biggest_assertion_stats.trigonometry_cntr; +const float biggest_assertion_stats_true_cntr = k.biggest_assertion_stats.true_cntr; +const float biggest_assertion_stats_uninterpretedfunction_cntr = k.biggest_assertion_stats.uninterpretedfunction_cntr; +const float biggest_assertion_stats_unique_variables = k.biggest_assertion_stats.unique_variables; +const float biggest_assertion_stats_variable_cntr = k.biggest_assertion_stats.variable_cntr; +const float biggest_literal_stats_abs_cntr = k.biggest_literal_stats.abs_cntr; +const float biggest_literal_stats_addition_cntr = k.biggest_literal_stats.addition_cntr; +const float biggest_literal_stats_conjunction_cntr = k.biggest_literal_stats.conjunction_cntr; +const float biggest_literal_stats_constant_cntr = k.biggest_literal_stats.constant_cntr; +const float biggest_literal_stats_disjunction_cntr = k.biggest_literal_stats.disjunction_cntr; +const float biggest_literal_stats_division_cntr = k.biggest_literal_stats.division_cntr; +const float biggest_literal_stats_equalto_cntr = k.biggest_literal_stats.equalto_cntr; +const float biggest_literal_stats_exp_cntr = k.biggest_literal_stats.exp_cntr; +const float biggest_literal_stats_false_cntr = k.biggest_literal_stats.false_cntr; +const float biggest_literal_stats_forall_cntr = k.biggest_literal_stats.forall_cntr; +const float biggest_literal_stats_ifthenelse_cntr = k.biggest_literal_stats.ifthenelse_cntr; +const float biggest_literal_stats_inequality_cntr = k.biggest_literal_stats.inequality_cntr; +const float biggest_literal_stats_log_cntr = k.biggest_literal_stats.log_cntr; +const float biggest_literal_stats_max_cntr = k.biggest_literal_stats.max_cntr; +const float biggest_literal_stats_min_cntr = k.biggest_literal_stats.min_cntr; +const float biggest_literal_stats_multiplication_cntr = k.biggest_literal_stats.multiplication_cntr; +const float biggest_literal_stats_negation_cntr = k.biggest_literal_stats.negation_cntr; +const float biggest_literal_stats_notequalto_cntr = k.biggest_literal_stats.notequalto_cntr; +const float biggest_literal_stats_pow_cntr = k.biggest_literal_stats.pow_cntr; +const float biggest_literal_stats_realconstant_cntr = k.biggest_literal_stats.realconstant_cntr; +const float biggest_literal_stats_sqrt_cntr = k.biggest_literal_stats.sqrt_cntr; +const float biggest_literal_stats_trigonometry_cntr = k.biggest_literal_stats.trigonometry_cntr; +const float biggest_literal_stats_true_cntr = k.biggest_literal_stats.true_cntr; const float biggest_literal_stats_uninterpretedfunction_cntr = k.biggest_literal_stats.uninterpretedfunction_cntr; -const float middle_literal_stats_conjunction_cntr = k.middle_literal_stats.conjunction_cntr; +const float biggest_literal_stats_unique_variables = k.biggest_literal_stats.unique_variables; +const float biggest_literal_stats_variable_cntr = k.biggest_literal_stats.variable_cntr; +const float box_boolean_count = k.box_boolean_count; +const float box_continuous_count = k.box_continuous_count; +const float box_integer_count = k.box_integer_count; +const float lemma_size = k.lemma_size; +const float lemma_stats_abs_cntr = k.lemma_stats.abs_cntr; +const float lemma_stats_addition_cntr = k.lemma_stats.addition_cntr; +const float lemma_stats_conjunction_cntr = k.lemma_stats.conjunction_cntr; +const float lemma_stats_constant_cntr = k.lemma_stats.constant_cntr; +const float lemma_stats_disjunction_cntr = k.lemma_stats.disjunction_cntr; +const float lemma_stats_division_cntr = k.lemma_stats.division_cntr; +const float lemma_stats_equalto_cntr = k.lemma_stats.equalto_cntr; +const float lemma_stats_exp_cntr = k.lemma_stats.exp_cntr; +const float lemma_stats_false_cntr = k.lemma_stats.false_cntr; +const float lemma_stats_forall_cntr = k.lemma_stats.forall_cntr; +const float lemma_stats_ifthenelse_cntr = k.lemma_stats.ifthenelse_cntr; +const float lemma_stats_inequality_cntr = k.lemma_stats.inequality_cntr; +const float lemma_stats_log_cntr = k.lemma_stats.log_cntr; +const float lemma_stats_max_cntr = k.lemma_stats.max_cntr; +const float lemma_stats_min_cntr = k.lemma_stats.min_cntr; +const float lemma_stats_multiplication_cntr = k.lemma_stats.multiplication_cntr; +const float lemma_stats_negation_cntr = k.lemma_stats.negation_cntr; +const float lemma_stats_notequalto_cntr = k.lemma_stats.notequalto_cntr; +const float lemma_stats_pow_cntr = k.lemma_stats.pow_cntr; const float lemma_stats_realconstant_cntr = k.lemma_stats.realconstant_cntr; -const float biggest_assertion_stats_exp_cntr = k.biggest_assertion_stats.exp_cntr; -const float assertions_stats_forall_cntr = k.assertions_stats.forall_cntr; const float lemma_stats_sqrt_cntr = k.lemma_stats.sqrt_cntr; -const float middle_assertion_stats_addition_cntr = k.middle_assertion_stats.addition_cntr; -const float assertions_stats_addition_cntr = k.assertions_stats.addition_cntr; -const float middle_literal_stats_constant_cntr = k.middle_literal_stats.constant_cntr; -const float assertions_stats_realconstant_cntr = k.assertions_stats.realconstant_cntr; -const float lemma_stats_false_cntr = k.lemma_stats.false_cntr; -const float smallest_assertion_stats_addition_cntr = k.smallest_assertion_stats.addition_cntr; +const float lemma_stats_trigonometry_cntr = k.lemma_stats.trigonometry_cntr; +const float lemma_stats_true_cntr = k.lemma_stats.true_cntr; +const float lemma_stats_uninterpretedfunction_cntr = k.lemma_stats.uninterpretedfunction_cntr; +const float lemma_stats_unique_variables = k.lemma_stats.unique_variables; const float lemma_stats_variable_cntr = k.lemma_stats.variable_cntr; -const float assertions_stats_disjunction_cntr = k.assertions_stats.disjunction_cntr; -const float middle_assertion_stats_negation_cntr = k.middle_assertion_stats.negation_cntr; -const float smallest_literal_stats_realconstant_cntr = k.smallest_literal_stats.realconstant_cntr; -const float assertions_stats_constant_cntr = k.assertions_stats.constant_cntr; -const float smallest_assertion_stats_max_cntr = k.smallest_assertion_stats.max_cntr; +const float middle_assertion_stats_abs_cntr = k.middle_assertion_stats.abs_cntr; +const float middle_assertion_stats_addition_cntr = k.middle_assertion_stats.addition_cntr; +const float middle_assertion_stats_conjunction_cntr = k.middle_assertion_stats.conjunction_cntr; +const float middle_assertion_stats_constant_cntr = k.middle_assertion_stats.constant_cntr; +const float middle_assertion_stats_disjunction_cntr = k.middle_assertion_stats.disjunction_cntr; +const float middle_assertion_stats_division_cntr = k.middle_assertion_stats.division_cntr; +const float middle_assertion_stats_equalto_cntr = k.middle_assertion_stats.equalto_cntr; +const float middle_assertion_stats_exp_cntr = k.middle_assertion_stats.exp_cntr; const float middle_assertion_stats_false_cntr = k.middle_assertion_stats.false_cntr; -const float middle_literal_stats_true_cntr = k.middle_literal_stats.true_cntr; -const float assertions_stats_false_cntr = k.assertions_stats.false_cntr; -const float middle_literal_stats_pow_cntr = k.middle_literal_stats.pow_cntr; -const float lemma_stats_true_cntr = k.lemma_stats.true_cntr; -const float biggest_literal_stats_division_cntr = k.biggest_literal_stats.division_cntr; +const float middle_assertion_stats_forall_cntr = k.middle_assertion_stats.forall_cntr; +const float middle_assertion_stats_ifthenelse_cntr = k.middle_assertion_stats.ifthenelse_cntr; +const float middle_assertion_stats_inequality_cntr = k.middle_assertion_stats.inequality_cntr; +const float middle_assertion_stats_log_cntr = k.middle_assertion_stats.log_cntr; const float middle_assertion_stats_max_cntr = k.middle_assertion_stats.max_cntr; -const float middle_assertion_stats_conjunction_cntr = k.middle_assertion_stats.conjunction_cntr; -const float lemma_stats_min_cntr = k.lemma_stats.min_cntr; -const float biggest_literal_stats_conjunction_cntr = k.biggest_literal_stats.conjunction_cntr; -const float biggest_assertion_stats_notequalto_cntr = k.biggest_assertion_stats.notequalto_cntr; -const float assertions_stats_trigonometry_cntr = k.assertions_stats.trigonometry_cntr; -const float biggest_assertion_stats_min_cntr = k.biggest_assertion_stats.min_cntr; -const float smallest_assertion_stats_equalto_cntr = k.smallest_assertion_stats.equalto_cntr; -const float assertions_stats_abs_cntr = k.assertions_stats.abs_cntr; -const float smallest_literal_stats_true_cntr = k.smallest_literal_stats.true_cntr; -const float biggest_assertion_stats_uninterpretedfunction_cntr = k.biggest_assertion_stats.uninterpretedfunction_cntr; -const float smallest_assertion_stats_disjunction_cntr = k.smallest_assertion_stats.disjunction_cntr; -const float smallest_assertion_stats_inequality_cntr = k.smallest_assertion_stats.inequality_cntr; -const float smallest_literal_stats_trigonometry_cntr = k.smallest_literal_stats.trigonometry_cntr; -const float smallest_assertion_stats_pow_cntr = k.smallest_assertion_stats.pow_cntr; -const float middle_literal_stats_min_cntr = k.middle_literal_stats.min_cntr; -const float smallest_assertion_stats_uninterpretedfunction_cntr = k.smallest_assertion_stats.uninterpretedfunction_cntr; -const float middle_literal_stats_inequality_cntr = k.middle_literal_stats.inequality_cntr; -const float lemma_stats_abs_cntr = k.lemma_stats.abs_cntr; -const float smallest_literal_stats_negation_cntr = k.smallest_literal_stats.negation_cntr; -const float biggest_assertion_stats_negation_cntr = k.biggest_assertion_stats.negation_cntr; -const float biggest_literal_stats_inequality_cntr = k.biggest_literal_stats.inequality_cntr; -const float smallest_literal_stats_min_cntr = k.smallest_literal_stats.min_cntr; -const float lemma_stats_exp_cntr = k.lemma_stats.exp_cntr; -const float middle_literal_stats_variable_cntr = k.middle_literal_stats.variable_cntr; -const float middle_literal_stats_exp_cntr = k.middle_literal_stats.exp_cntr; -const float smallest_literal_stats_conjunction_cntr = k.smallest_literal_stats.conjunction_cntr; -const float biggest_assertion_stats_multiplication_cntr = k.biggest_assertion_stats.multiplication_cntr; -const float assertions_stats_equalto_cntr = k.assertions_stats.equalto_cntr; -const float biggest_literal_stats_constant_cntr = k.biggest_literal_stats.constant_cntr; -const float biggest_assertion_stats_true_cntr = k.biggest_assertion_stats.true_cntr; -const float biggest_assertion_stats_trigonometry_cntr = k.biggest_assertion_stats.trigonometry_cntr; -const float smallest_assertion_stats_trigonometry_cntr = k.smallest_assertion_stats.trigonometry_cntr; -const float assertions_stats_multiplication_cntr = k.assertions_stats.multiplication_cntr; -const float LOG2P1_box_boolean_count = log2(1+k.box_boolean_count); -const float biggest_literal_stats_log_cntr = k.biggest_literal_stats.log_cntr; const float middle_assertion_stats_min_cntr = k.middle_assertion_stats.min_cntr; -const float smallest_assertion_stats_unique_variables = k.smallest_assertion_stats.unique_variables; -const float biggest_literal_stats_equalto_cntr = k.biggest_literal_stats.equalto_cntr; -const float middle_literal_stats_unique_variables = k.middle_literal_stats.unique_variables; -const float smallest_assertion_stats_false_cntr = k.smallest_assertion_stats.false_cntr; -const float biggest_literal_stats_false_cntr = k.biggest_literal_stats.false_cntr; -const float LOG2P1_assertions_size = log2(1+k.assertions_size); -const float smallest_literal_stats_uninterpretedfunction_cntr = k.smallest_literal_stats.uninterpretedfunction_cntr; -const float smallest_literal_stats_equalto_cntr = k.smallest_literal_stats.equalto_cntr; -const float smallest_assertion_stats_min_cntr = k.smallest_assertion_stats.min_cntr; -const float biggest_literal_stats_true_cntr = k.biggest_literal_stats.true_cntr; -const float middle_assertion_stats_unique_variables = k.middle_assertion_stats.unique_variables; -const float assertions_stats_log_cntr = k.assertions_stats.log_cntr; -const float assertions_stats_notequalto_cntr = k.assertions_stats.notequalto_cntr; -const float middle_literal_stats_disjunction_cntr = k.middle_literal_stats.disjunction_cntr; +const float middle_assertion_stats_multiplication_cntr = k.middle_assertion_stats.multiplication_cntr; +const float middle_assertion_stats_negation_cntr = k.middle_assertion_stats.negation_cntr; +const float middle_assertion_stats_notequalto_cntr = k.middle_assertion_stats.notequalto_cntr; +const float middle_assertion_stats_pow_cntr = k.middle_assertion_stats.pow_cntr; +const float middle_assertion_stats_realconstant_cntr = k.middle_assertion_stats.realconstant_cntr; +const float middle_assertion_stats_sqrt_cntr = k.middle_assertion_stats.sqrt_cntr; const float middle_assertion_stats_trigonometry_cntr = k.middle_assertion_stats.trigonometry_cntr; -const float smallest_assertion_stats_variable_cntr = k.smallest_assertion_stats.variable_cntr; -const float LOG2P1_theory_checksat_ms = log2(1+k.theory_checksat_ms); -const float middle_assertion_stats_ifthenelse_cntr = k.middle_assertion_stats.ifthenelse_cntr; -const float biggest_assertion_stats_forall_cntr = k.biggest_assertion_stats.forall_cntr; -const float lemma_stats_negation_cntr = k.lemma_stats.negation_cntr; -const float smallest_assertion_stats_division_cntr = k.smallest_assertion_stats.division_cntr; -const float smallest_assertion_stats_log_cntr = k.smallest_assertion_stats.log_cntr; -const float lemma_stats_log_cntr = k.lemma_stats.log_cntr; -const float LOG2P1_box_integer_count = log2(1+k.box_integer_count); -const float smallest_literal_stats_inequality_cntr = k.smallest_literal_stats.inequality_cntr; -const float lemma_size = k.lemma_size; -const float biggest_assertion_stats_log_cntr = k.biggest_assertion_stats.log_cntr; -const float biggest_literal_stats_ifthenelse_cntr = k.biggest_literal_stats.ifthenelse_cntr; -const float smallest_literal_stats_variable_cntr = k.smallest_literal_stats.variable_cntr; -const float middle_literal_stats_sqrt_cntr = k.middle_literal_stats.sqrt_cntr; -const float biggest_assertion_stats_variable_cntr = k.biggest_assertion_stats.variable_cntr; -const float biggest_literal_stats_sqrt_cntr = k.biggest_literal_stats.sqrt_cntr; +const float middle_assertion_stats_true_cntr = k.middle_assertion_stats.true_cntr; const float middle_assertion_stats_uninterpretedfunction_cntr = k.middle_assertion_stats.uninterpretedfunction_cntr; -const float assertions_stats_pow_cntr = k.assertions_stats.pow_cntr; -const float lemma_stats_addition_cntr = k.lemma_stats.addition_cntr; +const float middle_assertion_stats_unique_variables = k.middle_assertion_stats.unique_variables; +const float middle_assertion_stats_variable_cntr = k.middle_assertion_stats.variable_cntr; const float middle_literal_stats_abs_cntr = k.middle_literal_stats.abs_cntr; -const float biggest_assertion_stats_disjunction_cntr = k.biggest_assertion_stats.disjunction_cntr; +const float middle_literal_stats_addition_cntr = k.middle_literal_stats.addition_cntr; +const float middle_literal_stats_conjunction_cntr = k.middle_literal_stats.conjunction_cntr; +const float middle_literal_stats_constant_cntr = k.middle_literal_stats.constant_cntr; +const float middle_literal_stats_disjunction_cntr = k.middle_literal_stats.disjunction_cntr; +const float middle_literal_stats_division_cntr = k.middle_literal_stats.division_cntr; +const float middle_literal_stats_equalto_cntr = k.middle_literal_stats.equalto_cntr; +const float middle_literal_stats_exp_cntr = k.middle_literal_stats.exp_cntr; +const float middle_literal_stats_false_cntr = k.middle_literal_stats.false_cntr; const float middle_literal_stats_forall_cntr = k.middle_literal_stats.forall_cntr; -const float LOG2P1_lemma_size = log2(1+k.lemma_size); -const float smallest_literal_stats_division_cntr = k.smallest_literal_stats.division_cntr; -const float assertions_stats_true_cntr = k.assertions_stats.true_cntr; -const float assertions_stats_variable_cntr = k.assertions_stats.variable_cntr; -const float theory_checksat_ms = k.theory_checksat_ms; -const float box_boolean_count = k.box_boolean_count; -const float biggest_literal_stats_pow_cntr = k.biggest_literal_stats.pow_cntr; +const float middle_literal_stats_ifthenelse_cntr = k.middle_literal_stats.ifthenelse_cntr; +const float middle_literal_stats_inequality_cntr = k.middle_literal_stats.inequality_cntr; const float middle_literal_stats_log_cntr = k.middle_literal_stats.log_cntr; -const float assertions_stats_max_cntr = k.assertions_stats.max_cntr; -const float biggest_literal_stats_realconstant_cntr = k.biggest_literal_stats.realconstant_cntr; -const float smallest_literal_stats_exp_cntr = k.smallest_literal_stats.exp_cntr; -const float smallest_assertion_stats_realconstant_cntr = k.smallest_assertion_stats.realconstant_cntr; -const float smallest_assertion_stats_multiplication_cntr = k.smallest_assertion_stats.multiplication_cntr; +const float middle_literal_stats_max_cntr = k.middle_literal_stats.max_cntr; +const float middle_literal_stats_min_cntr = k.middle_literal_stats.min_cntr; +const float middle_literal_stats_multiplication_cntr = k.middle_literal_stats.multiplication_cntr; +const float middle_literal_stats_negation_cntr = k.middle_literal_stats.negation_cntr; +const float middle_literal_stats_notequalto_cntr = k.middle_literal_stats.notequalto_cntr; +const float middle_literal_stats_pow_cntr = k.middle_literal_stats.pow_cntr; +const float middle_literal_stats_realconstant_cntr = k.middle_literal_stats.realconstant_cntr; +const float middle_literal_stats_sqrt_cntr = k.middle_literal_stats.sqrt_cntr; const float middle_literal_stats_trigonometry_cntr = k.middle_literal_stats.trigonometry_cntr; -const float middle_assertion_stats_exp_cntr = k.middle_assertion_stats.exp_cntr; -const float smallest_literal_stats_max_cntr = k.smallest_literal_stats.max_cntr; -const float biggest_assertion_stats_unique_variables = k.biggest_assertion_stats.unique_variables; -const float biggest_literal_stats_multiplication_cntr = k.biggest_literal_stats.multiplication_cntr; -const float middle_assertion_stats_sqrt_cntr = k.middle_assertion_stats.sqrt_cntr; -const float LOG2P1_box_continuous_count = log2(1+k.box_continuous_count); -const float lemma_stats_constant_cntr = k.lemma_stats.constant_cntr; -const float smallest_literal_stats_multiplication_cntr = k.smallest_literal_stats.multiplication_cntr; +const float middle_literal_stats_true_cntr = k.middle_literal_stats.true_cntr; +const float middle_literal_stats_uninterpretedfunction_cntr = k.middle_literal_stats.uninterpretedfunction_cntr; +const float middle_literal_stats_unique_variables = k.middle_literal_stats.unique_variables; +const float middle_literal_stats_variable_cntr = k.middle_literal_stats.variable_cntr; +const float smallest_assertion_stats_abs_cntr = k.smallest_assertion_stats.abs_cntr; +const float smallest_assertion_stats_addition_cntr = k.smallest_assertion_stats.addition_cntr; +const float smallest_assertion_stats_conjunction_cntr = k.smallest_assertion_stats.conjunction_cntr; +const float smallest_assertion_stats_constant_cntr = k.smallest_assertion_stats.constant_cntr; +const float smallest_assertion_stats_disjunction_cntr = k.smallest_assertion_stats.disjunction_cntr; +const float smallest_assertion_stats_division_cntr = k.smallest_assertion_stats.division_cntr; +const float smallest_assertion_stats_equalto_cntr = k.smallest_assertion_stats.equalto_cntr; +const float smallest_assertion_stats_exp_cntr = k.smallest_assertion_stats.exp_cntr; +const float smallest_assertion_stats_false_cntr = k.smallest_assertion_stats.false_cntr; +const float smallest_assertion_stats_forall_cntr = k.smallest_assertion_stats.forall_cntr; const float smallest_assertion_stats_ifthenelse_cntr = k.smallest_assertion_stats.ifthenelse_cntr; -const float middle_assertion_stats_pow_cntr = k.middle_assertion_stats.pow_cntr; -const float smallest_assertion_stats_sqrt_cntr = k.smallest_assertion_stats.sqrt_cntr; +const float smallest_assertion_stats_inequality_cntr = k.smallest_assertion_stats.inequality_cntr; +const float smallest_assertion_stats_log_cntr = k.smallest_assertion_stats.log_cntr; +const float smallest_assertion_stats_max_cntr = k.smallest_assertion_stats.max_cntr; +const float smallest_assertion_stats_min_cntr = k.smallest_assertion_stats.min_cntr; +const float smallest_assertion_stats_multiplication_cntr = k.smallest_assertion_stats.multiplication_cntr; const float smallest_assertion_stats_negation_cntr = k.smallest_assertion_stats.negation_cntr; -const float middle_assertion_stats_equalto_cntr = k.middle_assertion_stats.equalto_cntr; -const float biggest_literal_stats_negation_cntr = k.biggest_literal_stats.negation_cntr; -const float biggest_literal_stats_max_cntr = k.biggest_literal_stats.max_cntr; -const float smallest_literal_stats_ifthenelse_cntr = k.smallest_literal_stats.ifthenelse_cntr; -const float biggest_literal_stats_addition_cntr = k.biggest_literal_stats.addition_cntr; -const float assertions_stats_conjunction_cntr = k.assertions_stats.conjunction_cntr; +const float smallest_assertion_stats_notequalto_cntr = k.smallest_assertion_stats.notequalto_cntr; +const float smallest_assertion_stats_pow_cntr = k.smallest_assertion_stats.pow_cntr; +const float smallest_assertion_stats_realconstant_cntr = k.smallest_assertion_stats.realconstant_cntr; +const float smallest_assertion_stats_sqrt_cntr = k.smallest_assertion_stats.sqrt_cntr; +const float smallest_assertion_stats_trigonometry_cntr = k.smallest_assertion_stats.trigonometry_cntr; const float smallest_assertion_stats_true_cntr = k.smallest_assertion_stats.true_cntr; -const float smallest_literal_stats_sqrt_cntr = k.smallest_literal_stats.sqrt_cntr; -const float biggest_assertion_stats_constant_cntr = k.biggest_assertion_stats.constant_cntr; -const float assertions_size = k.assertions_size; -const float biggest_assertion_stats_inequality_cntr = k.biggest_assertion_stats.inequality_cntr; -const float middle_literal_stats_max_cntr = k.middle_literal_stats.max_cntr; +const float smallest_assertion_stats_uninterpretedfunction_cntr = k.smallest_assertion_stats.uninterpretedfunction_cntr; +const float smallest_assertion_stats_unique_variables = k.smallest_assertion_stats.unique_variables; +const float smallest_assertion_stats_variable_cntr = k.smallest_assertion_stats.variable_cntr; +const float smallest_literal_stats_abs_cntr = k.smallest_literal_stats.abs_cntr; +const float smallest_literal_stats_addition_cntr = k.smallest_literal_stats.addition_cntr; +const float smallest_literal_stats_conjunction_cntr = k.smallest_literal_stats.conjunction_cntr; +const float smallest_literal_stats_constant_cntr = k.smallest_literal_stats.constant_cntr; const float smallest_literal_stats_disjunction_cntr = k.smallest_literal_stats.disjunction_cntr; -const float biggest_literal_stats_trigonometry_cntr = k.biggest_literal_stats.trigonometry_cntr; -const float smallest_assertion_stats_abs_cntr = k.smallest_assertion_stats.abs_cntr; -const float lemma_stats_forall_cntr = k.lemma_stats.forall_cntr; +const float smallest_literal_stats_division_cntr = k.smallest_literal_stats.division_cntr; +const float smallest_literal_stats_equalto_cntr = k.smallest_literal_stats.equalto_cntr; +const float smallest_literal_stats_exp_cntr = k.smallest_literal_stats.exp_cntr; +const float smallest_literal_stats_false_cntr = k.smallest_literal_stats.false_cntr; +const float smallest_literal_stats_forall_cntr = k.smallest_literal_stats.forall_cntr; +const float smallest_literal_stats_ifthenelse_cntr = k.smallest_literal_stats.ifthenelse_cntr; +const float smallest_literal_stats_inequality_cntr = k.smallest_literal_stats.inequality_cntr; +const float smallest_literal_stats_log_cntr = k.smallest_literal_stats.log_cntr; +const float smallest_literal_stats_max_cntr = k.smallest_literal_stats.max_cntr; +const float smallest_literal_stats_min_cntr = k.smallest_literal_stats.min_cntr; +const float smallest_literal_stats_multiplication_cntr = k.smallest_literal_stats.multiplication_cntr; +const float smallest_literal_stats_negation_cntr = k.smallest_literal_stats.negation_cntr; +const float smallest_literal_stats_notequalto_cntr = k.smallest_literal_stats.notequalto_cntr; +const float smallest_literal_stats_pow_cntr = k.smallest_literal_stats.pow_cntr; +const float smallest_literal_stats_realconstant_cntr = k.smallest_literal_stats.realconstant_cntr; +const float smallest_literal_stats_sqrt_cntr = k.smallest_literal_stats.sqrt_cntr; +const float smallest_literal_stats_trigonometry_cntr = k.smallest_literal_stats.trigonometry_cntr; +const float smallest_literal_stats_true_cntr = k.smallest_literal_stats.true_cntr; +const float smallest_literal_stats_uninterpretedfunction_cntr = k.smallest_literal_stats.uninterpretedfunction_cntr; +const float smallest_literal_stats_unique_variables = k.smallest_literal_stats.unique_variables; +const float smallest_literal_stats_variable_cntr = k.smallest_literal_stats.variable_cntr; +const float theory_checksat_ms = k.theory_checksat_ms; float x0[220]; float x1[8]; float x2[4]; float x3_result[1]; -x0[0] = 0.012060021933562159*lemma_stats_equalto_cntr - 0.13077405009633181; -x0[1] = 1.0*smallest_assertion_stats_notequalto_cntr; -x0[2] = 2.0912591059314334*smallest_literal_stats_unique_variables - 2.1616707779232285; -x0[3] = 0.11355810049368795*smallest_literal_stats_constant_cntr - 0.10184989913169329; -x0[4] = 1.0784956699158499*middle_assertion_stats_constant_cntr - 0.86756567892610137; -x0[5] = 0.8177201550461547*middle_literal_stats_realconstant_cntr - 0.47692941238456099; -x0[6] = 1.0*assertions_stats_min_cntr; -x0[7] = 0.22574457632123524*smallest_literal_stats_pow_cntr - 0.025429102002981659; -x0[8] = 2.0941748701487657*middle_literal_stats_equalto_cntr - 1.3575582013159881; -x0[9] = 0.0060158430467202326*lemma_stats_multiplication_cntr - 0.066145337728903422; -x0[10] = 0.22583392755190518*middle_literal_stats_multiplication_cntr - 0.076229900603439829; -x0[11] = 2.1822255594854378*middle_literal_stats_division_cntr - 0.028611025566566251; -x0[12] = 1.0*assertions_stats_exp_cntr; -x0[13] = 0.35521064491361387*biggest_assertion_stats_realconstant_cntr - 0.024828920951680846; -x0[14] = 0.0017334600017936373*box_continuous_count - 0.58442534836576887; -x0[15] = 1.0*middle_literal_stats_uninterpretedfunction_cntr; -x0[16] = 1.9432202120985784*box_integer_count - 1.0727661000227684; -x0[17] = 1.0*smallest_assertion_stats_exp_cntr; -x0[18] = 1.0*middle_assertion_stats_notequalto_cntr; -x0[19] = 1.0*middle_assertion_stats_log_cntr; -x0[20] = 1.0*middle_assertion_stats_forall_cntr; -x0[21] = 0.20061847213954173*middle_literal_stats_addition_cntr - 0.056870434227919743; -x0[22] = 1.2301038566497999*lemma_stats_division_cntr - 0.082070544353671684; -x0[23] = 0.17207873187544159*biggest_assertion_stats_addition_cntr - 0.60721498210663005; -x0[24] = 1.0*lemma_stats_max_cntr; -x0[25] = 1.0*smallest_literal_stats_false_cntr; -x0[26] = 1.6013170000800234*lemma_stats_trigonometry_cntr - 0.087084811253382188; -x0[27] = 2.8897480514079743*middle_assertion_stats_inequality_cntr - 0.40196417813611313; -x0[28] = 1.0*biggest_assertion_stats_abs_cntr; -x0[29] = 1.0*assertions_stats_ifthenelse_cntr; -x0[30] = 1.0*biggest_literal_stats_min_cntr; -x0[31] = 0.0018080221517174668*assertions_stats_negation_cntr - 1.3687231241606317; -x0[32] = 0.0017343103870421793*assertions_stats_unique_variables - 0.58538074892671133; -x0[33] = 0.0069435562741672532*lemma_stats_conjunction_cntr - 0.12134793808236284; -x0[34] = 113.53854005396379*biggest_literal_stats_abs_cntr - 0.008808265326141488; -x0[35] = 1.0*middle_assertion_stats_abs_cntr; -x0[36] = 0.9253024882411206*assertions_stats_division_cntr - 0.12138762665754345; -x0[37] = 1.0*biggest_assertion_stats_conjunction_cntr; -x0[38] = 2.4313917659418705*middle_assertion_stats_realconstant_cntr - 0.52438084633967419; -x0[39] = 1.0*smallest_literal_stats_forall_cntr; -x0[40] = 1.0*smallest_assertion_stats_conjunction_cntr; -x0[41] = 0.80039329263014425*biggest_literal_stats_unique_variables - 1.143463342419248; -x0[42] = 1.0948904341294901*smallest_assertion_stats_constant_cntr - 0.73040828883471565; -x0[43] = 1.0*lemma_stats_ifthenelse_cntr; -x0[44] = 1.0*middle_literal_stats_ifthenelse_cntr; -x0[45] = 1.0*smallest_literal_stats_log_cntr; -x0[46] = 1.0*smallest_literal_stats_notequalto_cntr; -x0[47] = 1.0*biggest_assertion_stats_false_cntr; -x0[48] = 0.0025642491676076151*assertions_stats_inequality_cntr - 0.51189793807800077; -x0[49] = 1.0*middle_literal_stats_notequalto_cntr; -x0[50] = 0.0071331690118607658*lemma_stats_unique_variables - 0.099029303944258809; -x0[51] = 0.13558170815879236*biggest_literal_stats_variable_cntr - 0.25090504782155415; -x0[52] = 1.0*middle_assertion_stats_disjunction_cntr; -x0[53] = 1.5084382293634835*middle_assertion_stats_variable_cntr - 2.0544718040888532; -x0[54] = 0.015500544957062002*lemma_stats_inequality_cntr - 0.10334257816291656; -x0[55] = 50.783859522963766*smallest_literal_stats_abs_cntr - 0.019698936975548396; -x0[56] = 1.0*lemma_stats_notequalto_cntr; -x0[57] = 3.5430778127515832*biggest_assertion_stats_equalto_cntr - 3.2338487561693077; -x0[58] = 1.0*assertions_stats_sqrt_cntr; -x0[59] = 1.0*assertions_stats_uninterpretedfunction_cntr; -x0[60] = 1.0*smallest_assertion_stats_forall_cntr; -x0[61] = 1.0*middle_assertion_stats_true_cntr; -x0[62] = 0.20071092487784711*smallest_literal_stats_addition_cntr - 0.055308394504741114; -x0[63] = 1.0*biggest_assertion_stats_max_cntr; -x0[64] = 1.0*biggest_assertion_stats_ifthenelse_cntr; -x0[65] = 1.0*biggest_literal_stats_notequalto_cntr; +x0[0] = 0.37771877530321563*LOG2P1_assertions_size - 3.7112883484884471; +x0[1] = 0.18421227306209151*LOG2P1_box_boolean_count - 0.73736612118951128; +x0[2] = 0.36467247081702653*LOG2P1_box_continuous_count - 2.214490285843389; +x0[3] = 1.9871975876578016*LOG2P1_box_integer_count - 1.012779622743669; +x0[4] = 0.70528450158506573*LOG2P1_lemma_size - 1.5663136897555112; +x0[5] = 0.58871281170393086*LOG2P1_theory_checksat_ms - 0.48690060312132571; +x0[6] = 0.00096372470822849647*assertions_size - 1.718519538122546; +x0[7] = 28.615217352461183*assertions_stats_abs_cntr - 0.022623976919217494; +x0[8] = 0.0014136802583617301*assertions_stats_addition_cntr - 0.79391086360450547; +x0[9] = 0.00096372447885263702*assertions_stats_conjunction_cntr - 1.7185189905623448; +x0[10] = 0.0012802935056375627*assertions_stats_constant_cntr - 1.4390970152848623; +x0[11] = 1.0*assertions_stats_disjunction_cntr; +x0[12] = 0.87410597744741314*assertions_stats_division_cntr - 0.11616631584131867; +x0[13] = 0.0010233994255783704*assertions_stats_equalto_cntr - 1.6120255568011366; +x0[14] = 1.0*assertions_stats_exp_cntr; +x0[15] = 1.0*assertions_stats_false_cntr; +x0[16] = 1.0*assertions_stats_forall_cntr; +x0[17] = 1.0*assertions_stats_ifthenelse_cntr; +x0[18] = 0.0025361863745808283*assertions_stats_inequality_cntr - 0.52762392593133101; +x0[19] = 117.95761981271237*assertions_stats_log_cntr - 0.0084782304185087587; +x0[20] = 1.0*assertions_stats_max_cntr; +x0[21] = 1.0*assertions_stats_min_cntr; +x0[22] = 0.0020301349895948911*assertions_stats_multiplication_cntr - 0.80350139739440551; +x0[23] = 0.0017962028699604385*assertions_stats_negation_cntr - 1.2888746453536402; +x0[24] = 1.0*assertions_stats_notequalto_cntr; +x0[25] = 0.041218934775899371*assertions_stats_pow_cntr - 0.62813177116735486; +x0[26] = 0.0014000326583671048*assertions_stats_realconstant_cntr - 1.0087657436576163; +x0[27] = 1.0*assertions_stats_sqrt_cntr; +x0[28] = 0.73604231188820646*assertions_stats_trigonometry_cntr - 0.069990942185588809; +x0[29] = 1.0*assertions_stats_true_cntr; +x0[30] = 1.0*assertions_stats_uninterpretedfunction_cntr; +x0[31] = 0.0016910259525192936*assertions_stats_unique_variables - 0.60267834351180793; +x0[32] = 0.00053076321034285453*assertions_stats_variable_cntr - 1.249344076420934; +x0[33] = 1.0*biggest_assertion_stats_abs_cntr; +x0[34] = 0.13113042655611967*biggest_assertion_stats_addition_cntr - 0.47619958324933132; +x0[35] = 1.0*biggest_assertion_stats_conjunction_cntr; +x0[36] = 0.06672989296864644*biggest_assertion_stats_constant_cntr - 0.33028731038545733; +x0[37] = 1.0*biggest_assertion_stats_disjunction_cntr; +x0[38] = 1.9874186465655559*biggest_assertion_stats_division_cntr - 0.0764226964646426; +x0[39] = 3.2950530271276053*biggest_assertion_stats_equalto_cntr - 2.9568559651899773; +x0[40] = 1.0*biggest_assertion_stats_exp_cntr; +x0[41] = 1.0*biggest_assertion_stats_false_cntr; +x0[42] = 1.0*biggest_assertion_stats_forall_cntr; +x0[43] = 1.0*biggest_assertion_stats_ifthenelse_cntr; +x0[44] = 3.2950530271276053*biggest_assertion_stats_inequality_cntr - 0.33819706193762811; +x0[45] = 117.95761981271237*biggest_assertion_stats_log_cntr - 0.0084782304185087587; +x0[46] = 1.0*biggest_assertion_stats_max_cntr; +x0[47] = 1.0*biggest_assertion_stats_min_cntr; +x0[48] = 0.082958029418317966*biggest_assertion_stats_multiplication_cntr - 0.38698045477454568; +x0[49] = 3.9531164657417492*biggest_assertion_stats_negation_cntr - 0.27162936399404242; +x0[50] = 1.0*biggest_assertion_stats_notequalto_cntr; +x0[51] = 0.18009925170940652*biggest_assertion_stats_pow_cntr - 0.042109025070847364; +x0[52] = 0.25334944573768703*biggest_assertion_stats_realconstant_cntr - 0.029772611498678811; +x0[53] = 1.0*biggest_assertion_stats_sqrt_cntr; +x0[54] = 1.74487648588679*biggest_assertion_stats_trigonometry_cntr - 0.026713051929410352; +x0[55] = 1.0*biggest_assertion_stats_true_cntr; +x0[56] = 1.0*biggest_assertion_stats_uninterpretedfunction_cntr; +x0[57] = 0.46388951933272993*biggest_assertion_stats_unique_variables - 2.4159064753691473; +x0[58] = 0.11083801287143255*biggest_assertion_stats_variable_cntr - 0.7338985308527981; +x0[59] = 117.95761981271234*biggest_literal_stats_abs_cntr - 0.008478230418508757; +x0[60] = 0.13020544393471256*biggest_literal_stats_addition_cntr - 0.097544120041077348; +x0[61] = 1.0*biggest_literal_stats_conjunction_cntr; +x0[62] = 0.064357853741237328*biggest_literal_stats_constant_cntr - 0.095331776594060239; +x0[63] = 1.0*biggest_literal_stats_disjunction_cntr; +x0[64] = 1.5456289779279924*biggest_literal_stats_division_cntr - 0.052657811797446157; +x0[65] = 2.2417710409364737*biggest_literal_stats_equalto_cntr - 1.6272296228288254; x0[66] = 1.0*biggest_literal_stats_exp_cntr; -x0[67] = 1.0*biggest_literal_stats_disjunction_cntr; -x0[68] = 2.654159976993224*middle_literal_stats_negation_cntr - 0.45464586727703943; -x0[69] = 2.7356197699342837*biggest_assertion_stats_division_cntr - 0.095078173539996827; -x0[70] = 1.0*middle_literal_stats_false_cntr; -x0[71] = 1.0*lemma_stats_uninterpretedfunction_cntr; -x0[72] = 1.0*biggest_literal_stats_forall_cntr; -x0[73] = 0.25624222226326016*biggest_assertion_stats_pow_cntr - 0.038625185248837436; -x0[74] = 0.12499452918035249*lemma_stats_pow_cntr - 0.11069143138818648; -x0[75] = 1.0*lemma_stats_disjunction_cntr; -x0[76] = 1.1689261602120784*middle_assertion_stats_multiplication_cntr - 0.34106526676164678; -x0[77] = 1.0*middle_assertion_stats_division_cntr; -x0[78] = 1.0*biggest_assertion_stats_sqrt_cntr; -x0[79] = 1.0*biggest_literal_stats_uninterpretedfunction_cntr; -x0[80] = 1.0*middle_literal_stats_conjunction_cntr; -x0[81] = 0.2443203750225911*lemma_stats_realconstant_cntr - 0.2661367250343058; -x0[82] = 1.0*biggest_assertion_stats_exp_cntr; -x0[83] = 1.0*assertions_stats_forall_cntr; -x0[84] = 1.0*lemma_stats_sqrt_cntr; -x0[85] = 2.1747340130869697*middle_assertion_stats_addition_cntr - 0.24041861665236089; -x0[86] = 0.0014571485659065975*assertions_stats_addition_cntr - 0.82981615138931808; -x0[87] = 0.11347593501396197*middle_literal_stats_constant_cntr - 0.098959114467955508; -x0[88] = 0.0014053437737330519*assertions_stats_realconstant_cntr - 1.0952587585298792; -x0[89] = 1.0*lemma_stats_false_cntr; -x0[90] = 1.5985510467578241*smallest_assertion_stats_addition_cntr - 0.1887505580423125; -x0[91] = 0.0022576329729095328*lemma_stats_variable_cntr - 0.086744599107285048; -x0[92] = 1.0*assertions_stats_disjunction_cntr; -x0[93] = 2.0000404701721601*middle_assertion_stats_negation_cntr - 1.0063818843705687; -x0[94] = 0.81788635256080222*smallest_literal_stats_realconstant_cntr - 0.4769628946624942; -x0[95] = 0.0013256836187079536*assertions_stats_constant_cntr - 1.5256195401983568; -x0[96] = 1.0*smallest_assertion_stats_max_cntr; -x0[97] = 1.0*middle_assertion_stats_false_cntr; -x0[98] = 1.0*middle_literal_stats_true_cntr; -x0[99] = 1.0*assertions_stats_false_cntr; -x0[100] = 0.22567669484734096*middle_literal_stats_pow_cntr - 0.028555367672305126; -x0[101] = 1.0*lemma_stats_true_cntr; -x0[102] = 1.7741310128313188*biggest_literal_stats_division_cntr - 0.053540493715390457; -x0[103] = 1.0*middle_assertion_stats_max_cntr; -x0[104] = 1.0*middle_assertion_stats_conjunction_cntr; -x0[105] = 1.0*lemma_stats_min_cntr; -x0[106] = 1.0*biggest_literal_stats_conjunction_cntr; -x0[107] = 1.0*biggest_assertion_stats_notequalto_cntr; -x0[108] = 1.3563299976310219*assertions_stats_trigonometry_cntr - 0.11406219685275623; -x0[109] = 1.0*biggest_assertion_stats_min_cntr; -x0[110] = 2.043518255782228*smallest_assertion_stats_equalto_cntr - 1.2315011490237662; -x0[111] = 34.237746428327789*assertions_stats_abs_cntr - 0.018593035298548839; -x0[112] = 1.0*smallest_literal_stats_true_cntr; -x0[113] = 1.0*biggest_assertion_stats_uninterpretedfunction_cntr; -x0[114] = 1.0*smallest_assertion_stats_disjunction_cntr; -x0[115] = 2.043518255782228*smallest_assertion_stats_inequality_cntr - 0.81201710675846184; -x0[116] = 3.8762142277239313*smallest_literal_stats_trigonometry_cntr - 0.035785065407226362; -x0[117] = 2.1255726952317442*smallest_assertion_stats_pow_cntr - 0.041884830456855163; -x0[118] = 1.0*middle_literal_stats_min_cntr; -x0[119] = 1.0*smallest_assertion_stats_uninterpretedfunction_cntr; -x0[120] = 2.0941748701487657*middle_literal_stats_inequality_cntr - 0.73661666883277765; -x0[121] = 34.237746428327789*lemma_stats_abs_cntr - 0.018593035298548839; -x0[122] = 2.1270398568572664*smallest_literal_stats_negation_cntr - 0.701477612994588; -x0[123] = 4.2960917448574234*biggest_assertion_stats_negation_cntr - 0.24696694980134606; -x0[124] = 2.3076136167747214*biggest_literal_stats_inequality_cntr - 0.57824608085200546; -x0[125] = 1.0*smallest_literal_stats_min_cntr; -x0[126] = 1.0*lemma_stats_exp_cntr; -x0[127] = 0.17824090761400588*middle_literal_stats_variable_cntr - 0.2492192302503668; -x0[128] = 1.0*middle_literal_stats_exp_cntr; -x0[129] = 1.0*smallest_literal_stats_conjunction_cntr; -x0[130] = 0.11279171999706769*biggest_assertion_stats_multiplication_cntr - 0.50845527338010954; -x0[131] = 0.0010478373585679356*assertions_stats_equalto_cntr - 1.7290093555637649; -x0[132] = 0.081392968854540143*biggest_literal_stats_constant_cntr - 0.0982272322343853; -x0[133] = 1.0*biggest_assertion_stats_true_cntr; -x0[134] = 5.2805429361484739*biggest_assertion_stats_trigonometry_cntr - 0.039737212164965244; -x0[135] = 19.473165433281935*smallest_assertion_stats_trigonometry_cntr - 0.015107188078574037; -x0[136] = 0.0020926462044186691*assertions_stats_multiplication_cntr - 0.8290502543065239; -x0[137] = 0.18680874324467026*LOG2P1_box_boolean_count - 0.69856632169121324; -x0[138] = 1.0*biggest_literal_stats_log_cntr; -x0[139] = 1.0*middle_assertion_stats_min_cntr; -x0[140] = 2.9017916017956864*smallest_assertion_stats_unique_variables - 2.929706431789687; -x0[141] = 2.307613616774721*biggest_literal_stats_equalto_cntr - 1.7293675359227159; -x0[142] = 1.8027957745963139*middle_literal_stats_unique_variables - 2.0233550404255141; -x0[143] = 1.0*smallest_assertion_stats_false_cntr; -x0[144] = 1.0*biggest_literal_stats_false_cntr; -x0[145] = 0.40207252399068183*LOG2P1_assertions_size - 4.0220936053549838; -x0[146] = 1.0*smallest_literal_stats_uninterpretedfunction_cntr; -x0[147] = 2.0232375396769844*smallest_literal_stats_equalto_cntr - 1.1644995583292124; -x0[148] = 1.0*smallest_assertion_stats_min_cntr; -x0[149] = 1.0*biggest_literal_stats_true_cntr; -x0[150] = 1.7255138236253043*middle_assertion_stats_unique_variables - 2.312509798535852; -x0[151] = 113.53854005396381*assertions_stats_log_cntr - 0.0088082653261414897; -x0[152] = 1.0*assertions_stats_notequalto_cntr; -x0[153] = 1.0*middle_literal_stats_disjunction_cntr; -x0[154] = 24.795385773122163*middle_assertion_stats_trigonometry_cntr - 0.040395896139299101; -x0[155] = 2.4887119517086012*smallest_assertion_stats_variable_cntr - 2.5369802207487218; -x0[156] = 0.6120128546931537*LOG2P1_theory_checksat_ms - 0.46818793319187496; -x0[157] = 1.0*middle_assertion_stats_ifthenelse_cntr; -x0[158] = 1.0*biggest_assertion_stats_forall_cntr; -x0[159] = 0.017639538853394594*lemma_stats_negation_cntr - 0.080831236730291578; -x0[160] = 13.768821746778553*smallest_assertion_stats_division_cntr - 0.01068178568407956; -x0[161] = 1.0*smallest_assertion_stats_log_cntr; -x0[162] = 1.0*lemma_stats_log_cntr; -x0[163] = 2.0017011220528755*LOG2P1_box_integer_count - 1.1020477768850323; -x0[164] = 2.0232375396769844*smallest_literal_stats_inequality_cntr - 0.85873798134777202; -x0[165] = 0.0069437513556026937*lemma_size - 0.12158944964901437; -x0[166] = 113.53854005396381*biggest_assertion_stats_log_cntr - 0.0088082653261414897; -x0[167] = 1.0*biggest_literal_stats_ifthenelse_cntr; -x0[168] = 0.17837794866259055*smallest_literal_stats_variable_cntr - 0.23355195031641121; -x0[169] = 1.0*middle_literal_stats_sqrt_cntr; -x0[170] = 0.14428401100058252*biggest_assertion_stats_variable_cntr - 0.94809930300700862; -x0[171] = 1.0*biggest_literal_stats_sqrt_cntr; -x0[172] = 1.0*middle_assertion_stats_uninterpretedfunction_cntr; -x0[173] = 0.042312206432987762*assertions_stats_pow_cntr - 0.60818298458376063; -x0[174] = 0.0056719421304003053*lemma_stats_addition_cntr - 0.058215071521321174; -x0[175] = 113.53854005396379*middle_literal_stats_abs_cntr - 0.008808265326141488; -x0[176] = 1.0*biggest_assertion_stats_disjunction_cntr; -x0[177] = 1.0*middle_literal_stats_forall_cntr; -x0[178] = 0.72401355669048295*LOG2P1_lemma_size - 1.5712693625351697; -x0[179] = 2.1838186991523911*smallest_literal_stats_division_cntr - 0.028293073914542229; -x0[180] = 1.0*assertions_stats_true_cntr; -x0[181] = 0.00055485511013681366*assertions_stats_variable_cntr - 1.3260489594876443; -x0[182] = 0.00047923755762088971*theory_checksat_ms - 0.041050603750268734; -x0[183] = 0.00046717948643324586*box_boolean_count - 0.56646527549706782; -x0[184] = 0.18678289239706466*biggest_literal_stats_pow_cntr - 0.028937582320941669; -x0[185] = 1.0*middle_literal_stats_log_cntr; -x0[186] = 1.0*assertions_stats_max_cntr; -x0[187] = 0.33209312111402756*biggest_literal_stats_realconstant_cntr - 0.18163355344095378; -x0[188] = 1.0*smallest_literal_stats_exp_cntr; -x0[189] = 1.7377524285899715*smallest_assertion_stats_realconstant_cntr - 0.81589431325263828; -x0[190] = 1.8510384775237294*smallest_assertion_stats_multiplication_cntr - 0.19630485638285014; -x0[191] = 3.8238820163722336*middle_literal_stats_trigonometry_cntr - 0.040641725077036152; -x0[192] = 1.0*middle_assertion_stats_exp_cntr; -x0[193] = 1.0*smallest_literal_stats_max_cntr; -x0[194] = 0.47112727137981791*biggest_assertion_stats_unique_variables - 2.5308927778662134; -x0[195] = 0.11754320648445506*biggest_literal_stats_multiplication_cntr - 0.078295265389878285; -x0[196] = 1.0*middle_assertion_stats_sqrt_cntr; -x0[197] = 0.37596563832047197*LOG2P1_box_continuous_count - 2.2589678491559266; -x0[198] = 0.0056245581232980957*lemma_stats_constant_cntr - 0.097673135366731514; -x0[199] = 0.22628710605841132*smallest_literal_stats_multiplication_cntr - 0.0662534940468925; -x0[200] = 1.0*smallest_assertion_stats_ifthenelse_cntr; -x0[201] = 4.6194934013477793*middle_assertion_stats_pow_cntr - 0.21896900451695062; -x0[202] = 1.0*smallest_assertion_stats_sqrt_cntr; -x0[203] = 2.0821013133084607*smallest_assertion_stats_negation_cntr - 1.3305095824454454; -x0[204] = 2.8897480514079743*middle_assertion_stats_equalto_cntr - 2.4877838732718613; -x0[205] = 4.1326787755776833*biggest_literal_stats_negation_cntr - 0.2580920414538429; -x0[206] = 1.0*biggest_literal_stats_max_cntr; -x0[207] = 1.0*smallest_literal_stats_ifthenelse_cntr; -x0[208] = 0.15392647098224665*biggest_literal_stats_addition_cntr - 0.094959138654059375; -x0[209] = 0.0010007277390044853*assertions_stats_conjunction_cntr - 1.8510488937317557; -x0[210] = 1.0*smallest_assertion_stats_true_cntr; -x0[211] = 1.0*smallest_literal_stats_sqrt_cntr; -x0[212] = 0.092383493135436215*biggest_assertion_stats_constant_cntr - 0.43437442734362935; -x0[213] = 0.0010007280265520134*assertions_size - 1.8510495808812195; -x0[214] = 3.5430778127515832*biggest_assertion_stats_inequality_cntr - 0.30922905658227551; -x0[215] = 1.0*middle_literal_stats_max_cntr; -x0[216] = 1.0*smallest_literal_stats_disjunction_cntr; -x0[217] = 3.2848954335701617*biggest_literal_stats_trigonometry_cntr - 0.034658322650546317; -x0[218] = 113.53854005396379*smallest_assertion_stats_abs_cntr - 0.008808265326141488; -x0[219] = 1.0*lemma_stats_forall_cntr; -x1[0] = relu(0.69722515599675816*x0[0] + 7.4258130304407669e-316*x0[1] - 0.013004996057516337*x0[2] + 0.16119898473116079*x0[3] + 0.17111355461967018*x0[4] + 0.067592103332607942*x0[5] + 3.7380792043419031e-315*x0[6] + 0.023509776025002763*x0[7] + 0.15221754833028134*x0[8] + 0.20445016213956199*x0[9] + 0.16659145941531447*x0[10] + 0.12953018352946197*x0[11] + 1.8006001664747104e-315*x0[12] + 0.14073655496056112*x0[13] + 0.1558580238299343*x0[14] - 7.4568552066707891e-304*x0[15] - 0.29177410475856747*x0[16] + 5.3575783978726722e-316*x0[17] - 1.2311787552695656e-310*x0[18] - 1.9734734692516225e-300*x0[19] + 3.9946215256428514e-314*x0[20] - 0.13006053098856374*x0[21] + 0.14769995413896575*x0[22] - 0.1630750850603922*x0[23] + 5.0153717554927963e-299*x0[24] + 2.1971739949198347e-313*x0[25] - 0.023368479948913484*x0[26] - 0.041164747752068784*x0[27] - 3.1644271681534095e-309*x0[28] - 9.8271127791251607e-316*x0[29] + 2.7125229451569316e-294*x0[30] + 0.18512559454726801*x0[31] + 0.16064932299205728*x0[32] + 0.57388140921224795*x0[33] - 0.017372520301574195*x0[34] + 5.8042784665486045e-299*x0[35] + 0.26196016555378832*x0[36] + 1.2276417037748935e-305*x0[37] - 0.056849558449800212*x0[38] - 7.0778413612731949e-292*x0[39] + 1.9643030673000898e-315*x0[40] + 0.65924896073661587*x0[41] + 0.31937351674131337*x0[42] - 3.5192241606050949e-317*x0[43] + 1.3103225835698773e-312*x0[44] - 2.2141050688777758e-315*x0[45] + 2.2491516939381426e-303*x0[46] - 7.0816177356514876e-301*x0[47] + 0.15103797925233989*x0[48] - 4.0990965784373166e-315*x0[49] + 0.52492489010212684*x0[50] + 0.23927650696410449*x0[51] + 2.5296422792422378e-310*x0[52] + 0.028712629027192207*x0[53] - 0.2375344361697832*x0[54] - 0.26624788617942302*x0[55] - 5.7182962693735768e-315*x0[56] - 0.044723061428655494*x0[57] - 6.1830531177035017e-293*x0[58] + 7.0399898100316262e-293*x0[59] - 5.9512959629510822e-315*x0[60] + 1.2414112782574945e-294*x0[61] + 0.068047429172219898*x0[62] + 1.7258373290016286e-311*x0[63] - 1.0836396389562363e-294*x0[64] - 1.5351826124594674e-316*x0[65] - 7.4994245837527376e-294*x0[66] - 1.1809502743576548e-300*x0[67] - 0.068801329690522342*x0[68] + 0.052770257648257303*x0[69] + 1.1457436741742238e-310*x0[70] - 4.56084836064003e-297*x0[71] - 1.6556208626813975e-301*x0[72] + 0.1757794900750366*x0[73] + 0.55203784126626843*x0[74] - 3.393285790618427e-302*x0[75] + 0.49087123305203456*x0[76] - 9.5869667785670187e-295*x0[77] - 2.0706583704068981e-316*x0[78] - 1.7865982917243484e-316*x0[79] + 1.957898909061027e-291*x0[80] + 0.034224391212281706*x0[81] - 2.7124074890955309e-310*x0[82] - 8.8665176119003892e-298*x0[83] - 1.0930865845322962e-295*x0[84] - 0.011611902071943011*x0[85] + 0.21276406371955056*x0[86] - 0.046876552984425779*x0[87] - 0.27382164881483329*x0[88] - 7.9039096346968264e-316*x0[89] + 0.38924739387862994*x0[90] + 0.32124213310515021*x0[91] + 1.2467668461025249e-315*x0[92] + 0.14082962089324677*x0[93] + 0.23503997489633549*x0[94] - 0.21063216486986247*x0[95] - 6.8489169738404794e-313*x0[96] - 1.4318928498449223e-305*x0[97] - 3.5673543359587292e-303*x0[98] - 6.5266282781659443e-316*x0[99] + 0.28114551068291338*x0[100] - 2.2600394043314621e-315*x0[101] + 0.057544401505819014*x0[102] - 1.79495619768813e-315*x0[103] - 5.1001340126008118e-300*x0[104] + 7.2495003913079863e-291*x0[105] - 1.5902438818766566e-315*x0[106] + 1.3690114499345883e-293*x0[107] + 0.075089598177098288*x0[108] + 2.78850247132903e-313*x0[109] - 0.04679987500421199*x0[110] - 0.26129900332789546*x0[111] + 2.6185989938132592e-310*x0[112] + 2.092430455094657e-315*x0[113] + 6.2126108353685111e-315*x0[114] + 0.079084758312359157*x0[115] + 0.13815237964890761*x0[116] + 0.25717554431996764*x0[117] - 4.4297874206431973e-304*x0[118] + 5.0264693290475013e-302*x0[119] - 0.3585864190868458*x0[120] - 0.11303912961498307*x0[121] + 0.025656318684385487*x0[122] - 0.042176241711434831*x0[123] + 0.058390538366545536*x0[124] - 1.1265596247835723e-302*x0[125] - 4.9572427191756153e-307*x0[126] - 0.10295293804430956*x0[127] + 8.4386004108186635e-294*x0[128] - 1.226938186318174e-305*x0[129] - 0.14246321510051124*x0[130] - 0.062219415689560784*x0[131] + 0.17343899942134239*x0[132] + 2.1743009467973374e-315*x0[133] - 0.049045767530342309*x0[134] + 0.072485997284349971*x0[135] + 0.10554528722054038*x0[136] + 0.13906972368345522*x0[137] + 2.8972233028691631e-290*x0[138] + 1.087695529983541e-306*x0[139] + 0.032759930896729038*x0[140] - 0.17358613683444757*x0[141] + 0.37641626060699063*x0[142] - 1.2281546967584665e-308*x0[143] + 1.40323409088604e-310*x0[144] + 0.25554422176444086*x0[145] - 1.8040972568671866e-290*x0[146] + 0.24100858694328889*x0[147] - 9.4962713589558044e-298*x0[148] + 1.0404208500004574e-312*x0[149] + 0.20571724578670025*x0[150] - 0.20131571278957816*x0[151] - 7.1999152942670498e-296*x0[152] + 7.8393393061236714e-316*x0[153] - 0.22774987052120615*x0[154] + 0.095739270660818679*x0[155] - 0.60156864187736681*x0[156] + 7.3284128101546478e-304*x0[157] + 5.9604168417430698e-291*x0[158] - 0.29482838533669514*x0[159] + 0.004985992059779322*x0[160] - 2.4539459963266822e-292*x0[161] - 9.7409933825442511e-302*x0[162] - 0.064044367789539702*x0[163] - 0.13481068611791625*x0[164] + 0.37041495618324988*x0[165] - 0.081956890361633603*x0[166] + 1.1370700303127477e-303*x0[167] - 0.0018319900388832639*x0[168] + 2.5693389352262539e-316*x0[169] - 0.013768589878768823*x0[170] + 9.7522794458912587e-303*x0[171] + 4.2105960881079674e-315*x0[172] - 0.018122288160148461*x0[173] - 0.14592361871444004*x0[174] - 0.2343523889624021*x0[175] + 6.0245735414248802e-316*x0[176] + 8.8966829901884493e-293*x0[177] + 1.0037408707878128*x0[178] + 9.2360255380799099e-5*x0[179] + 6.1059703276866036e-292*x0[180] + 0.12995302692079069*x0[181] - 0.29813758308694072*x0[182] + 0.44672427808738369*x0[183] + 0.25296527223291809*x0[184] + 6.22541250807761e-303*x0[185] - 2.0695000680848185e-315*x0[186] - 0.0018602728284304172*x0[187] + 4.139865719418525e-316*x0[188] + 0.090597186842315061*x0[189] - 0.018271261731276033*x0[190] + 0.21253650765601187*x0[191] - 1.041326964712663e-303*x0[192] - 3.6547860573760376e-293*x0[193] - 0.26644182488039375*x0[194] + 0.11363345276207512*x0[195] + 5.4282857974502395e-315*x0[196] - 0.047850342409283347*x0[197] + 0.37271321188217438*x0[198] + 0.049208282218349164*x0[199] - 6.6784019473983824e-305*x0[200] - 0.15617896203945889*x0[201] + 2.2300800144761096e-290*x0[202] + 0.13758288253363865*x0[203] + 0.038022547543690187*x0[204] + 0.13305839495482166*x0[205] - 8.271097632223156e-305*x0[206] - 4.286996299801863e-315*x0[207] + 0.072026313277703036*x0[208] + 0.017861024030143786*x0[209] + 1.0613866888320882e-312*x0[210] - 2.0223948662196788e-315*x0[211] - 0.31987796762783011*x0[212] - 0.12110255085441921*x0[213] - 0.022665932635410196*x0[214] - 4.3399403329487182e-300*x0[215] + 1.0560620844719169e-302*x0[216] + 0.056532698885382066*x0[217] - 0.15713833463597332*x0[218] + 6.5994250004956283e-291*x0[219] + 0.12205422900729977); -x1[1] = relu(0.13188903818913203*x0[0] - 4.1766158879268582e-310*x0[1] + 0.047365417074651021*x0[2] + 0.13131424304773226*x0[3] - 0.11314384158972304*x0[4] - 0.09857774788530789*x0[5] - 1.1321515059370275e-302*x0[6] - 0.063691896677178034*x0[7] + 0.10694749712140737*x0[8] - 0.0077213625888383191*x0[9] + 0.026145518191593369*x0[10] - 0.0072636694082904912*x0[11] + 4.0890961907591875e-315*x0[12] - 0.28541937796618361*x0[13] + 0.071378076871395787*x0[14] + 8.8747542970547235e-298*x0[15] + 0.10419981196040423*x0[16] + 2.1374772094065107e-310*x0[17] + 2.8936131307677879e-293*x0[18] - 7.3927445744792727e-316*x0[19] - 4.1277699183096172e-314*x0[20] - 0.03521222658253971*x0[21] - 0.034034876816773474*x0[22] + 0.048689962559718636*x0[23] - 4.9971629938542174e-314*x0[24] - 3.9653003469008237e-296*x0[25] - 0.092971176107231698*x0[26] + 0.07774574958848679*x0[27] + 2.5602810805506524e-307*x0[28] + 2.0866896593228046e-315*x0[29] - 3.1014887507359946e-293*x0[30] + 0.11224318781162088*x0[31] + 0.035706429819991586*x0[32] + 0.056678390746622891*x0[33] + 0.15576054912789808*x0[34] - 3.6748221617903044e-312*x0[35] + 0.014540068520243525*x0[36] + 7.8079683557152564e-305*x0[37] + 0.68577929000428872*x0[38] - 4.6897521666516918e-293*x0[39] + 2.20313573849424e-311*x0[40] - 0.11098302813272121*x0[41] + 0.13078489883554167*x0[42] + 1.9077228128173876e-315*x0[43] - 2.7084777310115989e-301*x0[44] + 2.6867959964572087e-313*x0[45] + 7.7943241709830317e-295*x0[46] - 1.3707328078675466e-292*x0[47] + 0.084260496986270084*x0[48] - 3.5497432049868978e-306*x0[49] + 0.10920060858602389*x0[50] - 0.27857369531073323*x0[51] + 1.1967195477484896e-311*x0[52] - 0.051307335550402608*x0[53] - 0.1408940975323324*x0[54] + 0.16998158331306684*x0[55] - 5.0892944200407966e-296*x0[56] - 0.01808052112065869*x0[57] - 7.1336079831471368e-315*x0[58] + 1.6040239645699751e-298*x0[59] + 2.5456241667171692e-311*x0[60] + 7.7723447256915074e-299*x0[61] - 0.11894645355033386*x0[62] - 2.7176276491347895e-301*x0[63] - 5.6045915030490587e-300*x0[64] - 5.7195051491958211e-316*x0[65] - 1.5278733536714545e-300*x0[66] - 5.4588253196865909e-307*x0[67] - 0.043107574128245792*x0[68] - 0.046787961930795617*x0[69] - 2.2860219360067425e-305*x0[70] + 9.2358300642618408e-313*x0[71] - 1.4130162301470954e-295*x0[72] - 0.081023492428876603*x0[73] - 0.057904729039643464*x0[74] + 6.2365388768781412e-310*x0[75] + 0.10977260463313593*x0[76] + 1.0006643938956263e-309*x0[77] + 2.5131602162930428e-314*x0[78] - 3.7311549039593768e-316*x0[79] - 1.5253393561920826e-311*x0[80] + 0.46532655660967776*x0[81] + 3.5361781936947851e-314*x0[82] + 1.1458882613981187e-300*x0[83] + 2.7838869962800363e-315*x0[84] + 0.18654021369091828*x0[85] + 0.0739793684375563*x0[86] + 0.032488508355859778*x0[87] + 0.34149839210168353*x0[88] - 1.5384704711128472e-315*x0[89] + 0.14179637473893111*x0[90] - 0.13509970676322205*x0[91] + 9.9858052600376213e-303*x0[92] - 0.12173515331136096*x0[93] - 0.13960503238956892*x0[94] + 0.050918789700772411*x0[95] - 1.8401390452208834e-302*x0[96] - 8.7186277519807703e-310*x0[97] - 1.1621806931907162e-296*x0[98] + 1.7614515212866096e-315*x0[99] - 0.10479405035625809*x0[100] + 4.2772119544977707e-299*x0[101] - 0.091113760467844945*x0[102] + 1.1049383731956345e-295*x0[103] + 4.1940631543866977e-302*x0[104] + 3.7009367084597761e-312*x0[105] + 3.3346644564041597e-316*x0[106] - 1.0826566474400268e-315*x0[107] + 0.0062152519121483575*x0[108] + 3.3961592609165482e-315*x0[109] + 0.14490280995104451*x0[110] - 0.057646709134404811*x0[111] + 9.1132913553210959e-298*x0[112] + 3.6024683160087478e-298*x0[113] + 1.588440789302159e-315*x0[114] - 0.093944990852156698*x0[115] - 0.071445093461574488*x0[116] + 0.15217144512393815*x0[117] + 4.8258595087332005e-291*x0[118] + 1.7946903252312902e-296*x0[119] - 0.060387349722643965*x0[120] + 0.015182330288086262*x0[121] - 0.24786137873274192*x0[122] - 0.0054395481161765057*x0[123] + 0.0064010914686194378*x0[124] - 1.6320776799774319e-316*x0[125] - 6.6005845200328392e-316*x0[126] - 0.011465852257561485*x0[127] - 2.665050666115864e-315*x0[128] - 2.0783054137349389e-299*x0[129] + 0.13485341716046639*x0[130] + 0.03860151892019232*x0[131] - 0.42571693799756072*x0[132] - 3.4001242628835975e-308*x0[133] - 0.092526980349317625*x0[134] - 0.050005322689762759*x0[135] - 0.15084224640780608*x0[136] - 0.09471600736856163*x0[137] + 5.6149226046074698e-302*x0[138] - 1.7306934249795111e-315*x0[139] + 0.1492692680160998*x0[140] - 0.054127052996083121*x0[141] + 0.020355632105904353*x0[142] + 1.8781253707302802e-299*x0[143] + 3.3376020477791789e-311*x0[144] - 0.082504762020360611*x0[145] + 2.8146590185935598e-310*x0[146] - 0.0019869137412539257*x0[147] - 3.208640829096398e-295*x0[148] - 1.0199721427337656e-316*x0[149] - 0.21512559170752391*x0[150] + 0.11852093815002847*x0[151] + 3.5506435206052254e-311*x0[152] + 2.2493912931331756e-314*x0[153] - 0.12723587076360929*x0[154] + 0.10537441385801902*x0[155] - 1.6310471162947606*x0[156] + 3.4960501893505437e-315*x0[157] + 2.6498321575017871e-295*x0[158] - 0.16654701878311046*x0[159] + 0.05209510294022509*x0[160] - 1.2105811000722141e-295*x0[161] - 8.0484720466206567e-298*x0[162] + 0.24596219149432563*x0[163] - 0.022245793912551357*x0[164] - 0.11160737748953074*x0[165] - 0.035003032335390975*x0[166] + 3.3929211443334048e-311*x0[167] - 0.015235671965961798*x0[168] - 1.6485599047271477e-310*x0[169] - 0.028187419983455784*x0[170] + 3.1126345068715092e-306*x0[171] - 1.6897684458122915e-315*x0[172] - 0.076835783133370403*x0[173] - 0.057949656677018513*x0[174] - 0.079291824679221606*x0[175] - 1.2543519645891605e-299*x0[176] - 1.5426459976035344e-299*x0[177] + 0.024256621434399942*x0[178] + 0.03704141292799773*x0[179] + 8.2221150558574622e-297*x0[180] + 0.11012856247939676*x0[181] + 0.056741691440239508*x0[182] - 0.14700962678920115*x0[183] + 0.0079436122529228468*x0[184] - 2.09905805119182e-299*x0[185] - 6.3044666704504048e-316*x0[186] + 0.74734837408757882*x0[187] - 4.0900031816498534e-316*x0[188] - 0.13058327400665767*x0[189] + 0.39719627136275487*x0[190] - 0.0035161590048638177*x0[191] + 3.8229472923172832e-311*x0[192] + 1.3537276266583116e-315*x0[193] + 0.24667437999904679*x0[194] - 0.24395192066407112*x0[195] - 2.9413417601438184e-315*x0[196] + 0.082182957938739351*x0[197] - 0.21655416700037342*x0[198] - 0.088405433052956825*x0[199] - 4.3305760647445362e-312*x0[200] + 0.0028546265146047853*x0[201] + 3.6114357344291392e-312*x0[202] - 0.23937862194584048*x0[203] + 0.093963457271977996*x0[204] + 0.020135552370165295*x0[205] - 4.8205950260232526e-310*x0[206] + 4.4439965210674443e-311*x0[207] - 0.014897294509042517*x0[208] + 0.20624494143342201*x0[209] + 5.1216079656969837e-292*x0[210] - 1.40745364896784e-306*x0[211] - 0.10043860125361821*x0[212] - 0.014229872158952181*x0[213] - 0.0045250991291347657*x0[214] - 1.8726307876428225e-299*x0[215] + 2.4371810735280124e-315*x0[216] - 0.088435901945379758*x0[217] + 0.019607968060725973*x0[218] + 1.7931544446692049e-306*x0[219] + 0.14658031699384014); -x1[2] = relu(0.56676726022035162*x0[0] + 1.5195987676909284e-291*x0[1] - 0.50703017830251551*x0[2] + 0.39129155332608501*x0[3] + 0.028266196624322511*x0[4] - 0.16596761592554793*x0[5] + 5.722778128614084e-292*x0[6] + 0.16081201790576*x0[7] - 0.00044953974716607537*x0[8] + 0.42218934421275134*x0[9] + 0.18160349035808665*x0[10] - 0.14894003718089927*x0[11] - 7.1774247723062513e-292*x0[12] - 0.11357503481784909*x0[13] + 0.04054993539318677*x0[14] - 3.9492262501033565e-311*x0[15] - 0.067398755318403406*x0[16] + 4.6835721411692416e-314*x0[17] - 3.420624349220094e-315*x0[18] - 7.1704463541513338e-291*x0[19] - 5.4054662333172884e-314*x0[20] - 0.15027911197878974*x0[21] + 0.3815104485542356*x0[22] + 0.13885657889464656*x0[23] - 3.1361422960406976e-312*x0[24] - 2.5626142840377193e-301*x0[25] + 0.27379531438297905*x0[26] + 0.065159476153904008*x0[27] + 8.2622900123440444e-292*x0[28] + 2.2243823793901135e-303*x0[29] + 2.4093853825921663e-296*x0[30] - 0.016093797578588542*x0[31] + 0.02217376683509489*x0[32] + 0.43517869712994045*x0[33] - 0.051507892642627819*x0[34] - 6.5611844942441344e-315*x0[35] - 0.070171526868440012*x0[36] + 3.4564001663450432e-315*x0[37] - 0.05312994113207746*x0[38] + 2.5047129798870712e-301*x0[39] + 2.5664068912776179e-312*x0[40] + 0.043153578626596599*x0[41] + 0.09425002261822657*x0[42] - 5.9111748063566922e-314*x0[43] + 5.6615906609404247e-295*x0[44] + 7.1014632323171074e-316*x0[45] - 6.4405941975992443e-298*x0[46] + 1.104337530137812e-302*x0[47] - 0.24039656530010015*x0[48] - 1.7343554216613101e-312*x0[49] + 0.45909181355491835*x0[50] + 0.081195666655328833*x0[51] - 1.2655843993622565e-311*x0[52] + 0.092945392887204381*x0[53] - 0.066599001477281858*x0[54] + 0.024762336770923668*x0[55] - 1.2442429141225486e-305*x0[56] - 0.23933878089901853*x0[57] + 3.6268176216844801e-311*x0[58] + 1.6116358275158488e-315*x0[59] - 3.3318264741652572e-315*x0[60] - 2.4415707578594957e-315*x0[61] - 0.04249708232857035*x0[62] - 9.1412459540075776e-297*x0[63] + 4.2156764051231945e-293*x0[64] + 6.1086785803086228e-292*x0[65] + 8.9433060851216973e-303*x0[66] - 2.0084367360415996e-315*x0[67] + 0.065674987172501212*x0[68] + 0.23666004829443896*x0[69] - 1.2229840876411486e-300*x0[70] - 1.7840540463338679e-315*x0[71] + 2.919261082053667e-315*x0[72] + 0.84682825602349221*x0[73] + 0.70575419391184357*x0[74] + 3.5912846240884066e-302*x0[75] + 0.064510876768065814*x0[76] - 1.7407356247859508e-303*x0[77] + 1.3305847420141967e-315*x0[78] - 3.8414996309637649e-298*x0[79] - 1.2580525924301655e-304*x0[80] - 0.17028998088444211*x0[81] + 1.9732770626994503e-313*x0[82] - 3.6838407389730286e-307*x0[83] - 4.313476345910156e-315*x0[84] - 0.11109191966911952*x0[85] + 0.018824357692983181*x0[86] + 0.17495345171971152*x0[87] - 0.10987115892866536*x0[88] + 8.0378408123741892e-313*x0[89] - 0.0066554808451750368*x0[90] + 0.25044024828315187*x0[91] - 3.0634396103217906e-316*x0[92] + 0.012404920555427615*x0[93] - 0.13728379427662377*x0[94] - 0.20508077770952399*x0[95] - 1.8087504213143985e-299*x0[96] - 1.5540267443906421e-310*x0[97] + 1.4853368729227545e-315*x0[98] + 3.8964307993603727e-291*x0[99] + 0.35524322088623633*x0[100] - 6.7253525528393477e-291*x0[101] - 0.023788451587746683*x0[102] + 1.0749830821381533e-312*x0[103] + 2.4989925988226674e-315*x0[104] + 2.5465751001268105e-302*x0[105] + 1.1014274711318193e-294*x0[106] + 2.1295890631491867e-315*x0[107] - 0.20540001446014403*x0[108] - 7.1303168500008709e-292*x0[109] - 0.012470781837617829*x0[110] + 0.13172983248533174*x0[111] + 7.2178884525927568e-291*x0[112] + 7.706338521991377e-303*x0[113] - 5.5200656699390851e-316*x0[114] - 0.01533995631419712*x0[115] - 0.095976343998114999*x0[116] + 0.62967681782731222*x0[117] - 2.2811789528587539e-300*x0[118] - 2.733187536010592e-315*x0[119] - 0.19863090138456513*x0[120] + 0.11284848454706177*x0[121] - 0.056486003613272627*x0[122] - 0.11381696554325728*x0[123] - 0.070720974846582865*x0[124] - 1.3314475659524725e-299*x0[125] + 3.7047472738160238e-305*x0[126] + 0.19200930137510253*x0[127] + 3.9565261919575645e-300*x0[128] - 1.0013754400882037e-295*x0[129] - 0.038915321551300945*x0[130] + 0.043740078791025629*x0[131] + 0.17938394097421834*x0[132] + 3.0017667461395827e-306*x0[133] + 0.34575009070195195*x0[134] - 0.082330216955655816*x0[135] + 0.28958416035891382*x0[136] + 0.16203695121056078*x0[137] + 1.7406949885338774e-315*x0[138] - 3.5500963959576956e-316*x0[139] + 0.055782156841501132*x0[140] + 0.098096670288083998*x0[141] + 0.01068058722046897*x0[142] - 3.8009850077794398e-305*x0[143] - 4.9190972122642785e-316*x0[144] - 0.28507138287106581*x0[145] + 9.2467851489694867e-316*x0[146] + 0.24310023414980333*x0[147] - 5.4371092908709795e-311*x0[148] + 3.5210934640593288e-293*x0[149] - 0.10966184932587805*x0[150] + 0.05243879780005628*x0[151] - 9.8380160461784643e-313*x0[152] + 5.4054867083857833e-316*x0[153] + 0.11488270828040921*x0[154] + 0.19984465094535356*x0[155] - 2.6439446885174891*x0[156] + 9.0790790289609173e-295*x0[157] + 1.1375182945736703e-315*x0[158] - 0.073452459754715677*x0[159] - 0.036588849962578156*x0[160] + 1.412895125064652e-315*x0[161] - 4.5286494360727197e-314*x0[162] + 0.019728562304634694*x0[163] - 0.17389700488482077*x0[164] + 0.49159192054574141*x0[165] + 0.093955986407026196*x0[166] + 3.007046519709186e-295*x0[167] - 0.062346818150180193*x0[168] + 1.0381999437572967e-315*x0[169] + 0.049302153067670614*x0[170] + 7.5926114109949815e-292*x0[171] - 1.4819576817387436e-313*x0[172] + 0.014981020965614876*x0[173] + 0.14233111124588563*x0[174] - 0.20110142557468616*x0[175] - 4.3368632873272777e-304*x0[176] - 3.6542178701786489e-315*x0[177] + 0.0062893752867007099*x0[178] - 0.15181536058146655*x0[179] - 1.2624501839158661e-311*x0[180] - 0.025434463249188372*x0[181] - 0.18379616651021669*x0[182] + 0.34479249804990736*x0[183] + 0.31536076543694502*x0[184] + 2.6699238233257416e-315*x0[185] + 3.1127446948033079e-306*x0[186] - 0.098272010788282099*x0[187] - 1.0943762748712414e-315*x0[188] - 0.13712724137188886*x0[189] + 0.037283853398585809*x0[190] + 0.068492992952496098*x0[191] - 2.7127767126337722e-303*x0[192] - 1.8528148997133443e-303*x0[193] - 0.34353294745180513*x0[194] + 0.26182853191800826*x0[195] + 1.0052871530588377e-315*x0[196] - 0.049351723597124461*x0[197] + 0.37945083063656004*x0[198] + 0.36072482502823849*x0[199] - 1.5824232394200448e-305*x0[200] + 0.015221474740180787*x0[201] - 3.6359854348193598e-315*x0[202] - 0.11529369028257372*x0[203] + 0.12193877251519732*x0[204] + 0.088710738298767258*x0[205] - 6.3106647805016904e-294*x0[206] + 1.2887923416738865e-315*x0[207] + 0.0032110400170396718*x0[208] - 0.047199073582661469*x0[209] + 1.6072346639149304e-313*x0[210] + 5.3444334590759866e-302*x0[211] + 0.16830269235550019*x0[212] - 0.095592099807365744*x0[213] - 0.047813530238305736*x0[214] - 8.9424891718664719e-311*x0[215] + 7.443383621631767e-311*x0[216] + 0.14023837300027631*x0[217] - 0.20661000999659626*x0[218] + 4.3888939459809299e-292*x0[219] - 0.073001075177664979); -x1[3] = relu(-0.3301773625163486*x0[0] + 6.1034431169823794e-292*x0[1] + 0.30941380248218514*x0[2] - 0.22621523483708914*x0[3] + 0.67917197564864307*x0[4] - 0.047611996543197699*x0[5] + 8.0093024232296984e-306*x0[6] - 0.47273288335334873*x0[7] - 0.21566515671585781*x0[8] + 0.014257971839646819*x0[9] - 0.20506173713074841*x0[10] + 0.15013217108481167*x0[11] - 2.7895737874361374e-298*x0[12] + 0.13828015908826405*x0[13] + 0.18324737692054305*x0[14] - 5.3958985724861787e-299*x0[15] - 0.13369831240955127*x0[16] + 7.8708251919619201e-292*x0[17] - 1.251020642618776e-315*x0[18] + 1.2745473108489786e-306*x0[19] - 1.8388052055671319e-315*x0[20] + 0.3459705766982118*x0[21] - 0.06603956998284298*x0[22] + 0.11303340413254331*x0[23] + 7.307525125099867e-313*x0[24] + 8.2765744886787041e-298*x0[25] + 0.088661234807330458*x0[26] + 0.081528707676250381*x0[27] + 1.6404976455269876e-315*x0[28] - 9.1613946271413103e-310*x0[29] + 9.9309094200059427e-315*x0[30] - 0.087635238570021659*x0[31] - 0.061248833036351459*x0[32] - 0.11206964269282155*x0[33] - 0.030524334531878181*x0[34] + 8.0681776449296848e-297*x0[35] - 0.16700416408740812*x0[36] - 2.1139639466395169e-296*x0[37] - 0.038666465048678933*x0[38] + 3.9670612568259305e-311*x0[39] + 1.6486584393580824e-310*x0[40] - 0.12929808197496587*x0[41] - 0.16345622862538781*x0[42] + 4.1004346181313918e-293*x0[43] + 2.3869080102407646e-313*x0[44] + 3.7514026923759298e-315*x0[45] + 3.7787267779556256e-291*x0[46] - 2.7174657805829064e-310*x0[47] + 0.43319682049168501*x0[48] - 8.0001864256060127e-295*x0[49] - 0.18226624717815809*x0[50] + 0.070184410905144781*x0[51] + 5.5916617800485828e-307*x0[52] - 0.086021480595807193*x0[53] + 0.32228238238475437*x0[54] - 0.094757384830887387*x0[55] - 3.8960011912649879e-315*x0[56] + 0.19879447460150385*x0[57] - 1.342527211095991e-299*x0[58] + 1.3189803437405145e-290*x0[59] + 5.9055482904390511e-315*x0[60] - 1.6370663102100555e-316*x0[61] + 0.44604865773079877*x0[62] - 3.1332327255753811e-302*x0[63] - 8.0853139430986465e-292*x0[64] - 1.2913331945611559e-301*x0[65] + 6.4616626974698827e-290*x0[66] + 1.6725211395467563e-299*x0[67] - 0.22973740566975842*x0[68] + 0.2424113772866367*x0[69] + 7.0864009650824734e-291*x0[70] - 8.3794589441378167e-305*x0[71] + 9.4754477505416538e-308*x0[72] - 0.96098550537479732*x0[73] - 0.61003854813697356*x0[74] + 7.8110234742263784e-297*x0[75] + 0.37724384209531808*x0[76] + 2.8209142332668326e-307*x0[77] + 1.9614958829366871e-307*x0[78] + 2.2112529662427151e-315*x0[79] + 1.2659787118824774e-311*x0[80] + 0.068129902806637763*x0[81] - 6.853708233641958e-316*x0[82] - 2.1085865844757618e-301*x0[83] - 4.4143662133029095e-291*x0[84] + 0.48465302178233965*x0[85] - 0.092514218651382013*x0[86] - 0.27179233523753832*x0[87] + 0.053793192907162557*x0[88] - 5.8332677060510688e-295*x0[89] - 0.088370211465489415*x0[90] - 0.057042841253399756*x0[91] - 3.7517642545562129e-315*x0[92] + 0.01547522979260498*x0[93] - 0.08570584943740249*x0[94] + 0.21175251806027184*x0[95] - 1.0357623603277429e-300*x0[96] + 1.7024293268456127e-313*x0[97] + 1.6601689779105989e-315*x0[98] - 1.5524907715601424e-299*x0[99] - 0.28037663017974351*x0[100] + 2.3502864851945779e-301*x0[101] + 0.021529601868563897*x0[102] + 1.073975549328277e-312*x0[103] - 1.6444947650589112e-315*x0[104] - 8.4341096143202698e-293*x0[105] + 4.6308865326241674e-307*x0[106] + 1.1346926560314449e-294*x0[107] - 0.39241279892106856*x0[108] + 4.7752583873982623e-301*x0[109] - 0.0067511250766370276*x0[110] + 0.063704433828372292*x0[111] - 1.8982932245560725e-296*x0[112] - 8.9303249889990914e-313*x0[113] - 3.0946039669281514e-315*x0[114] - 0.024390512721123966*x0[115] + 0.090473733849815899*x0[116] - 0.65620212688993018*x0[117] + 2.9027264688246884e-298*x0[118] - 1.2104011541216929e-315*x0[119] + 0.27776497769152642*x0[120] + 0.089657438817019472*x0[121] + 0.096081950374108591*x0[122] + 0.0055041255486634232*x0[123] + 0.0062965311757509895*x0[124] + 1.3141673464265164e-308*x0[125] - 6.8034518044035908e-291*x0[126] + 0.073076208759424055*x0[127] - 6.3477475517306291e-301*x0[128] + 6.0146064818119765e-311*x0[129] + 0.10059668783865254*x0[130] - 0.094983121329170708*x0[131] + 0.11248265589408005*x0[132] - 2.6873220934572261e-299*x0[133] - 0.062825728688899324*x0[134] + 0.10391634667900121*x0[135] - 0.26819469252947192*x0[136] - 0.063385155651598107*x0[137] - 1.451511097425571e-306*x0[138] - 1.6994467520958967e-315*x0[139] + 0.061050485039482863*x0[140] - 0.14008354754921798*x0[141] + 0.21252111580940206*x0[142] + 1.1099287407927574e-312*x0[143] + 5.4182313771491149e-307*x0[144] + 0.36111704149021484*x0[145] - 3.1643293275956642e-291*x0[146] - 0.19291032911576567*x0[147] + 1.0187043302554989e-294*x0[148] - 1.6404472970444403e-299*x0[149] - 0.17647056147813533*x0[150] - 0.061562796283219562*x0[151] - 1.8691012931018131e-309*x0[152] - 4.0387035437901648e-310*x0[153] - 0.018206945089238754*x0[154] + 0.06131843200625408*x0[155] + 0.090328501692888169*x0[156] + 3.8755326246739342e-315*x0[157] + 1.3210934395775424e-315*x0[158] + 0.082967002822415314*x0[159] - 0.15541223924220454*x0[160] + 9.5621946802275906e-300*x0[161] - 2.081229533544995e-310*x0[162] + 0.056524137958292059*x0[163] + 0.25284990485592429*x0[164] - 0.2687822863658238*x0[165] + 0.023602545399483078*x0[166] - 5.4392778000261548e-292*x0[167] + 0.17148451149802912*x0[168] - 1.1509832704576647e-299*x0[169] + 0.091289374272108634*x0[170] + 3.0041893386078983e-305*x0[171] - 8.1255297464645239e-316*x0[172] - 0.027578756712721243*x0[173] + 0.10774839820082316*x0[174] + 0.04434990394547144*x0[175] + 2.9489673698819085e-299*x0[176] - 1.1441588377462915e-294*x0[177] - 0.034261819294818981*x0[178] - 0.068337743109327942*x0[179] + 3.0230537951125646e-315*x0[180] + 0.027079362254110697*x0[181] + 0.42883017095062087*x0[182] - 0.28342206236575718*x0[183] - 0.32071089379687528*x0[184] - 2.3158778184499351e-290*x0[185] - 6.237366557788223e-315*x0[186] + 0.1674113680451052*x0[187] - 1.0667626297231608e-315*x0[188] - 0.18463267889761345*x0[189] - 0.12824610335749623*x0[190] + 0.041569211150060993*x0[191] + 2.7252893087237011e-315*x0[192] + 8.4702062451696903e-316*x0[193] + 0.10403259913659586*x0[194] - 0.025958696092445912*x0[195] - 7.2767868955227435e-302*x0[196] + 0.16533395984307539*x0[197] + 0.011907666283349248*x0[198] - 0.068058396127240239*x0[199] - 2.5721841887280795e-313*x0[200] - 0.25378088561148721*x0[201] + 1.1452448437854093e-308*x0[202] - 0.090755115274649148*x0[203] - 0.054334826488165337*x0[204] + 0.19970656944210233*x0[205] - 9.9422217387696257e-311*x0[206] + 2.2120136840582733e-315*x0[207] - 0.054328090567976009*x0[208] + 0.063402711363887379*x0[209] - 3.075256170348635e-302*x0[210] - 1.2160847815576649e-315*x0[211] + 0.078422077505329341*x0[212] + 0.034663220469209492*x0[213] - 0.16194604497042148*x0[214] - 7.2904452949781917e-298*x0[215] + 5.4881447308466218e-315*x0[216] - 0.075496699767859277*x0[217] - 0.10757173607958728*x0[218] - 1.5822535420222168e-303*x0[219] - 0.028295303789500972); -x1[4] = relu(-0.91737010512049932*x0[0] + 9.3868954459496187e-302*x0[1] - 0.19883873349444059*x0[2] - 0.00025275325937560681*x0[3] + 0.21926458786889694*x0[4] - 0.22122948239527487*x0[5] + 1.5524519874775617e-294*x0[6] - 0.10652048914758162*x0[7] - 0.33027340410427841*x0[8] - 0.44449346134082057*x0[9] + 0.059493183931284714*x0[10] + 0.081770698645681636*x0[11] - 4.4962580825549927e-292*x0[12] - 0.10592779765759568*x0[13] + 0.43227326522074561*x0[14] - 1.6496550574916085e-305*x0[15] - 0.32807240101022417*x0[16] - 5.3623007459156579e-293*x0[17] - 8.4968604942405368e-294*x0[18] - 1.2651671790857026e-311*x0[19] + 1.1554245533884035e-296*x0[20] - 0.13302274799768607*x0[21] - 0.12292154455455952*x0[22] + 0.055090114283501815*x0[23] + 6.243756106413042e-310*x0[24] - 2.0771014261470927e-315*x0[25] - 0.028933237108577575*x0[26] - 0.18816349037873856*x0[27] + 2.7051484950223807e-298*x0[28] - 7.5206761924429584e-311*x0[29] + 6.505572887962374e-291*x0[30] - 0.21156608311407527*x0[31] + 0.37343201373249896*x0[32] - 0.62262868961250739*x0[33] - 0.0066856258392070681*x0[34] - 1.9892481799038221e-315*x0[35] + 0.16824462680839422*x0[36] - 8.9223468543753382e-294*x0[37] - 0.073566399157809839*x0[38] + 4.2565722808031694e-315*x0[39] - 4.3296790962710752e-293*x0[40] - 1.5156124575285874*x0[41] + 0.11724761204185415*x0[42] - 7.8192448065143971e-315*x0[43] - 8.153121472254113e-292*x0[44] + 4.1302449394690582e-294*x0[45] + 7.183588821856412e-297*x0[46] - 1.2251636709710984e-299*x0[47] - 0.012615869413672268*x0[48] + 4.7743207315303337e-300*x0[49] - 0.86966774008846337*x0[50] - 0.28329303483390111*x0[51] + 3.6688541924442407e-304*x0[52] + 0.042260387584008657*x0[53] - 0.085259170636202725*x0[54] - 0.030136994750701591*x0[55] + 1.0252982593277505e-315*x0[56] + 0.45410527666105865*x0[57] + 3.4527861375154092e-306*x0[58] + 9.9136232680039596e-296*x0[59] + 9.1549100354460923e-316*x0[60] + 9.4716140613235784e-310*x0[61] - 0.14073783826464914*x0[62] + 4.2921972579667691e-294*x0[63] - 4.3860743025035042e-315*x0[64] + 2.5755985434150502e-301*x0[65] + 4.481880152729131e-290*x0[66] - 3.2556837766691076e-293*x0[67] + 0.28074952126026981*x0[68] + 0.14307422947732168*x0[69] + 4.0784601652465098e-313*x0[70] + 1.6779358453304989e-315*x0[71] - 3.1638553649287375e-315*x0[72] - 0.2493261071661671*x0[73] - 0.51142824169953216*x0[74] - 2.0691133452176765e-299*x0[75] + 0.46833074500612681*x0[76] - 1.126913951965611e-302*x0[77] + 1.9953841879559114e-293*x0[78] - 6.8180423263605825e-316*x0[79] - 2.0572843337489162e-299*x0[80] - 0.071769087211718097*x0[81] - 2.7855734224162204e-313*x0[82] - 9.8305603436053175e-303*x0[83] + 3.195965786843356e-299*x0[84] - 0.63171873275632906*x0[85] + 0.13959106014641431*x0[86] + 0.16401701642910632*x0[87] - 0.28198733803980924*x0[88] + 1.7353450101981971e-302*x0[89] - 0.12752704437895479*x0[90] - 0.52528094315125962*x0[91] + 1.8183955513636883e-315*x0[92] - 0.2085169688029006*x0[93] - 0.10383292554698635*x0[94] + 0.041206934699393218*x0[95] + 1.4626088618336835e-299*x0[96] - 6.6943500705387659e-311*x0[97] + 1.4114235900637655e-315*x0[98] - 1.0128422840770335e-294*x0[99] - 0.078075152283202401*x0[100] + 1.0171444756108222e-300*x0[101] + 0.05843009012474551*x0[102] - 3.2570463788922733e-308*x0[103] + 2.3830780970476784e-296*x0[104] + 7.1513084138371544e-301*x0[105] - 2.5177752973968704e-304*x0[106] + 4.9960848698208248e-306*x0[107] + 0.80540489103119706*x0[108] + 2.4317941569385289e-310*x0[109] - 0.16168042689170223*x0[110] - 0.021348919829896035*x0[111] - 3.9972643621016074e-304*x0[112] + 8.6056954619345883e-308*x0[113] + 7.2284369200214613e-311*x0[114] + 0.2346531048974097*x0[115] + 0.11747269552618986*x0[116] - 0.17834228583194803*x0[117] - 9.3943962937661396e-300*x0[118] + 6.0848339377431037e-316*x0[119] + 0.1238522951975741*x0[120] - 0.052164062817718404*x0[121] - 0.14174849983679452*x0[122] - 0.24173976533874308*x0[123] - 0.11304070215755344*x0[124] - 1.5109000515597176e-303*x0[125] + 8.1453779598204084e-294*x0[126] + 0.032123979605647154*x0[127] - 3.7421076479198608e-311*x0[128] - 2.50858736710349e-312*x0[129] + 0.010695902554491925*x0[130] + 0.2787079358927802*x0[131] + 0.21524405583670403*x0[132] - 2.3865095430365604e-313*x0[133] - 0.10750155505080006*x0[134] + 0.022623390301426835*x0[135] + 0.84671305236510963*x0[136] - 0.10047334630704308*x0[137] + 4.2647258458096534e-311*x0[138] + 1.1662238870814786e-296*x0[139] - 0.038080631671953323*x0[140] + 0.11250895845762231*x0[141] + 0.40112575185309934*x0[142] - 9.8142075014304711e-301*x0[143] + 1.1278688403590614e-302*x0[144] - 0.31965550566858308*x0[145] - 3.448436785633304e-314*x0[146] - 0.15069407174590627*x0[147] - 2.3598814946726574e-310*x0[148] + 8.1530064142229783e-292*x0[149] + 0.13496818505705166*x0[150] - 0.25628157400770313*x0[151] - 1.4886097611158738e-294*x0[152] - 6.0258118571724665e-291*x0[153] + 0.13792514427908412*x0[154] - 0.027898208088228304*x0[155] + 0.10458820771298882*x0[156] - 1.2136070178114805e-308*x0[157] + 3.2903957150557334e-315*x0[158] + 0.13856859970297583*x0[159] - 0.16433437171098583*x0[160] + 2.0753837229381658e-315*x0[161] - 4.3060043135295148e-292*x0[162] - 0.25593853582542564*x0[163] + 0.30932335628125068*x0[164] - 0.42435139658139515*x0[165] - 0.23775026827725063*x0[166] + 9.3407533852734777e-308*x0[167] - 0.078774525905862799*x0[168] - 1.4809771461006482e-298*x0[169] + 0.0043458616493127142*x0[170] + 1.3187723758715172e-300*x0[171] - 2.6276438037531775e-301*x0[172] + 0.39752468435240029*x0[173] - 0.35757602411104206*x0[174] - 0.049039942474399988*x0[175] - 1.0549048520880622e-308*x0[176] - 2.9234721032773582e-311*x0[177] - 0.11842506618813795*x0[178] - 0.059979974566185368*x0[179] - 1.2178497176161376e-299*x0[180] + 0.38757855898391524*x0[181] - 0.72258253658701088*x0[182] - 0.18633876726962101*x0[183] + 0.018205258333340257*x0[184] + 4.0057420438743483e-312*x0[185] - 1.6571021961820542e-305*x0[186] - 0.075235899814306367*x0[187] - 7.0363557061672292e-316*x0[188] - 0.16072221516374943*x0[189] - 0.16034501587747474*x0[190] + 0.02596907580832232*x0[191] - 5.0403776954195189e-310*x0[192] + 6.7064520261638312e-293*x0[193] - 0.0081340093097222541*x0[194] - 0.021292992072801935*x0[195] - 2.2057238808822584e-308*x0[196] + 0.060211475725052685*x0[197] - 0.41630118182377251*x0[198] - 0.28583114711413293*x0[199] + 7.6851272334894707e-295*x0[200] - 0.20350456920361798*x0[201] + 1.5708501798014129e-315*x0[202] + 0.054749432408175591*x0[203] + 0.20661820202386338*x0[204] + 0.25007079940089028*x0[205] + 2.2274552013516172e-308*x0[206] + 1.8839916985559906e-315*x0[207] - 0.5174781664409881*x0[208] - 0.084015072258515316*x0[209] + 1.0167061792019848e-299*x0[210] - 5.3295261904134042e-316*x0[211] + 0.041792690055187515*x0[212] + 0.090463945956839598*x0[213] - 0.72086877149012896*x0[214] - 1.1052975304739337e-310*x0[215] + 1.9576489467159918e-315*x0[216] + 0.029897031559524428*x0[217] - 0.01865441985938136*x0[218] - 9.3058021447453372e-293*x0[219] + 0.061633860578985039); -x1[5] = relu(0.34332491628346334*x0[0] - 6.1649444061272463e-305*x0[1] - 0.086537173603283335*x0[2] - 0.1224501081126828*x0[3] - 0.019650995211879393*x0[4] - 0.019445574660193331*x0[5] + 7.1290454942981929e-298*x0[6] - 0.20066060998522103*x0[7] + 0.23810838536793602*x0[8] + 0.043048287431689716*x0[9] - 0.30781447595295924*x0[10] - 0.0045077382520432871*x0[11] - 4.5180371718073672e-314*x0[12] - 0.23641998628762445*x0[13] - 0.13127479589456167*x0[14] + 3.3978726015258223e-315*x0[15] - 0.11333579322367715*x0[16] - 2.7741882741241601e-307*x0[17] + 6.0482522113025485e-310*x0[18] - 3.0928237702078446e-306*x0[19] + 2.2730117997276523e-301*x0[20] + 0.15468487575841613*x0[21] - 0.15404731584527925*x0[22] - 0.28858116363778907*x0[23] + 9.5295786198942705e-298*x0[24] - 8.7957467184588079e-292*x0[25] - 0.32011362816559741*x0[26] - 0.071287033350181675*x0[27] - 2.5968935993115997e-314*x0[28] - 4.9253422858663275e-292*x0[29] - 3.7960927971296665e-295*x0[30] - 0.099592729163544794*x0[31] + 0.12990278564849195*x0[32] + 0.22787728354529987*x0[33] + 0.0046214050468984576*x0[34] - 1.8671074502231197e-293*x0[35] + 0.13139390117055749*x0[36] + 4.5791104834825664e-316*x0[37] - 0.14614536467247438*x0[38] + 5.5398145088372436e-302*x0[39] - 3.9679191251499464e-308*x0[40] + 1.4169433660052146*x0[41] + 0.043168145296298324*x0[42] + 8.1431309190887781e-315*x0[43] + 7.9419800112568174e-316*x0[44] - 2.6568752284764045e-315*x0[45] + 3.6266510821166186e-311*x0[46] + 9.0262902697704909e-311*x0[47] + 0.82499820200876595*x0[48] + 2.6638047116075557e-315*x0[49] + 0.5958987662652816*x0[50] + 0.53611508675401465*x0[51] + 2.119912571204184e-304*x0[52] - 0.08709944801783133*x0[53] - 0.039367946620469871*x0[54] + 0.15192668766365827*x0[55] - 8.6990136246279718e-297*x0[56] - 0.090604733333519136*x0[57] - 2.4194943541672408e-293*x0[58] - 3.9657717534462239e-315*x0[59] - 5.1726108324995709e-298*x0[60] - 6.9514249169446545e-303*x0[61] - 0.051632925593666307*x0[62] + 3.2435255638614366e-310*x0[63] + 4.2060391988251786e-303*x0[64] - 3.2144007755298085e-316*x0[65] - 3.2739999736755156e-315*x0[66] - 2.1870647622084117e-315*x0[67] - 0.062280734076554184*x0[68] + 0.011907829409582318*x0[69] + 2.3650717280957754e-315*x0[70] + 1.2007271956157711e-315*x0[71] - 2.0507515872543403e-291*x0[72] - 0.28419460872239904*x0[73] + 0.69294425053490361*x0[74] + 4.9628756280438026e-316*x0[75] - 0.18873074377722854*x0[76] - 2.9746130456111093e-304*x0[77] - 2.0590665193652675e-307*x0[78] + 1.0309444768759671e-306*x0[79] + 9.9929817556494847e-299*x0[80] - 0.012239087967330716*x0[81] - 7.3212312040163852e-291*x0[82] - 7.8665962421219266e-311*x0[83] + 4.3209184468521498e-316*x0[84] - 0.080312313531080023*x0[85] - 0.026825419670853768*x0[86] - 0.98546664695208153*x0[87] - 0.0047777334383954781*x0[88] + 8.387884199989169e-293*x0[89] + 0.05113388167264106*x0[90] + 0.28124663136998035*x0[91] - 2.1349622318073378e-310*x0[92] + 0.046227429356342831*x0[93] - 0.058317941437523578*x0[94] + 0.18684856979304751*x0[95] + 9.7540975840938996e-316*x0[96] + 7.39452988069052e-316*x0[97] + 1.0225237385769367e-293*x0[98] + 1.6518591346528447e-315*x0[99] + 0.010155907216657762*x0[100] + 1.1978835619632999e-295*x0[101] - 0.19015073086089018*x0[102] - 3.6466671340824475e-315*x0[103] + 1.4892210534946296e-314*x0[104] - 8.1753790432738869e-316*x0[105] + 9.0803657917915694e-298*x0[106] - 3.3065271659000213e-315*x0[107] + 0.95738709571303204*x0[108] + 1.5037764435204856e-312*x0[109] - 0.22200719706403943*x0[110] - 0.021238795376861623*x0[111] - 8.1615388503556403e-292*x0[112] + 5.5339798925032184e-316*x0[113] + 8.6460557597802263e-294*x0[114] - 0.037006380116838024*x0[115] + 0.005731250376909359*x0[116] - 0.0030237371255670883*x0[117] + 1.2635537194919294e-316*x0[118] + 2.0494348235384706e-293*x0[119] - 0.12704873494194008*x0[120] - 0.078524062334555042*x0[121] + 0.27676957405148078*x0[122] + 0.06120816110865171*x0[123] - 0.030653955783984665*x0[124] + 1.385651239120222e-312*x0[125] + 8.9674366401638071e-293*x0[126] + 0.13146847688632488*x0[127] - 3.0370191217905949e-302*x0[128] - 5.499792972751421e-310*x0[129] - 0.12668970956843162*x0[130] - 0.21650653618523377*x0[131] - 1.6753311670096205*x0[132] + 3.1461384170567422e-310*x0[133] - 0.093844848880841422*x0[134] + 0.0080575457027025951*x0[135] - 0.50441937938963066*x0[136] + 0.2433606841118017*x0[137] + 9.7029419884791802e-301*x0[138] + 1.2997957750520076e-299*x0[139] - 0.014961321682527758*x0[140] - 0.17782059251523696*x0[141] + 0.5343086718799781*x0[142] - 9.5939298002963138e-300*x0[143] + 1.8587574213524213e-299*x0[144] + 0.79049160085658488*x0[145] + 8.0851132926527238e-308*x0[146] - 0.19359329878036427*x0[147] - 4.283934483927812e-310*x0[148] + 4.8698506922179331e-292*x0[149] + 0.11197958315705754*x0[150] + 0.081664281112760695*x0[151] + 1.245551968991828e-300*x0[152] + 2.0831835619923439e-315*x0[153] + 0.061035899286967399*x0[154] + 0.033242379691083186*x0[155] - 0.43178777407789565*x0[156] - 7.4415174085741841e-305*x0[157] + 4.4535832769133581e-310*x0[158] - 0.46219705210494316*x0[159] + 0.017803221221160747*x0[160] - 9.1936458928824028e-311*x0[161] - 7.7819950108956995e-295*x0[162] + 0.038990110017185671*x0[163] + 0.21740763359292939*x0[164] + 0.24148476764337551*x0[165] + 0.14447448001486843*x0[166] + 1.4474095086046087e-315*x0[167] - 0.17202096645598813*x0[168] + 1.583617745170739e-315*x0[169] - 0.25925137321100084*x0[170] + 2.4765373646257474e-315*x0[171] - 5.1958032720281749e-316*x0[172] + 0.018952614558090955*x0[173] - 0.012641116457482287*x0[174] - 0.046328229684442584*x0[175] - 6.3886384244291651e-294*x0[176] - 1.5411957174526817e-315*x0[177] - 0.46484239312981102*x0[178] + 0.041081016841581872*x0[179] + 3.4513773406243426e-302*x0[180] - 0.030656705280588996*x0[181] - 0.16541019746815705*x0[182] + 0.35945949655308096*x0[183] - 0.083679479724937403*x0[184] + 5.4266271454613692e-314*x0[185] + 1.6685413207804645e-295*x0[186] - 0.10331328887378895*x0[187] - 1.3034899456756183e-306*x0[188] + 0.064263370876221734*x0[189] - 0.12107206013366183*x0[190] - 0.168278947535348*x0[191] - 4.3062638424319836e-298*x0[192] - 5.0092070944517474e-314*x0[193] - 0.11508062187179663*x0[194] - 0.55299435049641865*x0[195] + 2.8528180561862747e-300*x0[196] + 0.13969122832864506*x0[197] + 0.16558623629407906*x0[198] - 0.12637496999450654*x0[199] + 7.6707944433932927e-316*x0[200] + 0.07832352685239713*x0[201] - 1.9616637642729483e-294*x0[202] + 0.40081944746596099*x0[203] - 0.019248452288723562*x0[204] + 0.20633132026473261*x0[205] - 9.3966853620562159e-314*x0[206] - 1.854754459823203e-315*x0[207] - 0.13668805877397217*x0[208] + 0.12602750776027508*x0[209] + 3.9907632032310799e-300*x0[210] - 6.831954888668953e-301*x0[211] - 0.20300441284085669*x0[212] + 0.2061424038277255*x0[213] + 0.20202055926911341*x0[214] + 2.7164600451660742e-296*x0[215] + 1.9348077286739147e-315*x0[216] - 0.087208557394858166*x0[217] - 0.1444071363853584*x0[218] + 5.3701858168035554e-316*x0[219] - 0.011834126227198753); -x1[6] = relu(-0.72192868411527034*x0[0] - 4.7032422419769877e-303*x0[1] - 0.06037427720467848*x0[2] - 0.1182224582006268*x0[3] - 0.090829699230284*x0[4] + 0.0037438699230031461*x0[5] - 1.8261276935430732e-316*x0[6] + 0.1581952615340298*x0[7] - 0.027567560201468271*x0[8] - 0.44064226073061874*x0[9] + 0.31433338718955811*x0[10] + 0.22810784131389503*x0[11] - 3.3786007278867598e-313*x0[12] + 0.038320352405971612*x0[13] + 0.16877899957117642*x0[14] + 5.446027005586015e-303*x0[15] + 0.17567488528348194*x0[16] + 1.4095529241308861e-315*x0[17] - 1.1480862599242671e-296*x0[18] + 3.1236970251738447e-306*x0[19] - 2.6551610597696302e-311*x0[20] + 0.17307308678658881*x0[21] + 0.22139664314808694*x0[22] - 0.18185167429994387*x0[23] - 4.2066925154898767e-299*x0[24] - 8.3290934518426505e-298*x0[25] - 0.020463947767595955*x0[26] - 0.045964042219736816*x0[27] + 4.0013340075091928e-304*x0[28] + 2.312097047998117e-313*x0[29] + 3.1877874947388014e-315*x0[30] - 0.10628377748935867*x0[31] - 0.072522773195709767*x0[32] - 0.26263367380838148*x0[33] - 0.0019938524317998623*x0[34] + 1.5095548394715634e-315*x0[35] - 0.048581618313695188*x0[36] + 2.1248113890660244e-315*x0[37] - 0.0098828022389013774*x0[38] + 4.1534112942960095e-301*x0[39] - 4.3302706945127821e-315*x0[40] - 1.7516377580693749*x0[41] - 0.16783715625997478*x0[42] - 1.325117470865195e-315*x0[43] + 2.4179081384514187e-294*x0[44] - 8.263310534914144e-293*x0[45] + 4.5987433793316692e-295*x0[46] - 2.2777423001315386e-315*x0[47] + 0.2017196653152753*x0[48] + 5.3436669083869197e-307*x0[49] - 0.55849305849346564*x0[50] - 0.77114963282671389*x0[51] + 1.1794056200550605e-296*x0[52] + 0.0026456521929826902*x0[53] + 0.28367804507796657*x0[54] + 0.11573806686467231*x0[55] + 7.8606856898016963e-300*x0[56] + 0.55164554764344709*x0[57] + 6.6344965472148094e-291*x0[58] + 5.3851163948133758e-292*x0[59] + 3.9097726853090683e-293*x0[60] + 1.5445994740252629e-315*x0[61] - 0.047568029572745987*x0[62] + 3.0766817158626344e-315*x0[63] - 7.0867434336840284e-291*x0[64] - 6.6646125621531189e-316*x0[65] + 9.1441642603587164e-306*x0[66] - 1.5601163748200959e-305*x0[67] + 0.20715481968274518*x0[68] + 0.2499683638499092*x0[69] + 9.601474826712353e-316*x0[70] + 3.5309169872821212e-300*x0[71] + 1.752838731796795e-315*x0[72] - 0.16648963704487085*x0[73] - 0.5594393710661707*x0[74] - 4.4270030774726669e-304*x0[75] + 0.076624814038149747*x0[76] + 7.1171630031846545e-315*x0[77] - 2.1340719118179334e-310*x0[78] - 1.1669909538863922e-308*x0[79] - 1.9395081506526933e-316*x0[80] - 0.0096304736676950508*x0[81] - 2.0353117975150557e-315*x0[82] + 5.5623641834273094e-302*x0[83] + 5.5867506612396881e-292*x0[84] - 0.40971203009813983*x0[85] - 0.17719351502424235*x0[86] + 0.011893173178716975*x0[87] + 0.12417672269776185*x0[88] - 1.4003508016007901e-300*x0[89] - 0.10402186981943054*x0[90] - 0.40554516580402417*x0[91] + 2.1084873132944382e-307*x0[92] + 0.076150495610869312*x0[93] + 0.19590662645274909*x0[94] + 0.15504729247106*x0[95] - 3.5922272407474005e-306*x0[96] - 2.7555490131975223e-307*x0[97] + 1.0700456256868402e-300*x0[98] + 8.4403005189982052e-311*x0[99] + 0.20338141490352135*x0[100] - 1.6035940897251149e-299*x0[101] + 0.08075994019262922*x0[102] - 6.0617260053572186e-306*x0[103] + 7.8007567317086368e-316*x0[104] - 2.1109616011146681e-296*x0[105] - 3.9652523215139982e-304*x0[106] + 2.8010861921541776e-315*x0[107] + 0.71603351356491007*x0[108] - 8.2641358436689141e-292*x0[109] + 0.0054653177291721375*x0[110] + 0.025926652229075097*x0[111] - 2.6967136918675047e-303*x0[112] - 8.6837775829075526e-316*x0[113] - 2.6514029904355337e-306*x0[114] - 0.030952531792437007*x0[115] + 0.0068344813507494875*x0[116] + 0.013744338912799713*x0[117] + 2.2934320562884445e-315*x0[118] - 1.5583230895811462e-301*x0[119] + 0.18692867589034518*x0[120] - 0.17901379620200114*x0[121] - 0.28787116259157536*x0[122] + 0.11412968232470498*x0[123] + 0.23201128257735409*x0[124] - 1.0924369091617895e-310*x0[125] - 7.8090820408554749e-311*x0[126] + 0.2131579388448481*x0[127] + 3.3934462097951782e-293*x0[128] + 1.1104672235472532e-294*x0[129] + 0.04691141086683713*x0[130] + 0.30129073160455294*x0[131] + 0.11529514953676551*x0[132] - 1.5520336395976461e-310*x0[133] - 0.12166149395523777*x0[134] + 0.080267980450978341*x0[135] - 0.15560145662953462*x0[136] + 0.0086069383911220251*x0[137] + 1.1057898089961567e-302*x0[138] - 6.1326225980436589e-309*x0[139] - 0.030043237308129595*x0[140] - 0.026521473507425647*x0[141] + 0.14031252204577854*x0[142] - 4.4787887744129046e-310*x0[143] - 1.6016693138763874e-299*x0[144] + 0.12272824518088413*x0[145] - 5.7311124458617973e-314*x0[146] - 0.11010100021335466*x0[147] + 1.0756988779944252e-294*x0[148] + 4.3316718270585498e-307*x0[149] + 0.14673413987130662*x0[150] + 0.018460495009877193*x0[151] - 2.2830531748003493e-315*x0[152] + 5.9240040195691321e-298*x0[153] + 0.08037857505354111*x0[154] - 0.041160042942350122*x0[155] + 0.84363077474170678*x0[156] + 9.5324955962311491e-311*x0[157] - 1.9050563365594352e-311*x0[158] + 0.12871918949936756*x0[159] - 0.085903816854955434*x0[160] - 1.1912972967493313e-303*x0[161] - 9.4272782727503136e-294*x0[162] - 0.099315610574513741*x0[163] + 0.017415318759995795*x0[164] - 0.46498074415988366*x0[165] + 0.10857929046983511*x0[166] - 1.2546939523870135e-299*x0[167] + 0.098430254618694979*x0[168] + 1.0021781884393253e-309*x0[169] + 0.15201224709429687*x0[170] - 5.3827093763042028e-307*x0[171] + 5.5171614693078321e-292*x0[172] - 0.040347236138016072*x0[173] - 0.087011510696257163*x0[174] + 0.043598928334743249*x0[175] + 6.8892875312156174e-316*x0[176] + 8.7694603864354665e-293*x0[177] - 0.45180328873762071*x0[178] + 0.047244189881718274*x0[179] - 1.0409147910095933e-310*x0[180] - 0.074485571270448928*x0[181] - 0.43719063431765953*x0[182] - 0.24129072257061585*x0[183] + 0.1389647984878184*x0[184] + 1.4145842663385928e-315*x0[185] - 1.2441227352230505e-315*x0[186] - 0.12754325443740699*x0[187] + 9.0935715653720048e-303*x0[188] - 0.043378244018076592*x0[189] - 0.062004749688555905*x0[190] + 0.0234758668641919*x0[191] + 1.6582743053279881e-315*x0[192] - 5.298690904313084e-294*x0[193] + 0.27715977543335718*x0[194] - 0.58870052814676399*x0[195] + 8.5914241936260256e-305*x0[196] - 0.016011967507429198*x0[197] - 0.2189467505257941*x0[198] - 0.12591013812441323*x0[199] + 1.0466467869813753e-294*x0[200] + 0.033289720149023608*x0[201] + 2.7912624230631238e-315*x0[202] - 0.073656846753050717*x0[203] + 0.073909769633181882*x0[204] + 0.20547161486374987*x0[205] + 2.1503265517421012e-297*x0[206] + 1.0387275117080965e-295*x0[207] - 0.32456579684535575*x0[208] + 0.077330548554642012*x0[209] + 1.070450671629128e-295*x0[210] + 4.3310180913303972e-314*x0[211] + 0.057387197621120094*x0[212] + 0.070357985337507201*x0[213] - 0.3150937514904274*x0[214] + 2.5130600360842326e-315*x0[215] + 1.5016264109175041e-299*x0[216] + 0.063869944038173712*x0[217] - 0.055426717881951082*x0[218] - 7.7724844383855067e-299*x0[219] + 0.032506528660508439); -x1[7] = relu(0.18309769774453794*x0[0] - 9.993653744522845e-303*x0[1] - 0.0013821538482420245*x0[2] + 0.14384539776301578*x0[3] - 0.11014887026359878*x0[4] - 0.10692896161059576*x0[5] + 1.1925172168790443e-295*x0[6] + 0.061679410671786665*x0[7] + 0.018983300522459869*x0[8] - 0.096850976257836702*x0[9] + 0.10530352007373586*x0[10] + 0.10114051588867733*x0[11] - 2.4884447122990993e-315*x0[12] - 0.18212408786214329*x0[13] + 0.025898098642517131*x0[14] + 5.0370733732919005e-300*x0[15] - 0.032230159403651273*x0[16] - 2.4025277720702926e-310*x0[17] + 2.7047721918301941e-306*x0[18] + 5.1592230565732832e-309*x0[19] - 9.9040851084150954e-303*x0[20] - 0.0436479799107009*x0[21] + 0.14088814154913501*x0[22] + 0.16694570471674425*x0[23] - 5.4843660375155694e-305*x0[24] + 3.7132662807408267e-312*x0[25] - 0.052555241840744484*x0[26] - 0.010926356114517*x0[27] - 1.3246877572697246e-315*x0[28] + 3.4907896572590126e-302*x0[29] + 2.305676871384803e-292*x0[30] + 0.1278902322502565*x0[31] + 0.019104030251283918*x0[32] + 0.062299013572876566*x0[33] + 0.11209523418246051*x0[34] + 7.8672205174629138e-316*x0[35] + 0.016762363719336912*x0[36] - 2.0388581928158538e-314*x0[37] + 0.46581851226787707*x0[38] - 4.4361714767138168e-307*x0[39] + 2.3597329436586312e-315*x0[40] - 0.042081778170924886*x0[41] + 0.1399431823589459*x0[42] + 3.2764689713606991e-300*x0[43] - 1.096994649871224e-315*x0[44] - 6.7855245837737524e-297*x0[45] - 3.7904674099870277e-311*x0[46] + 1.306451947655739e-299*x0[47] - 0.19396607915737271*x0[48] + 2.5315492659898182e-307*x0[49] - 0.086864608831563592*x0[50] - 0.063137943204648272*x0[51] + 5.6599327392894316e-316*x0[52] + 0.032465728045641087*x0[53] - 0.34538442376025602*x0[54] + 0.10088737957512034*x0[55] + 1.8488002968615376e-315*x0[56] + 0.036051283766200787*x0[57] + 6.0676396535009768e-292*x0[58] + 2.2833728056292698e-315*x0[59] - 1.2005542237659624e-310*x0[60] - 1.1837416529460451e-313*x0[61] + 0.1815256528354583*x0[62] - 4.1483786187160634e-315*x0[63] + 1.189739855973341e-300*x0[64] - 1.6061173996534963e-309*x0[65] + 9.0926158145569786e-294*x0[66] - 1.2384605485019375e-311*x0[67] + 0.43650209756488628*x0[68] + 0.081994396101374323*x0[69] - 3.9976693578182342e-315*x0[70] + 5.4511168742915894e-294*x0[71] + 1.1845622901276273e-311*x0[72] + 0.14745057029078057*x0[73] - 0.11886328707807645*x0[74] + 5.5150367679216033e-314*x0[75] + 0.37839088708364421*x0[76] + 1.3702207335553553e-315*x0[77] + 7.7194655881833967e-298*x0[78] - 3.3861166355663561e-315*x0[79] + 2.5579228962032509e-311*x0[80] + 0.27651311634809594*x0[81] + 3.0477967107474773e-306*x0[82] + 9.4156424294209428e-298*x0[83] - 3.8443309641331774e-300*x0[84] + 0.36627164826519526*x0[85] + 0.32777930499602531*x0[86] + 0.1254272112622867*x0[87] + 0.10421545180878071*x0[88] + 1.1884699435893995e-308*x0[89] + 0.6810573858962321*x0[90] + 0.13420457647019549*x0[91] - 1.0939284784731332e-315*x0[92] - 0.047933591723003814*x0[93] - 0.012289459299888082*x0[94] + 0.62368437878855076*x0[95] + 1.1051123028748301e-300*x0[96] + 1.0161593505766136e-312*x0[97] + 9.3866369516913766e-316*x0[98] + 1.1192285130160915e-295*x0[99] + 0.22324346615375062*x0[100] + 9.3350507176974942e-317*x0[101] + 0.0170483446542989*x0[102] - 3.3349937462164564e-315*x0[103] - 4.0779352409027147e-314*x0[104] + 4.694417503437873e-290*x0[105] - 1.8610712687246793e-303*x0[106] + 3.9367372002039862e-315*x0[107] - 0.051380902741830811*x0[108] + 2.4987860950617769e-305*x0[109] - 0.17941736126726737*x0[110] - 0.047556092806359446*x0[111] + 1.4331762727936122e-315*x0[112] - 1.3135595919989867e-308*x0[113] - 5.2195814935197048e-300*x0[114] + 0.10824210118284226*x0[115] + 0.029058901431878458*x0[116] + 0.12252923410244296*x0[117] + 2.4765372626901233e-312*x0[118] - 4.2197754885370608e-308*x0[119] - 0.18196738047678529*x0[120] - 0.032038763974502137*x0[121] - 0.4610247294404235*x0[122] + 0.046319050003475172*x0[123] - 0.63184724920614599*x0[124] - 1.2301976927869574e-300*x0[125] - 1.2027942072858561e-296*x0[126] + 0.20622373142130443*x0[127] + 1.4741810682659175e-316*x0[128] - 1.7602963308612096e-311*x0[129] - 0.12759540895733248*x0[130] + 0.32639391294814923*x0[131] - 0.42168582583801822*x0[132] - 1.5709029132008783e-306*x0[133] + 0.23985914850764453*x0[134] - 0.050912751440663651*x0[135] + 0.064157363185994187*x0[136] + 0.065480240911991144*x0[137] - 4.7318499757597033e-306*x0[138] + 1.660756011490196e-299*x0[139] + 0.0010011124712062617*x0[140] + 0.47758458935754183*x0[141] + 0.020355599680096269*x0[142] + 2.7045369128582411e-301*x0[143] - 7.0147997355862962e-292*x0[144] + 0.11218401140555799*x0[145] + 3.2164754559898251e-316*x0[146] + 0.16945095715972078*x0[147] + 2.6454576184338362e-315*x0[148] + 1.6059088301772674e-299*x0[149] - 0.065511737257634636*x0[150] - 0.015417672900505259*x0[151] + 7.4863409380075065e-294*x0[152] - 1.2428278760527253e-305*x0[153] - 0.069854028495537901*x0[154] - 0.12367766573201791*x0[155] - 1.8232554827118814*x0[156] - 2.7303900720953049e-315*x0[157] + 5.2051056643272121e-300*x0[158] + 0.16206408653824869*x0[159] + 0.0067895721581206847*x0[160] + 8.8414227877314974e-304*x0[161] - 1.492682962087792e-315*x0[162] + 0.15216869460620019*x0[163] - 0.17191461423066987*x0[164] + 0.059726842096976311*x0[165] + 0.079832026363421738*x0[166] + 2.706573766988795e-309*x0[167] + 0.10609411552561*x0[168] - 8.1919501038485315e-316*x0[169] + 0.1612733700656831*x0[170] - 1.6712487501021969e-299*x0[171] + 9.4817478127955928e-308*x0[172] - 0.13663345515141267*x0[173] + 0.11483689279032465*x0[174] + 0.11428546057848456*x0[175] - 6.2643255744534254e-295*x0[176] + 5.7292553735347266e-301*x0[177] - 1.0077668701513576*x0[178] + 0.15547607363666019*x0[179] + 2.6316851344367326e-301*x0[180] + 0.58128551851410937*x0[181] + 0.014144340307851522*x0[182] - 0.11599836458415103*x0[183] + 0.084048922720026245*x0[184] + 8.3699588937175653e-312*x0[185] - 4.4107125248627603e-312*x0[186] + 0.6522063721470851*x0[187] + 2.7424685866090645e-310*x0[188] + 0.066843396721615364*x0[189] + 0.45889442208964804*x0[190] - 0.020240504533116852*x0[191] + 7.6171147388492941e-308*x0[192] - 2.3960190268419488e-316*x0[193] + 0.16079427256160683*x0[194] - 0.22536742626413026*x0[195] + 4.786873966216728e-297*x0[196] - 0.034233480959635083*x0[197] + 0.078000462743437748*x0[198] + 0.20241705823326142*x0[199] - 1.0946800951692939e-303*x0[200] + 0.27870574631092965*x0[201] - 7.9949832535320307e-293*x0[202] + 0.039367625925130087*x0[203] + 0.10574628593042708*x0[204] + 0.1456623426356953*x0[205] - 4.6385850773975923e-295*x0[206] + 8.7209832457741923e-316*x0[207] + 0.050389193756523475*x0[208] + 0.36215184519429355*x0[209] + 9.274869520102299e-316*x0[210] + 9.7249872664501816e-295*x0[211] + 0.0058621179138875759*x0[212] + 0.15757268000783289*x0[213] - 0.093007260048802054*x0[214] + 4.5359783285525304e-290*x0[215] - 4.2626623863436382e-299*x0[216] - 0.052461985357654416*x0[217] - 0.016644774888109549*x0[218] + 3.480752810248252e-315*x0[219] - 0.023875997656202658); -x2[0] = relu(0.55800284880946083*x1[0] + 1.1966704325228015*x1[1] + 1.0294981891171815*x1[2] - 1.1519814591285755*x1[3] + 0.50659827991669171*x1[4] - 1.3033184163654803*x1[5] + 0.010475672155849283*x1[6] + 0.90831836409432853*x1[7] + 1.1844337554371509); -x2[1] = relu(-0.514451625589187*x1[0] + 0.46195256454288375*x1[1] - 1.5756023756440205*x1[2] + 0.66169009017998015*x1[3] + 0.87166307777297725*x1[4] + 0.016569343156980634*x1[5] + 0.88918417765469338*x1[6] - 0.87685208073834064*x1[7] + 0.20858959902658483); -x2[2] = relu(-0.09325394725844903*x1[0] + 0.21518897768520051*x1[1] - 0.012365545872623134*x1[2] - 0.035668886264491294*x1[3] + 0.015594067868800543*x1[4] - 0.055419604207940183*x1[5] - 0.10341197784511584*x1[6] - 0.020884845337471751*x1[7] - 0.38572717126414052); -x2[3] = relu(0.84462456618632009*x1[0] - 0.29033469115580413*x1[1] + 2.3120512091783882*x1[2] - 0.0042852475244832397*x1[3] - 0.031942099107773493*x1[4] + 0.54240512137966213*x1[5] - 1.3029761574303527*x1[6] - 0.81111520375999824*x1[7] - 0.36957780638258436); -x3_result[0] = sigmoid(-1.6586703209380282*x2[0] + 1.0957227401539915*x2[1] + 0.20946670824801569*x2[2] - 2.128419282564376*x2[3] - 1.0187430367351187); +x0[67] = 1.0*biggest_literal_stats_false_cntr; +x0[68] = 1.0*biggest_literal_stats_forall_cntr; +x0[69] = 1.0*biggest_literal_stats_ifthenelse_cntr; +x0[70] = 2.2417710409364737*biggest_literal_stats_inequality_cntr - 0.61454141810764829; +x0[71] = 1.0*biggest_literal_stats_log_cntr; +x0[72] = 1.0*biggest_literal_stats_max_cntr; +x0[73] = 1.0*biggest_literal_stats_min_cntr; +x0[74] = 0.08931595980065464*biggest_literal_stats_multiplication_cntr - 0.075558746988694386; +x0[75] = 3.859314929165945*biggest_literal_stats_negation_cntr - 0.27933085126644913; +x0[76] = 1.0*biggest_literal_stats_notequalto_cntr; +x0[77] = 0.15199671843207646*biggest_literal_stats_pow_cntr - 0.034598836144209451; +x0[78] = 0.24823812915831345*biggest_literal_stats_realconstant_cntr - 0.13793782624329198; +x0[79] = 1.0*biggest_literal_stats_sqrt_cntr; +x0[80] = 2.8596541345038138*biggest_literal_stats_trigonometry_cntr - 0.039463350379122568; +x0[81] = 1.0*biggest_literal_stats_true_cntr; +x0[82] = 1.0*biggest_literal_stats_uninterpretedfunction_cntr; +x0[83] = 0.7844167838394539*biggest_literal_stats_unique_variables - 1.1493090015501524; +x0[84] = 0.11096182710698629*biggest_literal_stats_variable_cntr - 0.2239494074005732; +x0[85] = 0.00046904838095628324*box_boolean_count - 0.5936472249093071; +x0[86] = 0.0016902606416621386*box_continuous_count - 0.6017648612276244; +x0[87] = 1.9019154961840616*box_integer_count - 0.9737183985710538; +x0[88] = 0.0064402310088025709*lemma_size - 0.11973423085545294; +x0[89] = 28.615217352461183*lemma_stats_abs_cntr - 0.022623976919217494; +x0[90] = 0.0052312396662408259*lemma_stats_addition_cntr - 0.057936176701793296; +x0[91] = 0.0064400668754121719*lemma_stats_conjunction_cntr - 0.11951223651954426; +x0[92] = 0.0051204320855597965*lemma_stats_constant_cntr - 0.097456400343892496; +x0[93] = 1.0*lemma_stats_disjunction_cntr; +x0[94] = 1.1314935931259746*lemma_stats_division_cntr - 0.077829322836308321; +x0[95] = 0.010959097474016669*lemma_stats_equalto_cntr - 0.12607333761257372; +x0[96] = 1.0*lemma_stats_exp_cntr; +x0[97] = 1.0*lemma_stats_false_cntr; +x0[98] = 1.0*lemma_stats_forall_cntr; +x0[99] = 1.0*lemma_stats_ifthenelse_cntr; +x0[100] = 0.014886936153706839*lemma_stats_inequality_cntr - 0.10551288536742841; +x0[101] = 1.0*lemma_stats_log_cntr; +x0[102] = 1.0*lemma_stats_max_cntr; +x0[103] = 1.0*lemma_stats_min_cntr; +x0[104] = 0.0054124685449075819*lemma_stats_multiplication_cntr - 0.065841650884572944; +x0[105] = 0.016785227125474561*lemma_stats_negation_cntr - 0.080341796535172358; +x0[106] = 1.0*lemma_stats_notequalto_cntr; +x0[107] = 0.11292569409072524*lemma_stats_pow_cntr - 0.11682975927132171; +x0[108] = 0.18193265637824893*lemma_stats_realconstant_cntr - 0.19706210965429538; +x0[109] = 1.0*lemma_stats_sqrt_cntr; +x0[110] = 1.5980485926746135*lemma_stats_trigonometry_cntr - 0.087753117573737133; +x0[111] = 1.0*lemma_stats_true_cntr; +x0[112] = 1.0*lemma_stats_uninterpretedfunction_cntr; +x0[113] = 0.0066135984914860377*lemma_stats_unique_variables - 0.097686172442849412; +x0[114] = 0.0020688498721947095*lemma_stats_variable_cntr - 0.085178681584834798; +x0[115] = 1.0*middle_assertion_stats_abs_cntr; +x0[116] = 2.0684090968641597*middle_assertion_stats_addition_cntr - 0.23132642526562444; +x0[117] = 1.0*middle_assertion_stats_conjunction_cntr; +x0[118] = 0.97347244624775553*middle_assertion_stats_constant_cntr - 0.80750704392620909; +x0[119] = 1.0*middle_assertion_stats_disjunction_cntr; +x0[120] = 1.0*middle_assertion_stats_division_cntr; +x0[121] = 2.7895691267196265*middle_assertion_stats_equalto_cntr - 2.3671137145153391; +x0[122] = 1.0*middle_assertion_stats_exp_cntr; +x0[123] = 1.0*middle_assertion_stats_false_cntr; +x0[124] = 1.0*middle_assertion_stats_forall_cntr; +x0[125] = 1.0*middle_assertion_stats_ifthenelse_cntr; +x0[126] = 2.7895691267196265*middle_assertion_stats_inequality_cntr - 0.42245541220428762; +x0[127] = 1.0*middle_assertion_stats_log_cntr; +x0[128] = 1.0*middle_assertion_stats_max_cntr; +x0[129] = 1.0*middle_assertion_stats_min_cntr; +x0[130] = 1.0514943753608537*middle_assertion_stats_multiplication_cntr - 0.34379701814968183; +x0[131] = 2.0003360069220513*middle_assertion_stats_negation_cntr - 0.98183674198739934; +x0[132] = 1.0*middle_assertion_stats_notequalto_cntr; +x0[133] = 4.5109334446419505*middle_assertion_stats_pow_cntr - 0.21723031753828123; +x0[134] = 2.4930558858837699*middle_assertion_stats_realconstant_cntr - 0.50172906493743663; +x0[135] = 1.0*middle_assertion_stats_sqrt_cntr; +x0[136] = 26.394155405579589*middle_assertion_stats_trigonometry_cntr - 0.03794171696338617; +x0[137] = 1.0*middle_assertion_stats_true_cntr; +x0[138] = 1.0*middle_assertion_stats_uninterpretedfunction_cntr; +x0[139] = 1.5862324617799162*middle_assertion_stats_unique_variables - 2.171563983290596; +x0[140] = 1.3853974121446897*middle_assertion_stats_variable_cntr - 1.9345576743439254; +x0[141] = 117.95761981271234*middle_literal_stats_abs_cntr - 0.008478230418508757; +x0[142] = 0.17166362569978674*middle_literal_stats_addition_cntr - 0.060988521658452227; +x0[143] = 1.0*middle_literal_stats_conjunction_cntr; +x0[144] = 0.090286815587543409*middle_literal_stats_constant_cntr - 0.095497791862739087; +x0[145] = 1.0*middle_literal_stats_disjunction_cntr; +x0[146] = 1.7689855005756907*middle_literal_stats_division_cntr - 0.033439458538877788; +x0[147] = 2.0532837374454407*middle_literal_stats_equalto_cntr - 1.2590069405697588; +x0[148] = 1.0*middle_literal_stats_exp_cntr; +x0[149] = 1.0*middle_literal_stats_false_cntr; +x0[150] = 1.0*middle_literal_stats_forall_cntr; +x0[151] = 1.0*middle_literal_stats_ifthenelse_cntr; +x0[152] = 2.0532837374454407*middle_literal_stats_inequality_cntr - 0.79427679687568187; +x0[153] = 1.0*middle_literal_stats_log_cntr; +x0[154] = 1.0*middle_literal_stats_max_cntr; +x0[155] = 1.0*middle_literal_stats_min_cntr; +x0[156] = 0.19811233121892721*middle_literal_stats_multiplication_cntr - 0.082830405426615364; +x0[157] = 2.5529411624742262*middle_literal_stats_negation_cntr - 0.48313764686226096; +x0[158] = 1.0*middle_literal_stats_notequalto_cntr; +x0[159] = 0.16942371481996552*middle_literal_stats_pow_cntr - 0.032428329804180853; +x0[160] = 0.72913826386016745*middle_literal_stats_realconstant_cntr - 0.40845997473773771; +x0[161] = 1.0*middle_literal_stats_sqrt_cntr; +x0[162] = 3.2027278540994542*middle_literal_stats_trigonometry_cntr - 0.043967585720764445; +x0[163] = 1.0*middle_literal_stats_true_cntr; +x0[164] = 1.0*middle_literal_stats_uninterpretedfunction_cntr; +x0[165] = 1.6169472673232148*middle_literal_stats_unique_variables - 1.8369487894279259; +x0[166] = 0.15532919408550064*middle_literal_stats_variable_cntr - 0.22999617101670369; +x0[167] = 117.95761981271234*smallest_assertion_stats_abs_cntr - 0.008478230418508757; +x0[168] = 1.4456995849575351*smallest_assertion_stats_addition_cntr - 0.17342576060476719; +x0[169] = 1.0*smallest_assertion_stats_conjunction_cntr; +x0[170] = 1.0264539941560433*smallest_assertion_stats_constant_cntr - 0.72301079154238657; +x0[171] = 1.0*smallest_assertion_stats_disjunction_cntr; +x0[172] = 11.916838896706651*smallest_assertion_stats_division_cntr - 0.017130509446857831; +x0[173] = 2.0160297845385511*smallest_assertion_stats_equalto_cntr - 1.1348771129523418; +x0[174] = 1.0*smallest_assertion_stats_exp_cntr; +x0[175] = 1.0*smallest_assertion_stats_false_cntr; +x0[176] = 1.0*smallest_assertion_stats_forall_cntr; +x0[177] = 1.0*smallest_assertion_stats_ifthenelse_cntr; +x0[178] = 2.0160297845385511*smallest_assertion_stats_inequality_cntr - 0.88115267158620925; +x0[179] = 1.0*smallest_assertion_stats_log_cntr; +x0[180] = 1.0*smallest_assertion_stats_max_cntr; +x0[181] = 1.0*smallest_assertion_stats_min_cntr; +x0[182] = 1.7094086275698364*smallest_assertion_stats_multiplication_cntr - 0.17729293822922976; +x0[183] = 2.0747529068139507*smallest_assertion_stats_negation_cntr - 1.3133291777697451; +x0[184] = 1.0*smallest_assertion_stats_notequalto_cntr; +x0[185] = 1.8874366036972476*smallest_assertion_stats_pow_cntr - 0.04666701586083901; +x0[186] = 1.6935753858341813*smallest_assertion_stats_realconstant_cntr - 0.74179892196316399; +x0[187] = 1.0*smallest_assertion_stats_sqrt_cntr; +x0[188] = 17.208229650322913*smallest_assertion_stats_trigonometry_cntr - 0.01855268056888117; +x0[189] = 1.0*smallest_assertion_stats_true_cntr; +x0[190] = 1.0*smallest_assertion_stats_uninterpretedfunction_cntr; +x0[191] = 2.390572553702162*smallest_assertion_stats_unique_variables - 2.4223597974623075; +x0[192] = 2.0922980271737206*smallest_assertion_stats_variable_cntr - 2.1450829482933913; +x0[193] = 41.714812421160595*smallest_literal_stats_abs_cntr - 0.023986092098705149; +x0[194] = 0.1717450336334706*smallest_literal_stats_addition_cntr - 0.059227533341004238; +x0[195] = 1.0*smallest_literal_stats_conjunction_cntr; +x0[196] = 0.090339966682452699*smallest_literal_stats_constant_cntr - 0.097404574153918844; +x0[197] = 1.0*smallest_literal_stats_disjunction_cntr; +x0[198] = 1.7697667925338136*smallest_literal_stats_division_cntr - 0.033199822673134864; +x0[199] = 2.0051965684798647*smallest_literal_stats_equalto_cntr - 1.0747323230902286; +x0[200] = 1.0*smallest_literal_stats_exp_cntr; +x0[201] = 1.0*smallest_literal_stats_false_cntr; +x0[202] = 1.0*smallest_literal_stats_forall_cntr; +x0[203] = 1.0*smallest_literal_stats_ifthenelse_cntr; +x0[204] = 2.0051965684798647*smallest_literal_stats_inequality_cntr - 0.93046424538963612; +x0[205] = 1.0*smallest_literal_stats_log_cntr; +x0[206] = 1.0*smallest_literal_stats_max_cntr; +x0[207] = 1.0*smallest_literal_stats_min_cntr; +x0[208] = 0.1984602857866811*smallest_literal_stats_multiplication_cntr - 0.072348923273919827; +x0[209] = 2.0731409307148403*smallest_literal_stats_negation_cntr - 0.76366328397279937; +x0[210] = 1.0*smallest_literal_stats_notequalto_cntr; +x0[211] = 0.16945087581388943*smallest_literal_stats_pow_cntr - 0.029827154091009504; +x0[212] = 0.72943489750124979*smallest_literal_stats_realconstant_cntr - 0.4083115777862239; +x0[213] = 1.0*smallest_literal_stats_sqrt_cntr; +x0[214] = 3.2392414057685444*smallest_literal_stats_trigonometry_cntr - 0.039113962205787063; +x0[215] = 1.0*smallest_literal_stats_true_cntr; +x0[216] = 1.0*smallest_literal_stats_uninterpretedfunction_cntr; +x0[217] = 1.8363223514790834*smallest_literal_stats_unique_variables - 1.9094426406129448; +x0[218] = 0.15542016244619064*smallest_literal_stats_variable_cntr - 0.21487147449525459; +x0[219] = 0.00032842472077025258*theory_checksat_ms - 0.040918510018383925; +x1[0] = relu(-0.068987151721099635*x0[0] + 0.11554164845276675*x0[1] + 0.042264035809676068*x0[2] - 0.082545385391382217*x0[3] + 0.47604599652106533*x0[4] - 1.1098751443858104*x0[5] + 0.012141316538451642*x0[6] - 0.070635953891904302*x0[7] + 0.16873307665984202*x0[8] - 0.16331670968133108*x0[9] + 0.26350338866248713*x0[10] + 4.137463735290108e-315*x0[11] + 0.16336746821966627*x0[12] - 0.057326990714608984*x0[13] + 9.6447809651410175e-317*x0[14] - 3.6194970660118597e-315*x0[15] - 4.2445272864408861e-315*x0[16] - 3.6812689425384359e-315*x0[17] + 0.16996581321337711*x0[18] - 0.18512844073140786*x0[19] + 3.2661676003985589e-315*x0[20] - 1.194981014528379e-316*x0[21] + 0.096030731392715105*x0[22] - 0.014681760266069564*x0[23] - 2.6241663880765488e-316*x0[24] + 0.020396150536906014*x0[25] - 0.23606320247107435*x0[26] + 2.2054370082641609e-316*x0[27] + 0.27103253075289552*x0[28] + 6.0128092949251897e-316*x0[29] + 3.7260027923452007e-315*x0[30] + 0.13530830519993778*x0[31] + 0.16238930585268582*x0[32] + 5.4097241118039054e-316*x0[33] - 0.043209003672510238*x0[34] + 4.3830864306289664e-315*x0[35] - 0.030106365820035189*x0[36] - 4.8343676219569922e-316*x0[37] + 0.31363443019406168*x0[38] + 0.076147524611650905*x0[39] + 2.4269988696922137e-315*x0[40] + 3.2349822657648756e-316*x0[41] - 3.3476375036755912e-315*x0[42] - 6.1259799717615856e-316*x0[43] - 0.17850226649202344*x0[44] - 0.11128512852668694*x0[45] - 1.2780732465820651e-315*x0[46] - 1.1125381378936786e-315*x0[47] + 0.13702880328994632*x0[48] - 0.15825322607578995*x0[49] + 1.2276983380353739e-315*x0[50] + 0.1958735384914522*x0[51] - 0.11962967874457925*x0[52] - 4.3679077557387445e-315*x0[53] + 0.15833440120298811*x0[54] + 4.1077754096820108e-315*x0[55] - 1.4173582917796411e-315*x0[56] - 0.23621745012269893*x0[57] + 0.13598572811335924*x0[58] - 0.21600890203918824*x0[59] + 0.11567974644629454*x0[60] - 9.4311841336158297e-316*x0[61] + 0.10337047267289246*x0[62] - 1.0623399763911306e-315*x0[63] + 0.15666760022380757*x0[64] + 0.23768246607185087*x0[65] - 4.4063908055700809e-315*x0[66] + 1.0465307897456555e-316*x0[67] + 1.5442237173389748e-315*x0[68] + 1.8086856841666268e-315*x0[69] - 0.14097254853807686*x0[70] - 4.766321788598167e-316*x0[71] + 4.738666958137849e-316*x0[72] - 3.2708601025050347e-315*x0[73] + 0.11013721540294361*x0[74] + 0.18675641258819567*x0[75] + 3.6920315252884043e-315*x0[76] - 0.27068736829800027*x0[77] - 0.036128946827851331*x0[78] - 1.3798542280848828e-315*x0[79] - 0.049438306224489151*x0[80] - 1.1425426161085496e-316*x0[81] - 5.4401124098564046e-316*x0[82] + 0.64473610193934849*x0[83] - 0.019392119291802956*x0[84] + 0.42048700261231603*x0[85] + 0.069283766669278088*x0[86] - 0.12663149368950047*x0[87] + 0.16932681652887568*x0[88] + 0.0515859183147842*x0[89] + 0.087081127876916714*x0[90] + 0.21446598518947407*x0[91] + 0.06214564911070284*x0[92] - 1.615197596163283e-315*x0[93] + 0.026006173586733829*x0[94] + 0.46942333729579516*x0[95] + 4.0321178774669438e-315*x0[96] + 1.5877865376926231e-315*x0[97] + 8.6950889194297005e-316*x0[98] + 3.1573682533549032e-315*x0[99] - 0.3221770044009013*x0[100] - 2.1315171296287999e-315*x0[101] + 1.2114651689559201e-316*x0[102] - 3.9081726417293243e-315*x0[103] + 0.19415086138395268*x0[104] - 0.22634288441987377*x0[105] + 4.2051532386238396e-315*x0[106] + 0.32903122500970233*x0[107] - 0.11253413864222656*x0[108] + 4.1269168813637397e-315*x0[109] - 0.16564097227537167*x0[110] + 2.1583662378338799e-316*x0[111] + 2.3595168788703919e-315*x0[112] + 0.52475331147107773*x0[113] + 0.3258981296098169*x0[114] + 1.2495851200628148e-315*x0[115] + 0.4369774737670773*x0[116] + 2.7286753036363143e-316*x0[117] + 0.40365582445715703*x0[118] + 1.1051567378569328e-315*x0[119] + 4.2586108845897267e-315*x0[120] - 0.028392325058851493*x0[121] + 9.7352897895274025e-316*x0[122] + 9.6741194231026686e-316*x0[123] - 7.1049324130625109e-316*x0[124] + 1.5400007455783677e-315*x0[125] - 0.031245348104709837*x0[126] + 3.5100498556274688e-317*x0[127] + 4.289358244850341e-315*x0[128] + 4.3473430044477585e-316*x0[129] + 0.41157356305692971*x0[130] + 0.27610336456668466*x0[131] + 1.9633172235323476e-315*x0[132] + 0.012843150556949708*x0[133] - 0.23116750401753153*x0[134] + 5.4213035283454867e-316*x0[135] + 0.049761272983511344*x0[136] + 3.4881704845847154e-315*x0[137] + 3.5225504130998129e-315*x0[138] - 0.12606027997680164*x0[139] + 0.08585887508236123*x0[140] - 0.11598433043679698*x0[141] - 0.016225668470037851*x0[142] - 2.001587197672602e-315*x0[143] - 1.1161932568754958*x0[144] - 7.9361056695408942e-316*x0[145] - 0.11685165970855191*x0[146] + 0.29392391440965721*x0[147] + 7.6892982393679037e-316*x0[148] + 2.7275697279999589e-315*x0[149] + 2.0379832252840887e-315*x0[150] - 1.3995647991620868e-315*x0[151] - 0.33860358939092011*x0[152] + 6.2828998650978364e-316*x0[153] - 2.0327463418863992e-316*x0[154] + 1.3379979994037863e-315*x0[155] + 0.035443266990276667*x0[156] - 0.048312666759740434*x0[157] + 9.5652766625107128e-316*x0[158] - 0.19689829052635352*x0[159] + 0.029616782696256155*x0[160] + 4.5124173228115511e-315*x0[161] + 0.24717447544636675*x0[162] - 1.2654639502017277e-315*x0[163] + 3.5249275111416489e-315*x0[164] + 0.15827549804410543*x0[165] + 0.10686237236390256*x0[166] - 0.16854080470628283*x0[167] + 0.042222595871171206*x0[168] + 1.0827163552733268e-315*x0[169] + 0.23800517547828104*x0[170] - 1.0791512763860655e-316*x0[171] - 0.045033098103362271*x0[172] - 0.089116016475911108*x0[173] - 2.5373250772077772e-315*x0[174] - 3.4812872114134198e-315*x0[175] - 2.1720336252013509e-316*x0[176] + 4.7550379221259279e-316*x0[177] + 0.2977433028647376*x0[178] + 1.5386723413950815e-315*x0[179] - 3.7503931976857212e-315*x0[180] + 3.9209978250342684e-315*x0[181] - 0.019811460094703529*x0[182] + 0.14879756594080343*x0[183] + 6.0052516221473207e-316*x0[184] + 0.081101073016967298*x0[185] - 0.11373166707524276*x0[186] + 1.5121301023032899e-315*x0[187] - 0.081805316477419482*x0[188] + 4.0307231103861081e-316*x0[189] - 4.2871069210999668e-315*x0[190] + 0.068180144197317064*x0[191] - 0.12715299017359996*x0[192] + 0.22242628903295669*x0[193] + 0.085477871348458884*x0[194] - 3.1752222690140731e-315*x0[195] + 0.0027282081744045804*x0[196] + 1.9985552156172034e-315*x0[197] + 0.19710054621499934*x0[198] - 0.12941398279204377*x0[199] + 3.4531573121313432e-315*x0[200] - 1.621371104509076e-315*x0[201] + 3.7042373824843171e-315*x0[202] + 7.9530832473289369e-316*x0[203] + 0.062388840116023851*x0[204] - 3.8162855273513924e-315*x0[205] - 6.6778090555535386e-316*x0[206] + 1.236097582471743e-315*x0[207] + 0.22506284120091843*x0[208] + 0.12849128595681772*x0[209] + 2.4244628653167058e-315*x0[210] - 0.16051125832721633*x0[211] - 0.15916880628328395*x0[212] + 1.5523593085840971e-315*x0[213] + 0.37356789384284522*x0[214] + 2.1359221398766171e-315*x0[215] - 1.2911914552809012e-315*x0[216] + 0.11538269556462218*x0[217] + 0.024322405024433155*x0[218] - 0.51934445836637055*x0[219] + 0.065331610888346409); +x1[1] = relu(0.36548106268703812*x0[0] + 0.10043923039264817*x0[1] + 0.11372761339710191*x0[2] - 0.10902695157359135*x0[3] + 0.039492437455893419*x0[4] + 0.13311261929796794*x0[5] - 0.16794813689797758*x0[6] - 0.29484466185566094*x0[7] - 0.2279349785452707*x0[8] + 0.03649574346044749*x0[9] - 0.046185881571367736*x0[10] - 3.7359790103319353e-315*x0[11] + 0.067191796057522485*x0[12] - 0.22665399842064352*x0[13] - 3.1973052692127599e-315*x0[14] - 2.1154938297543866e-315*x0[15] - 1.3906422898002072e-315*x0[16] - 9.834994262527314e-317*x0[17] - 0.091898939274539265*x0[18] - 0.19446164871570823*x0[19] - 3.0224282388357392e-315*x0[20] + 1.1646676662343539e-316*x0[21] - 0.13848524184531869*x0[22] - 0.028012937425625307*x0[23] - 3.1766618626709559e-315*x0[24] - 0.24382259236688439*x0[25] - 0.31126269617490543*x0[26] - 3.0013671047310329e-315*x0[27] + 0.33703119586022612*x0[28] - 1.479111270295264e-315*x0[29] - 2.3234112383422484e-316*x0[30] + 0.21509915755719691*x0[31] + 0.04138984849918198*x0[32] - 4.1371351964575929e-315*x0[33] + 0.38030207207019318*x0[34] - 1.6734343391213924e-315*x0[35] + 0.028446886895532229*x0[36] - 8.8257142438417635e-316*x0[37] + 0.1566930104510405*x0[38] + 0.59082679533470239*x0[39] - 1.9058716180116108e-316*x0[40] - 9.0032153309736939e-316*x0[41] - 1.2805411538896067e-315*x0[42] + 2.3147317993968098e-315*x0[43] - 0.55014602713367744*x0[44] - 0.14779051416223424*x0[45] - 3.357890927074238e-316*x0[46] + 1.3861036545578158e-315*x0[47] + 0.091613146206414642*x0[48] + 0.2003748034695832*x0[49] - 2.2260968079040939e-316*x0[50] - 0.41814470166685047*x0[51] - 0.23713700531236087*x0[52] + 2.259913550989497e-315*x0[53] - 0.206479900539359*x0[54] - 9.9146012319988245e-316*x0[55] + 4.092387280601891e-315*x0[56] + 0.068708461570517507*x0[57] + 0.013561631936672158*x0[58] - 0.072595277563544211*x0[59] - 0.34565552957792384*x0[60] + 4.0679494548406827e-315*x0[61] - 0.17819904216398916*x0[62] - 3.729558894059677e-315*x0[63] + 0.19834166097138436*x0[64] + 0.21528954546253617*x0[65] - 4.444249756618247e-315*x0[66] - 8.7504071276860094e-316*x0[67] - 4.0799647113917429e-315*x0[68] - 1.2283358012942641e-315*x0[69] - 0.3470024405709512*x0[70] + 2.9852109160198577e-315*x0[71] + 3.8135876818922762e-316*x0[72] - 1.065606674212899e-315*x0[73] - 0.053409106333301544*x0[74] + 0.16555310817081342*x0[75] - 6.1063799923385467e-316*x0[76] - 0.22411196307041836*x0[77] - 0.24315334255468815*x0[78] + 2.1031483990135237e-315*x0[79] - 0.040007247322914642*x0[80] - 3.5879797785520486e-315*x0[81] + 6.3430485531735352e-316*x0[82] - 0.087292817249553484*x0[83] + 0.079061536190714529*x0[84] - 0.50461906181206861*x0[85] - 0.004474011393827069*x0[86] - 0.17516021077108407*x0[87] - 0.12678060556747633*x0[88] - 0.22655047806958725*x0[89] - 0.25598917943996791*x0[90] - 0.3935891074154152*x0[91] - 0.066000298044610078*x0[92] - 2.3199672549447828e-316*x0[93] + 0.013518080571751821*x0[94] - 0.55648968841772528*x0[95] - 3.3972171196928283e-316*x0[96] + 3.5599175316788571e-316*x0[97] - 8.4056923388932903e-316*x0[98] - 6.5469049793040919e-316*x0[99] + 0.14273099432396447*x0[100] - 4.0461808681376963e-315*x0[101] - 5.3595983358591296e-316*x0[102] - 1.0358587050000358e-315*x0[103] - 0.52192100938332164*x0[104] + 0.21852905329759689*x0[105] + 3.4016278413395114e-316*x0[106] - 0.62277209500568143*x0[107] - 0.16704758454400409*x0[108] + 1.1431360383557695e-316*x0[109] + 0.13459019061375765*x0[110] - 5.6774864964336544e-316*x0[111] - 1.7762897009556871e-315*x0[112] - 0.38742658320129442*x0[113] - 0.37278676318778525*x0[114] + 1.3634040604331191e-315*x0[115] - 0.88161355349528625*x0[116] - 3.3824469679225267e-315*x0[117] + 0.055998092321175537*x0[118] - 4.0750344648964883e-315*x0[119] - 3.5486487836153807e-316*x0[120] + 0.03203576329269054*x0[121] + 2.4836971021104864e-316*x0[122] - 3.7765802332220916e-315*x0[123] - 4.3295541708692444e-316*x0[124] - 2.8544910817904017e-315*x0[125] - 0.043230491889202777*x0[126] - 1.7713481156538604e-316*x0[127] - 2.8462000970183493e-315*x0[128] - 1.4877908673417092e-315*x0[129] + 0.26980771940774678*x0[130] - 0.14098095658199894*x0[131] - 9.5813458512023119e-316*x0[132] + 0.11320682689940034*x0[133] - 0.375189750919734*x0[134] + 2.3451654427942843e-315*x0[135] - 0.28625386615667325*x0[136] + 1.4901665968217062e-315*x0[137] + 7.8890110357399191e-316*x0[138] + 0.083882858024735357*x0[139] + 0.2396443825699188*x0[140] - 0.26414838026816639*x0[141] - 0.20224505780353061*x0[142] + 4.8620925109258905e-316*x0[143] - 0.34868541515203183*x0[144] - 1.1107253270479272e-315*x0[145] - 0.15499857984136145*x0[146] - 0.042924624090722951*x0[147] + 2.4977846181998985e-315*x0[148] + 1.7375889954447318e-315*x0[149] + 3.9386007466509089e-315*x0[150] + 2.4415590188597505e-315*x0[151] - 0.025994887525081101*x0[152] + 2.6852633956341882e-315*x0[153] + 3.8978268527581875e-315*x0[154] - 2.6411640002265304e-315*x0[155] + 0.049563497368312878*x0[156] - 0.23570376697210341*x0[157] + 3.2169083563087112e-317*x0[158] + 0.078906175810176338*x0[159] - 0.14330725336833172*x0[160] - 1.4958919135168744e-315*x0[161] - 0.29536324915647555*x0[162] + 1.308528460885637e-315*x0[163] - 3.034739999002838e-315*x0[164] + 0.22092396413219087*x0[165] - 0.078449334930107278*x0[166] - 0.13658351038020106*x0[167] - 0.21651836059143725*x0[168] + 4.3679225381828681e-315*x0[169] + 0.14432812381438595*x0[170] - 1.0538141375143276e-315*x0[171] - 0.19256348568677681*x0[172] - 0.16396710637105699*x0[173] - 2.3549321818878386e-315*x0[174] - 3.2801697468850261e-315*x0[175] + 9.1663695916619925e-316*x0[176] - 3.2978541942738868e-316*x0[177] + 0.25810564906734657*x0[178] + 1.0924352885749895e-315*x0[179] + 2.3688530545755649e-315*x0[180] - 5.0076492896603093e-316*x0[181] - 0.067761734007159541*x0[182] - 0.022124100031660293*x0[183] - 4.8837923681568838e-316*x0[184] - 0.14960171980744152*x0[185] - 0.22548851809699808*x0[186] + 4.4853849854210544e-315*x0[187] - 0.22950338273945475*x0[188] + 2.1047289891244167e-316*x0[189] + 4.008593460509141e-315*x0[190] - 0.17830743375114533*x0[191] - 0.021307545215911463*x0[192] - 0.20412857554357877*x0[193] - 0.072747082717303277*x0[194] - 1.1583690950516291e-315*x0[195] + 0.33770661755256498*x0[196] + 3.3989691901080799e-315*x0[197] - 0.20341865459649677*x0[198] - 0.3776218289283701*x0[199] + 6.7289018661869194e-317*x0[200] - 3.9937100343082174e-315*x0[201] + 1.699490383033081e-315*x0[202] - 8.8798014381348943e-316*x0[203] + 0.34505179889299287*x0[204] + 1.3632815074496681e-315*x0[205] - 1.2665359639587611e-315*x0[206] - 2.8994800127494579e-315*x0[207] - 0.022392931874527434*x0[208] + 0.24201861277042419*x0[209] - 3.3455319144687709e-315*x0[210] + 0.12031738839393706*x0[211] - 0.3220041904631617*x0[212] + 1.0737146620103882e-315*x0[213] - 0.20892426411462492*x0[214] - 9.1796227543919902e-316*x0[215] + 1.0435598050348925e-315*x0[216] - 0.74262290795371155*x0[217] - 0.20921812114562088*x0[218] - 0.688297814981082*x0[219] + 0.31495767376215922); +x1[2] = relu(0.12974666418603656*x0[0] - 0.30537922411437174*x0[1] - 0.10554178861101569*x0[2] - 0.093229905782649614*x0[3] - 1.2627542502560476*x0[4] - 2.8761481666402271*x0[5] + 0.28862250586041571*x0[6] - 0.32968335907188689*x0[7] + 0.17231214846602189*x0[8] + 0.20356302158615994*x0[9] + 0.25671502615591174*x0[10] - 4.4504522764987639e-315*x0[11] - 0.25980656890923326*x0[12] + 0.12021114350411655*x0[13] - 3.4636124822958127e-315*x0[14] + 1.7851108774536046e-315*x0[15] + 4.3741849388196609e-315*x0[16] + 1.2194750501381147e-315*x0[17] - 0.22808722828315869*x0[18] + 0.025977818706774018*x0[19] - 3.0586020801856346e-315*x0[20] - 5.9367204681045856e-317*x0[21] + 0.33282389620520131*x0[22] + 0.27191901465232898*x0[23] - 1.7338703214294914e-315*x0[24] - 0.31437166736238537*x0[25] + 0.085911462193404342*x0[26] - 2.3655732244889301e-315*x0[27] - 0.051110051946586535*x0[28] - 8.4703463621868509e-316*x0[29] - 4.0728105469674889e-315*x0[30] - 0.16365764447490302*x0[31] + 0.29667729202004578*x0[32] + 3.7857149931854246e-315*x0[33] - 0.17266905815002792*x0[34] - 9.373188237778755e-316*x0[35] + 0.01914531278889792*x0[36] + 1.5382989858678322e-315*x0[37] + 0.068833526215544144*x0[38] + 0.3498541146353118*x0[39] + 2.0565565511170389e-316*x0[40] - 4.4762403490854611e-315*x0[41] - 2.7960274144811574e-315*x0[42] - 2.3118489658785778e-315*x0[43] - 0.37996502221194778*x0[44] - 0.12430056687693675*x0[45] + 5.0410845893638406e-316*x0[46] - 1.7631042795663907e-315*x0[47] + 0.10725022545286172*x0[48] - 0.29690019497500109*x0[49] + 4.090352634281157e-315*x0[50] - 0.25305838507352335*x0[51] - 0.24656182547798255*x0[52] + 1.2071072036388999e-315*x0[53] - 0.32248900036029138*x0[54] + 9.779865429633056e-317*x0[55] - 2.8326887257005221e-315*x0[56] - 0.03603310017105088*x0[57] - 0.0023155656416912595*x0[58] - 0.16848734126075851*x0[59] - 0.25009700094280907*x0[60] + 1.1020627555036377e-315*x0[61] - 0.46418770264284182*x0[62] - 2.4496279211239972e-315*x0[63] - 0.38450219279104375*x0[64] + 0.47113140218856103*x0[65] - 1.2757586626663974e-315*x0[66] - 2.1709366463072331e-315*x0[67] - 3.8160887706485925e-315*x0[68] + 1.6888165739983573e-316*x0[69] - 0.43677616711778833*x0[70] - 1.7141429965862369e-315*x0[71] - 8.2072269100573304e-316*x0[72] - 1.2167931185334511e-315*x0[73] - 0.16030378289623223*x0[74] - 0.45731941201834808*x0[75] + 3.5514364008023462e-316*x0[76] - 0.10806081391489798*x0[77] + 0.80879647653360165*x0[78] - 1.2275193084079468e-315*x0[79] - 0.29014636346191808*x0[80] + 3.8683545919383297e-315*x0[81] + 3.7389538487547359e-315*x0[82] - 0.21875317143948755*x0[83] - 0.28059810809589525*x0[84] - 0.54128709561644439*x0[85] - 0.15416412440858715*x0[86] - 0.10753239496175063*x0[87] - 0.27781805629148842*x0[88] - 0.24102081324789762*x0[89] - 0.33258640932140732*x0[90] - 0.3355512273027943*x0[91] - 0.33872585364621755*x0[92] - 3.3523537110517545e-315*x0[93] - 0.356009775928392*x0[94] - 0.26479121770408459*x0[95] - 3.3239067056162076e-315*x0[96] + 6.2287572366392422e-317*x0[97] - 1.9860922515998513e-315*x0[98] + 4.1103009793910785e-316*x0[99] - 0.28588739249727124*x0[100] - 8.0866515725735825e-316*x0[101] - 3.6781052030566044e-315*x0[102] + 2.5073433605972102e-315*x0[103] - 0.21356245929500633*x0[104] + 0.032695010504490168*x0[105] - 1.1919412509390585e-315*x0[106] - 0.22093929303911466*x0[107] + 0.29489802388469044*x0[108] + 3.4348119877126358e-315*x0[109] - 0.34612118997558455*x0[110] + 6.069552833163186e-316*x0[111] + 1.0915665334246552e-315*x0[112] - 0.0032151282484916273*x0[113] - 0.18604707239205276*x0[114] - 1.4585578775734758e-315*x0[115] + 0.31428750982487624*x0[116] - 9.5637626971521615e-316*x0[117] - 0.025399265795624123*x0[118] + 9.6066063901363185e-316*x0[119] - 6.61072650198441e-316*x0[120] - 0.020949738525819189*x0[121] - 4.0309444913206967e-315*x0[122] - 1.4834561576946388e-315*x0[123] - 4.3506648301142898e-315*x0[124] + 6.0486953084517874e-316*x0[125] - 0.016202071466653829*x0[126] - 4.1225052753395505e-315*x0[127] - 3.4878171337754662e-315*x0[128] - 1.4630640675249049e-315*x0[129] + 0.32109194354401166*x0[130] + 0.061701822726256086*x0[131] + 2.028563784695622e-315*x0[132] + 0.068077758747455044*x0[133] + 0.50188942151013205*x0[134] + 4.0726512009153922e-315*x0[135] + 0.12260244327259055*x0[136] - 3.5474196125170617e-315*x0[137] + 7.4900284716605142e-316*x0[138] - 0.026540946740957236*x0[139] + 0.062466186966101095*x0[140] - 0.12054904798610294*x0[141] - 0.24679433645566526*x0[142] + 1.9639496868469019e-315*x0[143] + 0.17149688708000566*x0[144] - 9.7374733126491979e-316*x0[145] - 0.16622159384746388*x0[146] - 0.012828716930871028*x0[147] - 1.6241808410150058e-315*x0[148] - 1.8796890537693352e-316*x0[149] - 1.110881753172057e-316*x0[150] - 7.3243697922134463e-316*x0[151] + 0.14733011115990149*x0[152] + 1.7572615629924577e-317*x0[153] - 3.1418629566068721e-315*x0[154] - 2.2541537089869974e-315*x0[155] - 0.10726609782367032*x0[156] + 0.27318105405295545*x0[157] + 6.6563864185564267e-316*x0[158] - 0.24065839662921507*x0[159] - 0.24408484690853133*x0[160] + 1.2480550284015832e-316*x0[161] - 0.16141434425690054*x0[162] - 1.7354897253375217e-315*x0[163] - 3.6318273981065857e-315*x0[164] - 0.013899596317506788*x0[165] - 0.17603263217297518*x0[166] - 0.28005343488926765*x0[167] + 0.33207308453132317*x0[168] + 1.3385554981378971e-315*x0[169] + 0.19721126196447789*x0[170] - 2.9997139215547964e-315*x0[171] - 0.23216808680726522*x0[172] + 0.018241773999925142*x0[173] - 1.416954027505588e-315*x0[174] + 3.5548116152025672e-315*x0[175] - 3.0147533786273331e-315*x0[176] - 4.2790816201289656e-315*x0[177] - 0.089946746727668656*x0[178] + 3.8178907614566999e-315*x0[179] - 6.3603166415613326e-316*x0[180] - 3.4391673246004201e-315*x0[181] + 0.29175113631408162*x0[182] - 0.012573416067162066*x0[183] + 6.8287154288814327e-316*x0[184] - 0.19027619698542975*x0[185] - 0.15614459016677595*x0[186] - 1.6302166779685852e-315*x0[187] - 0.17094637136663515*x0[188] - 1.2708845864944185e-315*x0[189] - 3.7313139436907731e-316*x0[190] - 0.25783033875386069*x0[191] - 0.29985741178482467*x0[192] - 0.10781083749249318*x0[193] - 0.29043520753278751*x0[194] - 4.4670102393931372e-315*x0[195] + 0.17754310836985715*x0[196] - 1.187355160691384e-315*x0[197] - 0.14254923640834669*x0[198] + 0.10614656597632453*x0[199] + 3.7602730185242956e-315*x0[200] + 2.9439053037384255e-315*x0[201] - 4.0243015415608511e-316*x0[202] - 2.7604792183399037e-315*x0[203] + 0.10472560659253061*x0[204] - 3.7503109653996273e-316*x0[205] + 3.0142320603204673e-315*x0[206] + 4.0457042677124356e-316*x0[207] - 0.26492322524543993*x0[208] - 0.046839947658766194*x0[209] + 4.2637447997661664e-315*x0[210] - 0.29773189644440901*x0[211] - 0.098758467620957621*x0[212] + 4.4022057237038534e-315*x0[213] - 0.33651676574224038*x0[214] - 4.1968792595913171e-315*x0[215] - 2.4005724692317461e-315*x0[216] - 0.03995719902042804*x0[217] - 0.32334995233413216*x0[218] + 0.52696685749471195*x0[219] + 0.081428598376102876); +x1[3] = relu(0.30552176448799473*x0[0] + 0.18517317183165111*x0[1] - 0.081709701477156185*x0[2] + 0.047233622702488522*x0[3] + 0.096348891497154573*x0[4] + 0.46337947070106161*x0[5] + 0.37438361213272697*x0[6] - 0.065202792719418576*x0[7] + 0.065085391214392413*x0[8] + 0.35942748261478846*x0[9] - 0.14474283198332219*x0[10] - 4.1072286914602922e-315*x0[11] - 0.17446752717277222*x0[12] + 0.27303931640425044*x0[13] + 1.1046039031025188e-315*x0[14] - 4.5458549545049308e-315*x0[15] + 3.0098326280737916e-315*x0[16] - 2.7830259238504948e-315*x0[17] + 0.18361961510700617*x0[18] - 0.010978724954091459*x0[19] - 4.4939436500193671e-315*x0[20] + 8.8396716971499078e-316*x0[21] - 0.39899130272347921*x0[22] + 0.20539064490895417*x0[23] + 3.5348216203587012e-315*x0[24] + 0.063681188430122437*x0[25] + 0.10132352316511242*x0[26] - 2.326954528934528e-316*x0[27] + 0.042663554669163779*x0[28] + 4.6285632926111418e-316*x0[29] + 2.5373992166985922e-315*x0[30] + 0.019057102672238268*x0[31] - 0.032563176346525773*x0[32] + 9.4780566355024346e-316*x0[33] - 0.24070633059049032*x0[34] + 1.9664434041437822e-315*x0[35] + 0.05047044189830293*x0[36] + 4.5012343988914139e-315*x0[37] - 0.11137046611983535*x0[38] + 0.15969071198053142*x0[39] - 1.7514868743173006e-316*x0[40] + 1.4534978350924023e-315*x0[41] + 3.7720467412030734e-316*x0[42] - 1.3592953413531128e-316*x0[43] - 0.050020564987897212*x0[44] + 0.083073960257907281*x0[45] + 5.3949474482483916e-316*x0[46] - 2.7088664332582137e-316*x0[47] + 0.11840416593891791*x0[48] + 0.14764492482759922*x0[49] - 7.3733936041417378e-316*x0[50] - 0.054063768786389979*x0[51] + 0.22655233428422489*x0[52] + 4.3612726220974161e-315*x0[53] + 0.055958206826821177*x0[54] + 2.0005259743092738e-315*x0[55] - 6.7454700117742535e-316*x0[56] - 0.08435946810228187*x0[57] + 0.18378472874771609*x0[58] + 0.15879754061552781*x0[59] - 0.089661631177470016*x0[60] + 1.3645574813866177e-315*x0[61] + 1.2341645619150532*x0[62] - 5.4657643970016113e-316*x0[63] - 0.094802215141132434*x0[64] - 0.0049400144007782738*x0[65] + 1.3502225273404554e-315*x0[66] - 1.0462315737092212e-315*x0[67] - 6.3504110206147323e-317*x0[68] - 6.2562028797051109e-316*x0[69] - 0.041551354996453356*x0[70] + 1.4113916338977925e-315*x0[71] + 4.0375933006991019e-315*x0[72] - 1.1816203134699075e-315*x0[73] + 0.040820155808511394*x0[74] - 0.011164962198379039*x0[75] + 3.2157816297220573e-315*x0[76] + 0.10958051058793751*x0[77] + 0.084793781240607463*x0[78] - 1.9644303534324279e-315*x0[79] - 0.027768960962353251*x0[80] - 3.9972914223024479e-315*x0[81] + 3.6505630887327287e-315*x0[82] - 1.8947531124803547*x0[83] - 0.55737924741212308*x0[84] - 0.13347503084545892*x0[85] + 0.031259258019895361*x0[86] + 0.032025138009694115*x0[87] - 0.11382083014959343*x0[88] + 0.12855196893434143*x0[89] - 0.020824254826141055*x0[90] - 0.11182752448799671*x0[91] - 0.13745606696236123*x0[92] - 1.9856479383645463e-315*x0[93] + 0.13928153979382682*x0[94] - 0.23447101356988911*x0[95] - 5.101494094693979e-316*x0[96] + 4.2078409260932772e-315*x0[97] - 1.0554171878494806e-315*x0[98] + 6.5615339172314992e-316*x0[99] + 0.064714709002614959*x0[100] + 3.713432507388259e-315*x0[101] - 7.6046209212059475e-316*x0[102] + 2.8027790636237445e-315*x0[103] - 0.20304240848063088*x0[104] - 0.18700773689401523*x0[105] + 1.7781201054790868e-315*x0[106] - 0.43520363092997966*x0[107] - 0.04642389817576692*x0[108] + 7.6928135658446287e-316*x0[109] - 0.094120205864645451*x0[110] - 2.4514245908450989e-315*x0[111] + 3.334621951936648e-315*x0[112] - 0.38579360652605188*x0[113] - 0.24243533086032254*x0[114] + 2.8705802504967186e-315*x0[115] + 0.06457611639469471*x0[116] + 6.480962729245565e-316*x0[117] + 0.055557656474422165*x0[118] - 3.2377619284949431e-315*x0[119] + 1.3812494052402045e-315*x0[120] + 0.17143134952620767*x0[121] + 5.524312361791349e-316*x0[122] + 1.1806420387878596e-315*x0[123] + 1.3999378533092921e-315*x0[124] + 1.5459968398913957e-315*x0[125] + 0.12838932295480834*x0[126] + 3.7286281386114461e-315*x0[127] - 1.1363692806857326e-315*x0[128] + 4.1065530171643527e-315*x0[129] + 0.0087151682768617407*x0[130] - 0.10969391276032552*x0[131] - 4.1074001421207121e-315*x0[132] - 0.013896146060786979*x0[133] + 0.017558500986448584*x0[134] + 1.1853380141758256e-315*x0[135] + 0.15495996298577536*x0[136] + 2.6733884537265469e-315*x0[137] + 2.0967761774649733e-315*x0[138] + 0.070128087740295053*x0[139] + 0.13555023978469949*x0[140] + 0.0014239841419500948*x0[141] + 0.20313047672368476*x0[142] - 3.0367491614175596e-315*x0[143] + 0.57118167714209844*x0[144] - 3.3784875406587243e-315*x0[145] + 0.19951587068147847*x0[146] - 0.10434501865160488*x0[147] - 7.4095749701114193e-316*x0[148] + 8.9416837037487209e-316*x0[149] - 2.1655977284723645e-316*x0[150] - 2.9750305007016969e-315*x0[151] + 0.044187630905968757*x0[152] - 2.783150517325063e-315*x0[153] + 2.9114812823020843e-315*x0[154] - 8.9711087220115234e-316*x0[155] + 0.15685560342292165*x0[156] + 0.079089044732057245*x0[157] + 2.1538893805598445e-315*x0[158] + 0.11906038233020137*x0[159] - 0.091651444802566914*x0[160] + 6.3094315361254635e-316*x0[161] + 0.093912268526120252*x0[162] + 3.1290691020045307e-315*x0[163] + 4.4417149132970068e-315*x0[164] + 0.26888719965906627*x0[165] + 0.14078901397361382*x0[166] - 0.14586115972566185*x0[167] - 0.04791248262903839*x0[168] + 6.5715151302219132e-316*x0[169] - 0.078851612593291445*x0[170] - 4.8667980909500117e-317*x0[171] + 0.046191178126052244*x0[172] + 0.070270588514731752*x0[173] + 6.4208723409160754e-316*x0[174] - 7.4617367905827069e-316*x0[175] - 3.8015832157349212e-315*x0[176] + 2.5745245197879357e-315*x0[177] - 0.043453602962628499*x0[178] + 2.8176762890781564e-315*x0[179] - 3.7882695349039645e-316*x0[180] + 1.0998772758818847e-315*x0[181] + 0.020728707539182618*x0[182] + 0.011887117037732032*x0[183] + 1.6256864714861118e-315*x0[184] - 0.061522126351435391*x0[185] + 0.016189288465616663*x0[186] - 4.4693029213787247e-315*x0[187] + 0.02741990526158114*x0[188] - 3.5031275166855564e-315*x0[189] + 8.165887399931937e-316*x0[190] + 0.13376105932333801*x0[191] + 0.0077975553109673728*x0[192] - 0.0012653582390094169*x0[193] - 0.11414584533883582*x0[194] - 4.3517278914018206e-315*x0[195] - 0.25977500527406*x0[196] + 1.0024994568213688e-315*x0[197] + 0.01431189070188311*x0[198] - 0.071470385852233878*x0[199] - 3.8317202072966633e-315*x0[200] - 3.2869852688343075e-315*x0[201] + 1.8887983644112509e-315*x0[202] - 3.705619175401293e-315*x0[203] + 0.010830751590326267*x0[204] + 1.4989402442044938e-315*x0[205] - 3.7355935699589887e-315*x0[206] - 1.3922581463169004e-315*x0[207] + 0.075713222414364109*x0[208] - 0.23193115923725827*x0[209] - 6.4107221080682191e-316*x0[210] + 0.094734645059620023*x0[211] + 0.079705999385160597*x0[212] - 1.3901727792169643e-315*x0[213] + 0.18165002969943983*x0[214] + 4.4479483073397323e-316*x0[215] + 1.3559124491727555e-315*x0[216] + 0.0072678091832688438*x0[217] - 0.099986995734145392*x0[218] + 0.027386461334829255*x0[219] - 0.080243531666927381); +x1[4] = relu(0.29069400172231313*x0[0] + 0.16760523031018423*x0[1] + 0.020929512561935086*x0[2] + 0.03236475923353458*x0[3] + 0.42135771384245102*x0[4] - 0.072427199557434652*x0[5] + 0.42910503060156979*x0[6] - 0.0081560934888373609*x0[7] - 0.25531675480131288*x0[8] + 0.37456942407176813*x0[9] + 0.046263189836989974*x0[10] + 4.3405005410988093e-316*x0[11] - 0.19251435587885468*x0[12] - 0.014008349040404502*x0[13] + 1.5134598602264458e-315*x0[14] + 3.7621511991956482e-315*x0[15] - 2.7766333764412745e-315*x0[16] - 3.2962371717622694e-315*x0[17] + 0.13229714829708705*x0[18] + 0.047433835880700652*x0[19] + 1.7587620255369082e-315*x0[20] - 1.5738506948158278e-315*x0[21] - 0.37438543065305196*x0[22] + 0.38590054936509893*x0[23] + 2.0599488601886059e-315*x0[24] - 0.149573040069201*x0[25] + 0.046660845204104746*x0[26] - 3.6384242762449566e-315*x0[27] + 0.21560565418651767*x0[28] - 2.1261787503254852e-316*x0[29] + 7.8332203525064922e-316*x0[30] + 0.14008122810411006*x0[31] + 0.1311992857204671*x0[32] - 4.4633242181764305e-315*x0[33] + 0.18977734074024533*x0[34] + 4.16921144014517e-316*x0[35] + 0.075398773582794204*x0[36] - 7.1458073038545551e-317*x0[37] + 0.078154796418435896*x0[38] + 0.054360166921264975*x0[39] + 2.3533977622115495e-316*x0[40] + 1.3568651065510666e-315*x0[41] - 6.2745403237767671e-317*x0[42] - 3.577251973082891e-316*x0[43] - 0.23723728706144825*x0[44] + 0.13162900657254314*x0[45] + 1.3694276939652462e-315*x0[46] - 9.4459057582583968e-316*x0[47] + 0.059606286346456198*x0[48] + 0.12442730135383319*x0[49] + 9.4115114771362876e-316*x0[50] - 0.12802961488244277*x0[51] + 0.20876362504895743*x0[52] + 1.0035538176128764e-315*x0[53] - 0.078373113914876405*x0[54] - 1.5176751887915116e-315*x0[55] - 8.2703033817437198e-316*x0[56] - 0.098988147857606665*x0[57] - 0.068379396357125935*x0[58] - 0.10381362819727652*x0[59] + 0.015176873026743899*x0[60] - 5.7924985559321007e-316*x0[61] + 0.99202343312919727*x0[62] - 1.2411030751648592e-315*x0[63] - 0.0065978473910931635*x0[64] - 0.20766923669838144*x0[65] + 3.1708337210335753e-315*x0[66] + 7.0222553196677429e-317*x0[67] - 1.5848530130391278e-315*x0[68] + 2.9042677558904825e-315*x0[69] + 0.26893834725147175*x0[70] + 5.9583420159307131e-316*x0[71] + 3.7315638124505008e-315*x0[72] - 7.5884916541318141e-316*x0[73] + 0.15125459878355413*x0[74] + 0.15760147433434496*x0[75] - 3.3880443512593607e-315*x0[76] - 0.10004369164930388*x0[77] - 0.1550031726860723*x0[78] + 1.9748172733685809e-315*x0[79] - 0.033518701518102177*x0[80] - 1.960936864657249e-316*x0[81] - 4.4655025042023799e-315*x0[82] - 1.7671486848735229*x0[83] - 0.68482534657288574*x0[84] - 0.090323811232421738*x0[85] + 0.028451753328348508*x0[86] + 0.012805021461149684*x0[87] - 0.3041490617344228*x0[88] + 0.13189207703371161*x0[89] - 0.019767775256588266*x0[90] - 0.17135204038276811*x0[91] - 0.08605469202017979*x0[92] - 3.2298243340573916e-315*x0[93] + 0.0097057972387141755*x0[94] - 0.49593235444809408*x0[95] - 6.001651316379511e-316*x0[96] + 2.7239331775763702e-315*x0[97] + 3.6303216342377553e-315*x0[98] + 5.7192169112980374e-316*x0[99] + 0.064983271309508525*x0[100] - 1.5828267954783118e-316*x0[101] + 2.5273010731917769e-315*x0[102] - 3.4213279234030542e-315*x0[103] - 0.0071998530002897274*x0[104] - 0.35895989443243603*x0[105] + 1.9976576020924955e-316*x0[106] - 0.231295999518454*x0[107] + 0.15602249556905129*x0[108] + 6.0784705698509268e-316*x0[109] + 0.18772016610246597*x0[110] + 2.4675237396774618e-315*x0[111] - 5.6736836237510497e-316*x0[112] - 0.43115698204550812*x0[113] - 0.28944888590534107*x0[114] - 8.1204229357294151e-316*x0[115] + 0.14670726586780791*x0[116] - 2.0794588109696596e-315*x0[117] + 0.1945711455940165*x0[118] - 4.5423527751150416e-315*x0[119] + 2.2099861572234959e-315*x0[120] + 0.088671774119677027*x0[121] - 1.0563074941432865e-315*x0[122] - 3.6042993992382117e-316*x0[123] - 4.0656706165744916e-315*x0[124] - 2.9154620581424435e-315*x0[125] + 0.13073816524731313*x0[126] + 3.3804180626445973e-315*x0[127] + 2.4065117459955023e-315*x0[128] - 2.2287503356747781e-316*x0[129] + 0.029612306127695161*x0[130] + 0.1323268544044898*x0[131] + 1.9321391615449711e-316*x0[132] + 0.0048520978511106842*x0[133] - 0.04275178437267102*x0[134] + 3.1511805455624486e-315*x0[135] + 0.26545524227159834*x0[136] - 4.1940955751668925e-315*x0[137] + 3.8504886445938127e-315*x0[138] - 0.25941328135839392*x0[139] - 0.059293247549308224*x0[140] - 0.10160476599151444*x0[141] + 0.20628346224426189*x0[142] + 2.3895004729304131e-316*x0[143] + 0.44648842260616167*x0[144] - 3.8671634836573662e-315*x0[145] + 0.056031654432887781*x0[146] + 0.066655385868827882*x0[147] - 3.7598768470455214e-315*x0[148] - 2.9922050179968285e-315*x0[149] + 1.8315454790769875e-315*x0[150] - 3.5811830310973091e-315*x0[151] + 0.22971347835549064*x0[152] - 7.9845118994118841e-316*x0[153] - 4.3841913788019516e-315*x0[154] + 2.9663883192466112e-316*x0[155] + 0.014092990295056864*x0[156] + 0.10001567461616452*x0[157] + 1.1519066472348352e-315*x0[158] + 0.12897295687930499*x0[159] - 0.054184268860286905*x0[160] - 9.0136410548256713e-316*x0[161] - 0.12528924749102494*x0[162] - 8.7516002468141514e-316*x0[163] + 2.9695675378051269e-315*x0[164] + 0.27304335818561815*x0[165] - 0.059375410832698657*x0[166] - 0.047786178545295738*x0[167] + 0.14236140406080158*x0[168] - 6.3477718701543421e-316*x0[169] + 0.017292640791317253*x0[170] - 1.7117493967518298e-315*x0[171] - 0.07891854514225316*x0[172] + 0.12425057043745065*x0[173] - 3.6233974573716405e-316*x0[174] + 1.0973307874333721e-315*x0[175] - 1.8915759668875752e-315*x0[176] + 8.6161587210798634e-316*x0[177] + 0.073217865888395295*x0[178] - 1.0396364939698011e-315*x0[179] + 8.4038375176456731e-316*x0[180] + 1.4905371065308355e-315*x0[181] - 0.05228836575445444*x0[182] - 0.12557885615997436*x0[183] - 3.3547029981383861e-315*x0[184] - 0.041588774800736868*x0[185] - 0.077896519314059651*x0[186] - 4.0026118917261008e-315*x0[187] + 0.060990345498683485*x0[188] + 2.0262549665260413e-315*x0[189] + 1.6169752344757069e-315*x0[190] + 0.072387783931134764*x0[191] + 0.065832159759649206*x0[192] - 0.11772683266937917*x0[193] + 0.0019782833576902571*x0[194] - 7.342531941793958e-316*x0[195] - 0.059657303567147289*x0[196] - 1.0440847399022859e-315*x0[197] - 0.0098820283245415613*x0[198] - 0.14046100171267614*x0[199] - 5.0993266287056735e-317*x0[200] + 1.2465077481965328e-315*x0[201] + 1.1878316623035156e-315*x0[202] + 4.7638315989299979e-316*x0[203] + 0.034575161939913029*x0[204] + 2.2936455420540125e-315*x0[205] + 2.3723562616219975e-315*x0[206] + 9.4668592305182178e-316*x0[207] - 0.18876709867133787*x0[208] - 0.1538813433762091*x0[209] + 4.9176371494676884e-316*x0[210] + 0.038284601881223387*x0[211] + 0.14858891822617426*x0[212] + 1.4856732377550997e-315*x0[213] - 0.14784136170861462*x0[214] + 1.5085315158839277e-315*x0[215] + 3.7881931968210255e-315*x0[216] + 0.060312953238198574*x0[217] + 0.030760870450419808*x0[218] + 0.35675426147557476*x0[219] - 0.14131318185711164); +x1[5] = relu(0.19927398925638523*x0[0] - 0.1205492243147388*x0[1] - 0.04100761258268279*x0[2] + 0.093864947355285056*x0[3] - 0.58619923666309359*x0[4] + 0.50324025825306595*x0[5] + 0.25781265725304398*x0[6] - 0.0123605517385613*x0[7] + 0.21781845935659919*x0[8] - 0.0050964057862784963*x0[9] + 0.1038946068664057*x0[10] - 1.2074241862759587e-315*x0[11] + 0.082778167351877915*x0[12] - 0.12416318212626473*x0[13] + 1.31747010540998e-315*x0[14] - 7.8638963449845647e-316*x0[15] - 1.5299718651344429e-315*x0[16] - 3.0154033368064067e-316*x0[17] + 0.19270491656006727*x0[18] + 0.12075750640666305*x0[19] + 3.9578816189546119e-315*x0[20] + 3.4342725618998499e-315*x0[21] - 0.38918259337294797*x0[22] - 0.587366500957064*x0[23] - 9.9968209688252372e-316*x0[24] - 0.27431751462108966*x0[25] + 0.11381331391170335*x0[26] + 9.1282294036262441e-317*x0[27] + 0.16294083181186347*x0[28] + 3.4955138069821362e-315*x0[29] - 4.3001986676428117e-317*x0[30] - 0.13448341109289241*x0[31] + 0.15241400048074444*x0[32] + 2.2192396658648068e-315*x0[33] + 0.20497433096507345*x0[34] + 2.5705039173158653e-315*x0[35] - 0.18346608120172761*x0[36] + 2.8235048210273973e-315*x0[37] - 0.11882183603553655*x0[38] + 0.26393994555185535*x0[39] - 3.6624218401091557e-315*x0[40] - 1.8618197023125184e-315*x0[41] - 3.1884619635145651e-315*x0[42] + 1.1429605956449312e-316*x0[43] - 0.34115120800127674*x0[44] + 0.020516057388326833*x0[45] - 5.2690791855007465e-316*x0[46] + 4.2041763028596919e-315*x0[47] - 0.034827786798764589*x0[48] + 0.12013020218567212*x0[49] - 2.005795382048429e-315*x0[50] - 0.33745199182408786*x0[51] + 0.085209110218205028*x0[52] - 1.4905379316204641e-315*x0[53] + 0.015675198838680918*x0[54] + 1.8193945768028616e-315*x0[55] - 2.6793864847769065e-315*x0[56] + 0.30986450033013807*x0[57] + 0.17739018428072043*x0[58] + 0.048148047758204901*x0[59] + 0.27548910311914215*x0[60] + 1.3617640638689701e-315*x0[61] + 0.46617261201004645*x0[62] + 2.9936147602073896e-315*x0[63] + 0.063962536810752257*x0[64] + 0.43049256538869535*x0[65] + 7.737993102389194e-316*x0[66] - 1.0975405874692221e-315*x0[67] - 3.6606466276590529e-315*x0[68] + 3.2077167145675725e-315*x0[69] - 0.41173766287251762*x0[70] + 1.6420587200448699e-315*x0[71] + 3.825619316719496e-316*x0[72] + 3.3191614669426947e-316*x0[73] + 0.11718296068279814*x0[74] - 0.033108179359557635*x0[75] + 2.9394272854101223e-315*x0[76] - 0.44806566040007767*x0[77] - 0.20815348940112666*x0[78] - 1.1996123809518384e-315*x0[79] - 0.028822986329027533*x0[80] - 3.3742131317237288e-315*x0[81] - 9.4137826969102198e-316*x0[82] - 0.43401552341724081*x0[83] + 0.091167643039512247*x0[84] + 0.18418939235065146*x0[85] - 0.17011563455013448*x0[86] + 0.097513597520361261*x0[87] - 0.098891230791751675*x0[88] + 0.18107574264207099*x0[89] + 0.10970518891502369*x0[90] - 0.14034083367278655*x0[91] + 0.0079221565143696212*x0[92] + 8.4389724031708984e-316*x0[93] - 0.0794221534306149*x0[94] - 0.16061091958410056*x0[95] + 2.9673252653373845e-316*x0[96] - 2.5984189029826574e-315*x0[97] + 1.7951697970887965e-315*x0[98] - 1.4808559000818892e-315*x0[99] - 0.057173451548101814*x0[100] + 8.1354035001769675e-316*x0[101] - 3.8305762526409389e-315*x0[102] - 4.1299130436598147e-315*x0[103] - 0.036808429038378714*x0[104] + 0.056858257408024207*x0[105] - 7.5679580882643936e-316*x0[106] - 0.35245798975897752*x0[107] + 0.081787255478491652*x0[108] - 2.3870208562670651e-315*x0[109] - 0.26235107406639491*x0[110] + 4.1570663678456651e-316*x0[111] + 3.3839814666493192e-315*x0[112] - 0.23155663306388202*x0[113] + 0.036606547821178129*x0[114] + 3.7314273317564936e-316*x0[115] + 0.10206624672145607*x0[116] + 1.2892262103614385e-315*x0[117] + 0.010000767608356611*x0[118] + 1.0953233789516933e-316*x0[119] - 4.3849121612913564e-315*x0[120] - 0.10031654458216717*x0[121] - 2.3151104957736906e-315*x0[122] - 1.8918874357520264e-316*x0[123] + 3.7471824478576879e-315*x0[124] - 2.2959281648630507e-315*x0[125] - 0.13907889215754193*x0[126] - 7.7286072879085833e-316*x0[127] + 5.0998194097808355e-316*x0[128] + 2.248321807510052e-315*x0[129] + 0.17891962058010172*x0[130] + 0.055612554287111489*x0[131] - 1.0195516088779949e-315*x0[132] - 0.09258477001507244*x0[133] + 0.2463733177433689*x0[134] - 1.9725857912945437e-315*x0[135] + 0.11659396062129435*x0[136] - 3.3355448962070182e-315*x0[137] + 4.0895014085799371e-316*x0[138] - 0.04193591137548864*x0[139] + 0.064154090720174181*x0[140] - 0.04507103655106378*x0[141] + 0.31306951422853208*x0[142] - 9.155519514826802e-316*x0[143] + 0.82407568605996617*x0[144] - 1.4091224546149776e-315*x0[145] - 0.15812456322113022*x0[146] - 0.1813022198221097*x0[147] - 1.7652780646543065e-315*x0[148] - 3.9797710047080064e-315*x0[149] - 6.9163480007039883e-316*x0[150] + 1.3193029357957008e-315*x0[151] + 0.018864689181407161*x0[152] - 3.2502666805846205e-317*x0[153] - 2.8684674775754076e-315*x0[154] - 4.0227980503939916e-316*x0[155] + 0.34301955609062068*x0[156] + 0.75746782498880172*x0[157] + 1.5727184297532841e-315*x0[158] - 0.014082888673405758*x0[159] - 0.01899419634737199*x0[160] - 1.4866326934766976e-315*x0[161] - 0.082914865982255198*x0[162] - 1.7158056164163089e-315*x0[163] + 1.9145830180636789e-315*x0[164] - 0.35379198551182589*x0[165] + 0.48198963027594449*x0[166] + 0.022660392245362211*x0[167] - 0.12230706435597118*x0[168] - 5.9382181787033887e-316*x0[169] - 0.29712273349902352*x0[170] - 1.1978295895347284e-315*x0[171] + 0.05290382049990866*x0[172] + 0.11576476605758083*x0[173] - 8.3131681219243897e-316*x0[174] - 3.3838264930781882e-315*x0[175] - 4.2251445378010106e-315*x0[176] + 1.6885437460080673e-315*x0[177] - 0.012666350971152047*x0[178] - 3.0307449100807189e-315*x0[179] + 3.778976703577901e-316*x0[180] + 2.3841995487437097e-315*x0[181] + 0.23233981422063088*x0[182] + 0.13814230754308823*x0[183] + 8.5200566783300387e-316*x0[184] - 0.38323887403075069*x0[185] + 0.013956518989964747*x0[186] + 1.1622127824972367e-315*x0[187] + 0.15980847534453158*x0[188] - 7.318764666867942e-316*x0[189] + 3.4898641317373463e-315*x0[190] - 0.010866437235708577*x0[191] - 0.026097962861189573*x0[192] + 0.064495448842976658*x0[193] + 0.3571513066246082*x0[194] - 9.7379227147606551e-316*x0[195] + 0.34543645769132819*x0[196] + 1.2360879975982137e-315*x0[197] - 0.036402155473145577*x0[198] + 0.065308295893071369*x0[199] - 3.8348153951701343e-315*x0[200] + 1.2394155494855803e-317*x0[201] - 4.3290703027383333e-315*x0[202] - 2.4562248486689327e-315*x0[203] - 0.31149649326623852*x0[204] + 3.364301922894674e-316*x0[205] - 3.9513242808898777e-315*x0[206] - 2.1131247207540439e-315*x0[207] + 0.50796072721098018*x0[208] - 0.0050792291580543684*x0[209] - 3.7056973514084344e-315*x0[210] - 0.27552281694415032*x0[211] - 0.072712398148648119*x0[212] - 3.3551478004986805e-315*x0[213] - 0.30986832042685986*x0[214] - 2.6474951303353162e-315*x0[215] - 1.0741199391190153e-315*x0[216] - 0.14270637724220506*x0[217] + 0.32906182622090491*x0[218] + 0.017156783001235746*x0[219] - 0.032573065939152247); +x1[6] = relu(-0.69175685435097534*x0[0] - 0.073259776102597582*x0[1] - 0.16612501465788987*x0[2] + 0.076990963852144906*x0[3] + 0.15318627673744295*x0[4] - 2.449113521757937*x0[5] + 0.046071204904858575*x0[6] + 0.13745602935818388*x0[7] + 0.47221002508096932*x0[8] - 0.03155548643097969*x0[9] - 0.0042934013342856075*x0[10] - 2.4751475826672782e-315*x0[11] + 0.037499280806761896*x0[12] - 0.071027609199154268*x0[13] + 1.6772503045436118e-315*x0[14] - 1.3722955029471881e-315*x0[15] + 4.0876292308061815e-315*x0[16] - 4.5418841489093047e-315*x0[17] + 0.18113812579824187*x0[18] + 0.0083189607645983727*x0[19] + 2.8558057558893901e-316*x0[20] + 3.8751891699995712e-315*x0[21] + 0.013745566006527777*x0[22] - 0.40026963861032477*x0[23] + 4.3685318693438841e-315*x0[24] + 0.2411921789153634*x0[25] + 0.11526444695820917*x0[26] + 2.3444010787742598e-315*x0[27] - 0.014831933555889675*x0[28] + 3.7095529310141375e-315*x0[29] - 1.9916403716511385e-315*x0[30] - 0.082862493729145253*x0[31] - 0.11220160676568139*x0[32] - 2.6164646111717573e-315*x0[33] + 0.29369876719171284*x0[34] + 2.6455539464128059e-316*x0[35] - 0.10402057274144116*x0[36] - 3.8795965221185497e-315*x0[37] + 0.16226499929539548*x0[38] + 0.028812663549905769*x0[39] + 1.022225808355301e-315*x0[40] + 1.0949818313707232e-316*x0[41] + 8.1104240845954445e-316*x0[42] + 3.6512496176509074e-315*x0[43] + 0.0025101349832723613*x0[44] + 0.23664621920737422*x0[45] - 7.9849239501605157e-317*x0[46] - 1.8101887158524356e-315*x0[47] + 0.19853837137670094*x0[48] + 0.38434593228074038*x0[49] + 1.085445489909794e-315*x0[50] + 0.59002757628494373*x0[51] - 0.030073391706366318*x0[52] + 1.5853622119157011e-315*x0[53] + 0.14787430193898041*x0[54] - 1.1366090458030029e-315*x0[55] - 4.306844858473294e-315*x0[56] - 0.15326416165935353*x0[57] - 0.073974662280186468*x0[58] + 0.22304008434643072*x0[59] + 0.0087244592094778417*x0[60] + 4.3099450956976655e-315*x0[61] + 0.60216525172918589*x0[62] - 3.6334032748312174e-316*x0[63] + 0.31863415552864455*x0[64] - 0.055376163200107964*x0[65] + 6.0882546506486501e-316*x0[66] + 4.1619532205552454e-315*x0[67] - 1.6608879224758012e-315*x0[68] + 4.1820900023024908e-316*x0[69] - 0.0071978667359952741*x0[70] - 4.0742736630897703e-315*x0[71] - 1.4726048901612418e-315*x0[72] + 3.3965450174915081e-315*x0[73] + 0.29886637479743189*x0[74] + 0.031799270134990135*x0[75] + 4.0930892638934716e-316*x0[76] + 0.20377727748834015*x0[77] + 0.087036398975240487*x0[78] - 1.592723340438998e-315*x0[79] + 0.096959421331665144*x0[80] + 3.5819319605065576e-317*x0[81] - 2.0474079721375917e-315*x0[82] - 0.31266085651883047*x0[83] + 0.17903329143753843*x0[84] + 0.56047504179232843*x0[85] - 0.10478458065912233*x0[86] - 0.019548359120354603*x0[87] + 0.37776740190477487*x0[88] - 0.088631967667007594*x0[89] + 0.132662586809035*x0[90] + 0.25021691460167284*x0[91] + 0.3928222921752102*x0[92] - 1.4118552008713159e-315*x0[93] + 0.37146578481143211*x0[94] + 0.47128727076912191*x0[95] + 2.0734836008114814e-315*x0[96] - 4.1344911251033701e-316*x0[97] + 5.8903053721929005e-316*x0[98] + 4.5238733464580836e-315*x0[99] + 0.18330658487299753*x0[100] + 1.8674741452907906e-315*x0[101] - 1.1982475690711101e-315*x0[102] + 3.4023753972462644e-315*x0[103] + 0.43248855540466935*x0[104] + 0.084006202566176469*x0[105] - 1.5235605234680548e-315*x0[106] + 0.3375218890843602*x0[107] + 0.021317318579911457*x0[108] + 3.1845619822292704e-315*x0[109] + 0.25282300746932745*x0[110] + 1.9355915144144773e-315*x0[111] + 3.1815544020761199e-316*x0[112] + 0.39175651907158349*x0[113] + 0.41280319591114045*x0[114] - 1.9998313427145032e-315*x0[115] - 0.54485302787792977*x0[116] - 3.1669502069562564e-315*x0[117] + 0.12718622714395481*x0[118] - 4.4857331139564271e-315*x0[119] + 1.0599476364241204e-316*x0[120] - 0.056391786102969112*x0[121] - 2.7998720900580567e-316*x0[122] + 3.2401696487255083e-315*x0[123] - 1.3274946528981908e-315*x0[124] + 1.7614190315297391e-315*x0[125] - 0.028974892634997255*x0[126] + 6.9230404163162955e-316*x0[127] + 4.3361819626950755e-315*x0[128] - 2.9656193258314851e-315*x0[129] + 0.098436311881766089*x0[130] + 0.014011795886977645*x0[131] + 9.6555448275210086e-316*x0[132] - 0.0047672024221148889*x0[133] - 0.11068839585133443*x0[134] - 1.649172944202314e-316*x0[135] - 0.032622922682044912*x0[136] + 2.094855245293286e-315*x0[137] - 2.6373655889567077e-315*x0[138] - 0.017080509834069245*x0[139] - 0.071260567350901957*x0[140] + 0.13252383289649677*x0[141] + 0.2006719481280704*x0[142] - 1.9106227212443399e-315*x0[143] + 0.59170450009268205*x0[144] + 3.1863738790535769e-315*x0[145] + 0.052441943571770171*x0[146] + 0.15773015918156358*x0[147] - 1.037346015516994e-315*x0[148] + 1.4538853604223743e-315*x0[149] - 2.1359217248614746e-316*x0[150] + 2.4738954770416792e-315*x0[151] - 0.13666402755094928*x0[152] - 7.8099082602599896e-316*x0[153] - 4.3415380888363888e-315*x0[154] - 1.2021079806388294e-315*x0[155] + 0.4428751346657781*x0[156] - 0.12081610345297228*x0[157] + 3.3434160141119218e-315*x0[158] - 0.068787557489457682*x0[159] - 0.083282023844394176*x0[160] + 2.8934926633983614e-315*x0[161] + 0.031073068533075825*x0[162] + 6.998555385889255e-316*x0[163] + 3.4669359581416012e-315*x0[164] + 0.26041910584865169*x0[165] + 0.47459633413715557*x0[166] + 0.19106994479878797*x0[167] + 0.020880076347458285*x0[168] - 4.4055475442070719e-316*x0[169] + 0.14405417299191606*x0[170] - 8.1213549905702946e-316*x0[171] + 0.23691592640105333*x0[172] - 0.016839111541910215*x0[173] + 2.6501436779242902e-315*x0[174] - 7.3425333251777664e-316*x0[175] + 3.3172579901102751e-315*x0[176] - 2.8834795584705083e-316*x0[177] - 0.083434371266855004*x0[178] - 2.4654381354260156e-315*x0[179] + 3.0560766043490396e-315*x0[180] + 3.409784914558915e-315*x0[181] + 0.086423279885682783*x0[182] + 0.037162294201192173*x0[183] + 2.6790824763037075e-315*x0[184] + 0.16954251622791217*x0[185] + 0.074221214147128109*x0[186] + 3.0172513597107371e-315*x0[187] + 0.19046534348180422*x0[188] - 7.2866801426401406e-316*x0[189] - 3.2755078027387456e-316*x0[190] + 0.056576793803165423*x0[191] + 0.15442399723861561*x0[192] + 0.16782353645572379*x0[193] + 0.24934054855554305*x0[194] + 1.274491389225471e-315*x0[195] + 0.54588051148554584*x0[196] + 2.297271475006872e-315*x0[197] + 0.069919753271801402*x0[198] - 0.027240057739273148*x0[199] - 6.7534497648333647e-316*x0[200] - 1.3711563456688849e-315*x0[201] - 1.2224510347932136e-315*x0[202] + 5.9340600234148596e-316*x0[203] + 0.052580595810483174*x0[204] - 6.2633484029212191e-316*x0[205] + 3.5830595566487481e-315*x0[206] - 1.8864652382118948e-315*x0[207] + 0.29271320843413928*x0[208] + 0.1204617925922734*x0[209] + 1.7370787343270199e-315*x0[210] - 0.031675613721639483*x0[211] - 0.018201387102496431*x0[212] - 1.415623568009215e-317*x0[213] + 0.25589275890158147*x0[214] - 7.1257235353511084e-316*x0[215] - 1.7257095674210263e-315*x0[216] + 0.14041241208532609*x0[217] + 0.26532830007439068*x0[218] + 0.060769729048821976*x0[219] - 0.034215271354308852); +x1[7] = relu(-0.5798585062428222*x0[0] + 0.014655685582705337*x0[1] - 0.24917260040685649*x0[2] - 0.16793912560351976*x0[3] + 0.96009926398157031*x0[4] + 0.089238711448498736*x0[5] - 0.032931425158341736*x0[6] - 0.10552506567570924*x0[7] - 0.024293681297777675*x0[8] - 0.29432762849155353*x0[9] - 0.074009980938980827*x0[10] - 3.5570082211826644e-315*x0[11] + 0.02193291046816075*x0[12] - 0.20963159030742592*x0[13] - 3.9745931127484304e-315*x0[14] - 4.1558622063503385e-315*x0[15] + 2.0443293157006305e-316*x0[16] - 4.18748505587604e-315*x0[17] - 0.17003089632246088*x0[18] + 0.089672223448042723*x0[19] + 1.2513591171114289e-315*x0[20] + 7.2947961590043747e-316*x0[21] + 0.13554977282745342*x0[22] - 0.16225602318328497*x0[23] - 4.3866200227126182e-315*x0[24] + 0.25702024203470664*x0[25] - 0.14652805850799744*x0[26] + 2.9546526248005939e-315*x0[27] - 0.49921068507240501*x0[28] + 4.7390147309459567e-316*x0[29] - 4.2782234330427958e-315*x0[30] - 0.036540974247909599*x0[31] - 0.10172298072064948*x0[32] - 2.0462907167893686e-315*x0[33] - 0.13760349119439974*x0[34] - 2.6457766020367607e-315*x0[35] - 0.025849419034976017*x0[36] + 3.6171806787565846e-316*x0[37] - 0.038891445840461392*x0[38] - 0.12305761688046855*x0[39] - 8.321075741399208e-316*x0[40] - 3.13470566474708e-316*x0[41] + 1.3956875251338749e-315*x0[42] - 1.6124075185294012e-315*x0[43] + 0.066557270359213161*x0[44] + 0.1458502187213323*x0[45] + 3.132592190252552e-315*x0[46] + 4.9274640163503416e-316*x0[47] - 0.060276719337161673*x0[48] + 0.17323072436999029*x0[49] + 4.0101775387234937e-316*x0[50] + 0.87050847393712816*x0[51] + 0.11582488644258129*x0[52] + 3.6674029457219932e-316*x0[53] - 0.050556718985850582*x0[54] + 7.0668229559099338e-316*x0[55] - 1.2621382263572507e-315*x0[56] - 0.50845858615925332*x0[57] - 0.031230973165135012*x0[58] - 0.050353304412716141*x0[59] + 0.049276536951018891*x0[60] - 3.1635313418562254e-315*x0[61] + 0.35973447676790937*x0[62] + 2.1458737286909065e-315*x0[63] + 0.14833907711069613*x0[64] - 0.033674806684162825*x0[65] + 3.2855927843367556e-315*x0[66] - 4.8555112600838975e-316*x0[67] - 1.8110144724696124e-316*x0[68] + 1.3232089100972797e-315*x0[69] - 0.060106110792126057*x0[70] - 9.1056497142931366e-316*x0[71] - 4.7664767769912674e-316*x0[72] + 4.3797426042192257e-315*x0[73] + 0.067453326783830092*x0[74] + 0.022280658556195463*x0[75] + 6.932709478631667e-316*x0[76] - 0.33093547023177466*x0[77] + 0.13652684131367113*x0[78] - 1.6424510032270113e-315*x0[79] + 0.14844747803766775*x0[80] - 8.366990447624785e-316*x0[81] - 1.0727773107857853e-315*x0[82] + 0.076630024949652417*x0[83] + 0.0074826160664123774*x0[84] + 0.47023072982298852*x0[85] - 0.018550472951964096*x0[86] - 0.17964799203915691*x0[87] + 0.65674203339543713*x0[88] + 0.014311503707155889*x0[89] + 0.19974480740349371*x0[90] + 0.74965304934984323*x0[91] + 0.35438621710186968*x0[92] + 4.4307322292424726e-315*x0[93] + 0.45503118227917205*x0[94] + 0.97217137243343243*x0[95] - 2.9073535021694615e-316*x0[96] + 2.5445752138837359e-315*x0[97] - 6.3421438695694353e-316*x0[98] + 1.6550209373973445e-315*x0[99] + 0.18262621898909714*x0[100] - 4.2733627608717886e-315*x0[101] - 4.5930398244554624e-316*x0[102] - 3.5840445209796408e-315*x0[103] + 0.6209743889375281*x0[104] + 0.12129608152421856*x0[105] + 2.6216191733515367e-315*x0[106] + 0.11412754946416373*x0[107] - 0.041875160373276973*x0[108] + 3.2172759559711864e-315*x0[109] - 0.67622207577255411*x0[110] - 1.0381686941051972e-315*x0[111] - 2.9896938997079016e-315*x0[112] + 0.74936346541040222*x0[113] + 0.46634662729538157*x0[114] - 3.2206950977479791e-315*x0[115] - 0.36424138103682097*x0[116] + 1.3625792178373871e-315*x0[117] - 0.15591849692910284*x0[118] - 3.8548933485209295e-315*x0[119] - 9.6470907220353253e-317*x0[120] + 0.061536370956154857*x0[121] - 5.752975675779901e-316*x0[122] + 2.9614198073670862e-315*x0[123] - 1.2846565181525495e-315*x0[124] + 2.2158078414228854e-316*x0[125] - 0.0007169935823068081*x0[126] - 2.6752052368600908e-315*x0[127] + 3.1885481977323903e-316*x0[128] + 8.8989832403952932e-316*x0[129] - 0.088693374025696117*x0[130] - 0.14695513568960208*x0[131] + 3.4941809858519761e-315*x0[132] + 0.072408230349909508*x0[133] - 0.016252381802660174*x0[134] - 3.7003302866537222e-315*x0[135] - 0.16429358954842985*x0[136] + 1.4821693192541371e-316*x0[137] + 3.474707190794885e-315*x0[138] + 0.076399926685802907*x0[139] + 0.15937420773585473*x0[140] - 0.19050406700458825*x0[141] - 0.42822102957504632*x0[142] + 3.444154986464378e-315*x0[143] + 0.21371441918101949*x0[144] + 1.3349341155296358e-315*x0[145] + 0.074585922063554036*x0[146] + 0.12435581401104769*x0[147] - 3.1602317787876957e-315*x0[148] - 1.6949765498861107e-315*x0[149] - 1.3461713570268768e-315*x0[150] + 3.4817402103227787e-315*x0[151] + 0.15967211024809189*x0[152] + 5.3857569379175819e-316*x0[153] + 1.4001803110843323e-315*x0[154] + 3.9030029759627515e-315*x0[155] + 0.088070257465248547*x0[156] + 0.065713954542295477*x0[157] - 4.0709627315707297e-315*x0[158] - 0.4222863426532168*x0[159] - 0.081134603368763852*x0[160] - 2.9568706040605302e-315*x0[161] + 0.21894864916871506*x0[162] - 2.0939301864219516e-315*x0[163] - 4.0183332680843405e-315*x0[164] - 0.20792068597911548*x0[165] - 0.034960499983784574*x0[166] + 0.013635230972462957*x0[167] - 0.021997457378894147*x0[168] + 5.2174181993746482e-316*x0[169] + 0.28904175688549083*x0[170] + 1.4001985470473203e-315*x0[171] + 0.0044580192810556966*x0[172] - 0.096140171492987231*x0[173] - 2.3354102994214378e-315*x0[174] - 6.0288000753987937e-316*x0[175] + 1.8639677169363472e-315*x0[176] - 4.1637130329791673e-317*x0[177] - 0.037139652790063572*x0[178] - 7.1981122057368783e-316*x0[179] + 3.7961991699439615e-315*x0[180] + 2.9774380974158507e-316*x0[181] + 0.21833515712938145*x0[182] - 0.20283395108307353*x0[183] + 1.539654114061902e-315*x0[184] + 0.30826459149397556*x0[185] - 0.019316612144518606*x0[186] + 2.7722502977674762e-315*x0[187] + 0.14293116416053891*x0[188] - 1.6857164108838326e-317*x0[189] - 2.9818984973632232e-315*x0[190] - 0.11752874198452666*x0[191] + 0.092138009244107949*x0[192] - 0.027138620267259227*x0[193] - 0.1462190041577493*x0[194] + 4.0461482351017885e-316*x0[195] + 0.19515242401520264*x0[196] - 4.1034024494726393e-315*x0[197] + 0.21914708043521711*x0[198] + 0.24706091923924056*x0[199] + 3.2372248544346314e-315*x0[200] + 3.6509959297637373e-315*x0[201] + 4.361400950708267e-316*x0[202] + 2.7431182900765962e-315*x0[203] + 0.019296175484747262*x0[204] - 1.1325138147151281e-315*x0[205] + 1.9910408476931925e-315*x0[206] - 3.6738779675094738e-315*x0[207] + 0.16361405470866078*x0[208] - 0.072282350137092402*x0[209] + 1.5198983755033551e-315*x0[210] - 0.11034541354513923*x0[211] - 0.031813189900719817*x0[212] - 3.250322332138968e-315*x0[213] + 0.033774455779959044*x0[214] + 2.800541855328872e-315*x0[215] + 3.853685847141837e-315*x0[216] - 1.0091985909737637*x0[217] - 0.24606158367023956*x0[218] - 0.19550029779303305*x0[219] + 0.053108968311719872); +x2[0] = relu(0.4067235107513465*x1[0] + 0.44353683178652814*x1[1] + 1.6605495207297656*x1[2] - 1.2007219899371433*x1[3] - 0.20345339775021135*x1[4] - 0.60668456699393625*x1[5] + 1.340810942913528*x1[6] + 0.81665439951304775*x1[7] + 0.5531201327256402); +x2[1] = relu(-0.58639435981898291*x1[0] + 0.88359644940698245*x1[1] - 0.98955175866203871*x1[2] + 1.1362962743013854*x1[3] + 0.98099014772509752*x1[4] + 1.0177049509185954*x1[5] - 0.6521974082329971*x1[6] - 1.1282778717495878*x1[7] + 0.39185486720026275); +x2[2] = relu(-0.57771741578230318*x1[0] + 0.69433440361493526*x1[1] - 0.7692689959690725*x1[2] + 0.9194416260004975*x1[3] + 0.64530414634630873*x1[4] + 0.54396998984811018*x1[5] - 1.8790530143739812*x1[6] - 0.81202815488230973*x1[7] + 0.0099081660491244748); +x2[3] = relu(0.47141837202986575*x1[0] - 0.79455663136308785*x1[1] + 1.0382638451144521*x1[2] + 0.11634479070220931*x1[3] + 0.34018826737390551*x1[4] + 0.18160649407733312*x1[5] - 0.36989575976492861*x1[6] - 1.3992201021724771*x1[7] - 0.32405384144867277); +x3_result[0] = sigmoid(-0.89868928342981602*x2[0] + 1.4199944189224629*x2[1] + 2.1579744471653157*x2[2] - 2.2929148050486901*x2[3] - 0.56308214764676823); return x3_result[0]; } diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.h b/src/dreal/util/pattern_matching/pattern_matching_heuristic.h index bb6bdc1c6..7e358b76c 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_heuristic.h +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.h @@ -34,7 +34,13 @@ namespace dreal PatternMatchingTrie::matching_stats_t pattern_matching_stats; }; - static float calculate(statistics k); + // todo: I have no idea why, but passing const ref instead of copying BREAKS it?!?!?! + // it goes from functioning perfectly normally.. to just returning 0 and only 0... + // the unit tests work, it only breaks the executable. + // I think it's a compiler bug.... the struct is massive, the function is pure / constexpr. + // lots to optimize away here. + // honestly passing by copy might let some fancier optimizations through so who knows. + static float calculate(const statistics& k); }; } diff --git a/test/dreal/util/test/pattern_matching_heuristic_test.cc b/test/dreal/util/test/pattern_matching_heuristic_test.cc index f43e7ae0a..41d47cf40 100644 --- a/test/dreal/util/test/pattern_matching_heuristic_test.cc +++ b/test/dreal/util/test/pattern_matching_heuristic_test.cc @@ -1,5 +1,5 @@ -// This file was automatically generated on 2025-04-14 00:05:27.500595 by Kunal in the `WORTH_IT_regression` python notebook. +// This file was automatically generated on 2025-04-14 01:50:25.358983 by Kunal in the `WORTH_IT_regression` python notebook. #include @@ -20,4384 +20,4384 @@ namespace dreal float expected_value = -1E9; float calculated_value = -1E9; -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 2486; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 1142; +k.assertions_stats.conjunction_cntr = 2486; +k.assertions_stats.constant_cntr = 1881; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1465; k.assertions_stats.exp_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.assertions_stats.inequality_cntr = 1021; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 584; +k.assertions_stats.negation_cntr = 581; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 58; +k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 1301; +k.assertions_stats.variable_cntr = 4424; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1079; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 6784; +k.box_continuous_count = 1301; k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; -k.biggest_assertion_stats.abs_cntr = 0; -k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 538; -k.assertions_stats.unique_variables = 1079; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 3; k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 1; k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 862; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.763136; +expected_value = 0.9175118461376377; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 2289: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.assertions_size = 696; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 342; +k.assertions_stats.conjunction_cntr = 696; +k.assertions_stats.constant_cntr = 521; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 465; +k.assertions_stats.exp_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.assertions_stats.inequality_cntr = 231; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 214; +k.assertions_stats.negation_cntr = 125; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 18; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.assertions_stats.unique_variables = 421; +k.assertions_stats.variable_cntr = 1324; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 1334; +k.box_continuous_count = 421; +k.box_integer_count = 0; +k.lemma_size = 4; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 4; +k.lemma_stats.constant_cntr = 4; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 4; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 4; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 902; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1569; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1207; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 536; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 46; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 3722; -k.theory_checksat_ms = 0.426912; -k.box_boolean_count = 5725; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2069; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 2069; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.7555246294934173; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.0700951; +expected_value = 0.507457976074427; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 15980: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 17145: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 382; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 200; +k.assertions_stats.conjunction_cntr = 382; +k.assertions_stats.constant_cntr = 260; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 298; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1301; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 419; -k.assertions_stats.unique_variables = 1301; -k.lemma_stats.conjunction_cntr = 4; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 721; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 4; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 84; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 133; +k.assertions_stats.negation_cntr = 63; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 18; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.assertions_stats.unique_variables = 253; +k.assertions_stats.variable_cntr = 799; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 1541; +k.box_continuous_count = 253; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 3; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 1142; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 4; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1581; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; -k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1465; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 584; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 4; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 58; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 4124; -k.theory_checksat_ms = 0.107627; -k.box_boolean_count = 4384; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 4; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2186; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 2186; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.521368718251169; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 1.78806; +expected_value = 0.6806496148601098; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 3267: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 15726: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 816; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 342; +k.assertions_stats.conjunction_cntr = 816; +k.assertions_stats.constant_cntr = 631; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 465; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 941; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 410; -k.assertions_stats.unique_variables = 941; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; +k.assertions_stats.inequality_cntr = 351; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 214; +k.assertions_stats.negation_cntr = 206; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 18; +k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 421; +k.assertions_stats.variable_cntr = 1454; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 745; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; +k.box_boolean_count = 2274; +k.box_continuous_count = 421; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 822; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1369; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1057; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 424; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 42; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 3200; -k.theory_checksat_ms = 0.633665; -k.box_boolean_count = 4924; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 0; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 1802; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 1802; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.5851091945741282; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.188381; +expected_value = 0.5545806328948858; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 14862: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16851: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 776; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 342; +k.assertions_stats.conjunction_cntr = 776; +k.assertions_stats.constant_cntr = 601; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 445; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 761; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 342; -k.assertions_stats.unique_variables = 761; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 607; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 331; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 184; +k.assertions_stats.negation_cntr = 178; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 18; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.assertions_stats.unique_variables = 401; +k.assertions_stats.variable_cntr = 1364; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 2134; +k.box_continuous_count = 401; +k.box_integer_count = 0; +k.lemma_size = 2; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 2; +k.lemma_stats.constant_cntr = 2; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 2; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 2; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 662; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1113; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; -k.assertions_stats.equalto_cntr = 853; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 344; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 34; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2588; -k.theory_checksat_ms = 0.228382; -k.box_boolean_count = 3994; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 0; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 1460; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; -k.assertions_size = 1460; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.5626372673913672; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.0537551; +expected_value = 0.8756637580116956; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12973: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 3043: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 2069; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 902; +k.assertions_stats.conjunction_cntr = 2069; +k.assertions_stats.constant_cntr = 1569; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1207; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 311; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 134; -k.assertions_stats.unique_variables = 311; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 262; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 862; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 536; +k.assertions_stats.negation_cntr = 536; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 46; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; +k.assertions_stats.unique_variables = 1079; +k.assertions_stats.variable_cntr = 3722; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 5725; +k.box_continuous_count = 1079; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.lemma_stats.notequalto_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 262; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 473; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 343; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 144; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 14; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 1058; -k.theory_checksat_ms = 0.188873; -k.box_boolean_count = 1669; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 605; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 605; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.5449244520084344; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.213331; +expected_value = 0.8242458129848773; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1523: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 15973: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 3128; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 1346; +k.assertions_stats.conjunction_cntr = 3128; +k.assertions_stats.constant_cntr = 2737; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 2243; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1173; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.assertions_stats.inequality_cntr = 885; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 1512; +k.assertions_stats.negation_cntr = 786; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 76; +k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 1923; +k.assertions_stats.variable_cntr = 6298; k.biggest_assertion_stats.abs_cntr = 0; -k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 546; -k.assertions_stats.unique_variables = 1173; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 935; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 1; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 5240; +k.box_continuous_count = 1923; +k.box_integer_count = 0; +k.lemma_size = 2; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 2; +k.lemma_stats.constant_cntr = 2; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 2; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 2; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 982; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1703; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1313; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 582; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 50; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 4046; -k.theory_checksat_ms = 0.798768; -k.box_boolean_count = 6218; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2248; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 2248; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.9865325448134941; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.457984; +expected_value = 0.9982519332098194; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 115: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16757: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 1; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 2657; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 1222; +k.assertions_stats.conjunction_cntr = 2657; +k.assertions_stats.constant_cntr = 2009; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1567; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 58; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 19; -k.assertions_stats.unique_variables = 58; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 2; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 2; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 42; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 2; -k.biggest_literal_stats.variable_cntr = 2; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 2; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 1090; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 624; +k.assertions_stats.negation_cntr = 619; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 62; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; +k.assertions_stats.unique_variables = 1391; +k.assertions_stats.variable_cntr = 4730; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 1; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 7249; +k.box_continuous_count = 1391; +k.box_integer_count = 0; +k.lemma_size = 2; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 2; +k.lemma_stats.constant_cntr = 2; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 2; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 2; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 17; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 4; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 85; -k.smallest_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; -k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 2; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 3; -k.assertions_stats.equalto_cntr = 56; -k.biggest_literal_stats.constant_cntr = 0; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 52; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 6; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 2; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 198; -k.theory_checksat_ms = 0.133798; -k.box_boolean_count = 22; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 6; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 2; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 98; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 3; -k.assertions_size = 98; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.9176756792767737; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 46.3854; +expected_value = 0.9999999998130396; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 13267: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12760: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 1; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 1802; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 822; +k.assertions_stats.conjunction_cntr = 1802; +k.assertions_stats.constant_cntr = 1369; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1057; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1031; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 468; -k.assertions_stats.unique_variables = 1031; -k.lemma_stats.conjunction_cntr = 2; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; +k.assertions_stats.inequality_cntr = 745; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 424; +k.assertions_stats.negation_cntr = 417; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 42; +k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 941; +k.assertions_stats.variable_cntr = 3200; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 814; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 1; -k.smallest_literal_stats.abs_cntr = 0; +k.box_boolean_count = 4924; +k.box_continuous_count = 941; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 3; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 902; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 2; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1497; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1159; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 464; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 2; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 46; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 3506; -k.theory_checksat_ms = 0.400875; -k.box_boolean_count = 5389; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 2; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 1973; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 1973; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.8427251964625254; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.68239; +expected_value = 0.951935337229555; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1379: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 14833: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 600; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 345; +k.assertions_stats.conjunction_cntr = 600; +k.assertions_stats.constant_cntr = 491; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 478; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 2379; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 1188; -k.assertions_stats.unique_variables = 2379; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 1092; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 122; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 338; +k.assertions_stats.negation_cntr = 3; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 18; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.assertions_stats.unique_variables = 473; +k.assertions_stats.variable_cntr = 1311; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 821; +k.box_continuous_count = 473; +k.box_integer_count = 0; +k.lemma_size = 4; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 4; +k.lemma_stats.constant_cntr = 4; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 4; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 4; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 1670; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 3379; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 2777; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 1866; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 94; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 7792; -k.theory_checksat_ms = 80.867; -k.box_boolean_count = 6491; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 3869; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 3869; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.9999859625552632; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.814617; +expected_value = 0.7419381786488394; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 989: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16807: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 9; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 5; +k.assertions_stats.conjunction_cntr = 9; +k.assertions_stats.constant_cntr = 15; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 761; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 329; -k.assertions_stats.unique_variables = 761; -k.lemma_stats.conjunction_cntr = 2; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 607; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 2; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 8; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 4; +k.assertions_stats.negation_cntr = 4; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 4; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; +k.assertions_stats.unique_variables = 4; +k.assertions_stats.variable_cntr = 16; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 5; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 8; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 4; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 4; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 4; +k.biggest_assertion_stats.variable_cntr = 7; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 1; +k.box_continuous_count = 4; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 3; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 662; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 2; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1113; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; -k.assertions_stats.equalto_cntr = 853; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 344; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 2; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 34; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2588; -k.theory_checksat_ms = 0.552686; -k.box_boolean_count = 3994; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 2; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 0; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 1460; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; -k.assertions_size = 1460; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.9947370775745865; -calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 13030: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; -EXPECT_NEAR(calculated_value, expected_value, 0.001); - -k.lemma_stats.equalto_cntr = 2; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 1; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; -k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 23; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 1; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 4; -k.lemma_stats.max_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; -k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 1255; -k.assertions_stats.unique_variables = 24; -k.lemma_stats.conjunction_cntr = 2; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 7; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 0; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.0142411; +expected_value = 0.0003001685338791476; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 17224: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.assertions_size = 14; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 2; +k.assertions_stats.conjunction_cntr = 14; +k.assertions_stats.constant_cntr = 16; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 9; +k.assertions_stats.exp_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.assertions_stats.inequality_cntr = 5; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 4; +k.assertions_stats.negation_cntr = 8; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 3; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.assertions_stats.unique_variables = 6; +k.assertions_stats.variable_cntr = 21; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 1; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; -k.lemma_stats.realconstant_cntr = 2; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 0; +k.box_continuous_count = 6; +k.box_integer_count = 0; +k.lemma_size = 8; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 2; +k.lemma_stats.conjunction_cntr = 8; +k.lemma_stats.constant_cntr = 9; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 4; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 4; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 2; +k.lemma_stats.negation_cntr = 5; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 2; +k.lemma_stats.realconstant_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 5; +k.lemma_stats.variable_cntr = 12; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 467; -k.middle_literal_stats.constant_cntr = 0; -k.assertions_stats.realconstant_cntr = 1363; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 2; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 1; -k.assertions_stats.constant_cntr = 1198; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; -k.assertions_stats.equalto_cntr = 2221; -k.biggest_literal_stats.constant_cntr = 0; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 345; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 0; -k.lemma_size = 2; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 8; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 1; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2263; -k.theory_checksat_ms = 0.0640391; -k.box_boolean_count = 0; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 1; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 7; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2228; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 6; -k.assertions_size = 2228; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 5.133294085747257e-05; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.478895; +expected_value = 0.003040690431174058; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 7242: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12886: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 161; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; -k.lemma_stats.multiplication_cntr = 141; -k.middle_literal_stats.multiplication_cntr = 1; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 7; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 0; +k.assertions_stats.conjunction_cntr = 7; +k.assertions_stats.constant_cntr = 7; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1315; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 543; -k.assertions_stats.unique_variables = 1315; -k.lemma_stats.conjunction_cntr = 233; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 3; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 609; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 184; -k.biggest_literal_stats.variable_cntr = 3; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 72; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 6; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 1; +k.assertions_stats.negation_cntr = 7; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 0; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.assertions_stats.unique_variables = 3; +k.assertions_stats.variable_cntr = 8; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 1; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 13; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 2; +k.biggest_assertion_stats.variable_cntr = 2; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 1; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 0; +k.box_continuous_count = 3; +k.box_integer_count = 0; +k.lemma_size = 4; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 4; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 4; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 5; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 2; +k.lemma_stats.variable_cntr = 5; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 914; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 467; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 1881; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 2; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1531; -k.biggest_literal_stats.constant_cntr = 0; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 1040; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 2; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 34; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 233; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 52; -k.lemma_stats.addition_cntr = 74; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 4306; -k.theory_checksat_ms = 37.6658; -k.box_boolean_count = 3572; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 234; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 2; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 1; k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 2; -k.assertions_stats.conjunction_cntr = 2140; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 2140; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 1.4067878668063158e-13; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.213105; +expected_value = 9.893092458825077e-05; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 13904: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 17187: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 2; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 1; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 2103; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 378; +k.assertions_stats.conjunction_cntr = 2103; +k.assertions_stats.constant_cntr = 1098; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 2096; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 23; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 1; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 4; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 1095; -k.assertions_stats.unique_variables = 24; -k.lemma_stats.conjunction_cntr = 2; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 1; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; k.assertions_stats.inequality_cntr = 7; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 0; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 335; +k.assertions_stats.negation_cntr = 1376; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.assertions_stats.realconstant_cntr = 1328; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; +k.assertions_stats.unique_variables = 24; +k.assertions_stats.variable_cntr = 2138; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 6; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 0; +k.box_continuous_count = 23; +k.box_integer_count = 1; +k.lemma_size = 2; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 2; +k.lemma_stats.constant_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 2; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.lemma_stats.notequalto_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 2; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 554; -k.middle_literal_stats.constant_cntr = 0; -k.assertions_stats.realconstant_cntr = 1474; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 1; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; k.lemma_stats.variable_cntr = 2; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 1; -k.assertions_stats.constant_cntr = 1311; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 0; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; -k.assertions_stats.equalto_cntr = 2425; -k.biggest_literal_stats.constant_cntr = 0; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 365; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; k.smallest_literal_stats.inequality_cntr = 0; -k.lemma_size = 2; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 8; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.theory_checksat_ms = 0.146826; +expected_value = 2.9583265683339373e-07; +calculated_value = PatternMatchingHeuristic::calculate(k); +std::cout << "Trial 10048: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +EXPECT_NEAR(calculated_value, expected_value, 0.001); + +k.assertions_size = 2202; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 446; +k.assertions_stats.conjunction_cntr = 2202; +k.assertions_stats.constant_cntr = 1175; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 2195; +k.assertions_stats.exp_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; +k.assertions_stats.ifthenelse_cntr = 0; +k.assertions_stats.inequality_cntr = 7; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 342; +k.assertions_stats.negation_cntr = 1281; +k.assertions_stats.notequalto_cntr = 0; k.assertions_stats.pow_cntr = 1; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; +k.assertions_stats.realconstant_cntr = 1357; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2467; -k.theory_checksat_ms = 0.0255911; -k.box_boolean_count = 0; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 1; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 24; +k.assertions_stats.variable_cntr = 2237; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 6; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; k.biggest_assertion_stats.unique_variables = 7; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 0; -k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2432; -k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 6; -k.assertions_size = 2432; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; +k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 1.207162311518787e-09; -calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 5991: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; -EXPECT_NEAR(calculated_value, expected_value, 0.001); - -k.lemma_stats.equalto_cntr = 2; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 1; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; -k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 0; k.box_continuous_count = 23; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; k.box_integer_count = 1; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 4; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; -k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 673; -k.assertions_stats.unique_variables = 24; +k.lemma_size = 2; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; k.lemma_stats.conjunction_cntr = 2; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.constant_cntr = 0; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 2; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 7; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; k.lemma_stats.inequality_cntr = 0; -k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 1; k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 2; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 1; -k.assertions_stats.addition_cntr = 784; -k.middle_literal_stats.constant_cntr = 0; -k.assertions_stats.realconstant_cntr = 1653; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 1; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; k.lemma_stats.variable_cntr = 2; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 1; -k.assertions_stats.constant_cntr = 1618; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; -k.assertions_stats.equalto_cntr = 2859; -k.biggest_literal_stats.constant_cntr = 0; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 417; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 1; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 0; -k.lemma_size = 2; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 8; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 1; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 0; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 1; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 0; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2901; -k.theory_checksat_ms = 0.101; -k.box_boolean_count = 0; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.equalto_cntr = 1; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 7; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2866; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 6; -k.assertions_size = 2866; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 5.4670130632985314e-08; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.0610181; +expected_value = 4.8153790532843145e-11; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 4506: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 7306: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 2; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 1; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 3084; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 1797; +k.assertions_stats.conjunction_cntr = 3084; +k.assertions_stats.constant_cntr = 2483; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 2470; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 23; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 1; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 4; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 1345; -k.assertions_stats.unique_variables = 24; -k.lemma_stats.conjunction_cntr = 2; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 1; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 7; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 0; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 614; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 1706; +k.assertions_stats.negation_cntr = 3; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 90; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.assertions_stats.unique_variables = 2417; +k.assertions_stats.variable_cntr = 6747; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; -k.lemma_stats.realconstant_cntr = 1; +k.biggest_assertion_stats.equalto_cntr = 1; k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 407; -k.middle_literal_stats.constant_cntr = 0; -k.assertions_stats.realconstant_cntr = 1333; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 2; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 1; -k.assertions_stats.constant_cntr = 1129; -k.smallest_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; -k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; -k.assertions_stats.equalto_cntr = 2131; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 336; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 4265; +k.box_continuous_count = 2417; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 1; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; +k.lemma_stats.realconstant_cntr = 0; +k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 3; +k.middle_assertion_stats.abs_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; +k.middle_assertion_stats.false_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 0; -k.lemma_size = 2; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 8; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 1; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2173; -k.theory_checksat_ms = 0.0527811; -k.box_boolean_count = 0; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 1; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 7; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 1; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2138; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 6; -k.assertions_size = 2138; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 2.765947552768804e-07; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.178055; +expected_value = 0.414725644747226; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 8614: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1213: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 2069; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 902; +k.assertions_stats.conjunction_cntr = 2069; +k.assertions_stats.constant_cntr = 1569; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1207; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 761; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; +k.assertions_stats.inequality_cntr = 862; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 536; +k.assertions_stats.negation_cntr = 538; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 46; +k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 1079; +k.assertions_stats.variable_cntr = 3722; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 241; -k.assertions_stats.unique_variables = 761; -k.lemma_stats.conjunction_cntr = 4; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 427; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 4; -k.smallest_literal_stats.abs_cntr = 0; +k.box_boolean_count = 5725; +k.box_continuous_count = 1079; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 3; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 2; k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; +k.lemma_stats.variable_cntr = 3; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 662; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 4; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 933; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 853; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 344; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 4; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 34; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 2408; -k.theory_checksat_ms = 0.105549; -k.box_boolean_count = 2554; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 4; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 1280; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 1280; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.4372270207842434; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.139642; +expected_value = 0.2967137125035579; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1277: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 15965: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 2364; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 1227; +k.assertions_stats.conjunction_cntr = 2364; +k.assertions_stats.constant_cntr = 1943; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 1870; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1455; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 727; -k.assertions_stats.unique_variables = 1455; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 1154; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.inequality_cntr = 494; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 1286; +k.assertions_stats.negation_cntr = 14; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 90; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.assertions_stats.unique_variables = 1817; +k.assertions_stats.variable_cntr = 5037; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 1222; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 2105; -k.smallest_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; -k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.biggest_assertion_stats.multiplication_cntr = 0; k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; -k.assertions_stats.equalto_cntr = 1631; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 720; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 62; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 5018; -k.theory_checksat_ms = 0.158808; -k.box_boolean_count = 7697; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; -k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2785; -k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; -k.assertions_size = 2785; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.3981107348641727; -calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 15578: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; -EXPECT_NEAR(calculated_value, expected_value, 0.001); - -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; -k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 1391; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 3320; +k.box_continuous_count = 1817; k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; -k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 640; -k.assertions_stats.unique_variables = 1391; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; +k.lemma_stats.constant_cntr = 3; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 0; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 1090; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 1; k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 1222; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 1; k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 2009; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.abs_cntr = 0; +k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 1567; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 624; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 62; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; +k.smallest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 4730; -k.theory_checksat_ms = 0.194292; -k.box_boolean_count = 7249; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 2657; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 2657; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.10349768981386948; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.238812; +expected_value = 0.3885534648265548; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12694: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12641: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 0; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 905; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 374; +k.assertions_stats.conjunction_cntr = 905; +k.assertions_stats.constant_cntr = 811; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 641; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 555; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 221; -k.assertions_stats.unique_variables = 555; -k.lemma_stats.conjunction_cntr = 3; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; k.assertions_stats.inequality_cntr = 264; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 2; -k.lemma_stats.inequality_cntr = 3; -k.smallest_literal_stats.abs_cntr = 0; -k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 450; +k.assertions_stats.negation_cntr = 272; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 22; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.assertions_stats.unique_variables = 555; +k.assertions_stats.variable_cntr = 1816; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 1487; +k.box_continuous_count = 555; +k.box_integer_count = 0; +k.lemma_size = 7; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 7; +k.lemma_stats.constant_cntr = 6; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 1; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 6; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 0; +k.lemma_stats.negation_cntr = 3; +k.lemma_stats.notequalto_cntr = 0; +k.lemma_stats.pow_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 2; +k.lemma_stats.variable_cntr = 8; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 374; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 3; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 811; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.log_cntr = 0; +k.middle_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.min_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; +k.middle_assertion_stats.trigonometry_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; +k.middle_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; +k.middle_literal_stats.abs_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; +k.middle_literal_stats.forall_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.log_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; -k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; +k.middle_literal_stats.trigonometry_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; +k.smallest_assertion_stats.ifthenelse_cntr = 0; k.smallest_assertion_stats.inequality_cntr = 0; -k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 641; -k.biggest_literal_stats.constant_cntr = 1; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 450; -k.biggest_literal_stats.log_cntr = 0; -k.middle_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.true_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; -k.middle_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 3; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; -k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 22; -k.lemma_stats.addition_cntr = 0; -k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; -k.middle_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 1816; -k.theory_checksat_ms = 0.127112; -k.box_boolean_count = 1487; -k.biggest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; -k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 3; +k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 905; -k.smallest_assertion_stats.true_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 905; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; -k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.48373694190302663; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.632496; +expected_value = 0.41555135776245433; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 602: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 591: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.lemma_stats.equalto_cntr = 1; -k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_literal_stats.unique_variables = 1; -k.smallest_literal_stats.constant_cntr = 1; -k.middle_assertion_stats.constant_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 0; -k.assertions_stats.min_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.division_cntr = 0; +k.assertions_size = 514; +k.assertions_stats.abs_cntr = 0; +k.assertions_stats.addition_cntr = 517; +k.assertions_stats.conjunction_cntr = 514; +k.assertions_stats.constant_cntr = 1324; +k.assertions_stats.disjunction_cntr = 0; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 190; k.assertions_stats.exp_cntr = 0; -k.biggest_assertion_stats.realconstant_cntr = 0; -k.box_continuous_count = 581; -k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.box_integer_count = 0; -k.smallest_assertion_stats.exp_cntr = 0; -k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.log_cntr = 0; -k.middle_assertion_stats.forall_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; -k.lemma_stats.max_cntr = 0; -k.smallest_literal_stats.false_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; -k.biggest_assertion_stats.abs_cntr = 0; +k.assertions_stats.false_cntr = 0; +k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.min_cntr = 0; -k.assertions_stats.negation_cntr = 260; -k.assertions_stats.unique_variables = 581; -k.lemma_stats.conjunction_cntr = 6; -k.biggest_literal_stats.abs_cntr = 0; -k.middle_assertion_stats.abs_cntr = 0; -k.assertions_stats.division_cntr = 0; +k.assertions_stats.inequality_cntr = 324; +k.assertions_stats.log_cntr = 0; +k.assertions_stats.max_cntr = 0; +k.assertions_stats.min_cntr = 0; +k.assertions_stats.multiplication_cntr = 810; +k.assertions_stats.negation_cntr = 81; +k.assertions_stats.notequalto_cntr = 0; +k.assertions_stats.pow_cntr = 0; +k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.sqrt_cntr = 0; +k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.true_cntr = 0; +k.assertions_stats.uninterpretedfunction_cntr = 0; +k.assertions_stats.unique_variables = 212; +k.assertions_stats.variable_cntr = 1262; +k.biggest_assertion_stats.abs_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 5; k.biggest_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; -k.smallest_literal_stats.forall_cntr = 0; -k.smallest_assertion_stats.conjunction_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 7; +k.biggest_assertion_stats.disjunction_cntr = 0; +k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 0; +k.biggest_assertion_stats.exp_cntr = 0; +k.biggest_assertion_stats.false_cntr = 0; +k.biggest_assertion_stats.forall_cntr = 0; +k.biggest_assertion_stats.ifthenelse_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.log_cntr = 0; +k.biggest_assertion_stats.max_cntr = 0; +k.biggest_assertion_stats.min_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 6; +k.biggest_assertion_stats.negation_cntr = 0; +k.biggest_assertion_stats.notequalto_cntr = 0; +k.biggest_assertion_stats.pow_cntr = 0; +k.biggest_assertion_stats.realconstant_cntr = 0; +k.biggest_assertion_stats.sqrt_cntr = 0; +k.biggest_assertion_stats.trigonometry_cntr = 0; +k.biggest_assertion_stats.true_cntr = 0; +k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; +k.biggest_assertion_stats.unique_variables = 8; +k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_literal_stats.abs_cntr = 0; +k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.conjunction_cntr = 0; +k.biggest_literal_stats.constant_cntr = 3; +k.biggest_literal_stats.disjunction_cntr = 0; +k.biggest_literal_stats.division_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.exp_cntr = 0; +k.biggest_literal_stats.false_cntr = 0; +k.biggest_literal_stats.forall_cntr = 0; +k.biggest_literal_stats.ifthenelse_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.log_cntr = 0; +k.biggest_literal_stats.max_cntr = 0; +k.biggest_literal_stats.min_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 2; +k.biggest_literal_stats.negation_cntr = 0; +k.biggest_literal_stats.notequalto_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.sqrt_cntr = 0; +k.biggest_literal_stats.trigonometry_cntr = 0; +k.biggest_literal_stats.true_cntr = 0; +k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 2; -k.smallest_assertion_stats.constant_cntr = 1; -k.lemma_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.log_cntr = 0; -k.smallest_literal_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.false_cntr = 0; -k.assertions_stats.inequality_cntr = 469; -k.middle_literal_stats.notequalto_cntr = 0; -k.lemma_stats.unique_variables = 2; k.biggest_literal_stats.variable_cntr = 2; -k.middle_assertion_stats.disjunction_cntr = 0; -k.middle_assertion_stats.variable_cntr = 1; -k.lemma_stats.inequality_cntr = 5; -k.smallest_literal_stats.abs_cntr = 0; +k.box_boolean_count = 0; +k.box_continuous_count = 306; +k.box_integer_count = 0; +k.lemma_size = 3; +k.lemma_stats.abs_cntr = 0; +k.lemma_stats.addition_cntr = 0; +k.lemma_stats.conjunction_cntr = 3; +k.lemma_stats.constant_cntr = 5; +k.lemma_stats.disjunction_cntr = 0; +k.lemma_stats.division_cntr = 0; +k.lemma_stats.equalto_cntr = 1; +k.lemma_stats.exp_cntr = 0; +k.lemma_stats.false_cntr = 0; +k.lemma_stats.forall_cntr = 0; +k.lemma_stats.ifthenelse_cntr = 0; +k.lemma_stats.inequality_cntr = 2; +k.lemma_stats.log_cntr = 0; +k.lemma_stats.max_cntr = 0; +k.lemma_stats.min_cntr = 0; +k.lemma_stats.multiplication_cntr = 2; +k.lemma_stats.negation_cntr = 2; k.lemma_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; -k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.forall_cntr = 0; -k.middle_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.addition_cntr = 0; -k.biggest_assertion_stats.max_cntr = 0; -k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.exp_cntr = 0; -k.biggest_literal_stats.disjunction_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; -k.middle_literal_stats.false_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.forall_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 0; k.lemma_stats.pow_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.sqrt_cntr = 0; -k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.conjunction_cntr = 0; k.lemma_stats.realconstant_cntr = 0; -k.biggest_assertion_stats.exp_cntr = 0; -k.assertions_stats.forall_cntr = 0; k.lemma_stats.sqrt_cntr = 0; +k.lemma_stats.trigonometry_cntr = 0; +k.lemma_stats.true_cntr = 0; +k.lemma_stats.uninterpretedfunction_cntr = 0; +k.lemma_stats.unique_variables = 2; +k.lemma_stats.variable_cntr = 4; +k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; -k.assertions_stats.addition_cntr = 502; -k.middle_literal_stats.constant_cntr = 1; -k.assertions_stats.realconstant_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; -k.lemma_stats.variable_cntr = 7; -k.assertions_stats.disjunction_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; -k.assertions_stats.constant_cntr = 857; -k.smallest_assertion_stats.max_cntr = 0; +k.middle_assertion_stats.conjunction_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.disjunction_cntr = 0; +k.middle_assertion_stats.division_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; -k.middle_literal_stats.true_cntr = 0; -k.assertions_stats.false_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.biggest_literal_stats.division_cntr = 0; +k.middle_assertion_stats.forall_cntr = 0; +k.middle_assertion_stats.ifthenelse_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; -k.middle_assertion_stats.conjunction_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.notequalto_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; -k.biggest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; -k.assertions_stats.abs_cntr = 0; -k.smallest_literal_stats.true_cntr = 0; -k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.smallest_assertion_stats.disjunction_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; -k.smallest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.middle_literal_stats.min_cntr = 0; -k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; -k.lemma_stats.abs_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; -k.biggest_assertion_stats.negation_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; -k.smallest_literal_stats.min_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.middle_literal_stats.variable_cntr = 1; -k.middle_literal_stats.exp_cntr = 0; -k.smallest_literal_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; -k.assertions_stats.equalto_cntr = 649; -k.biggest_literal_stats.constant_cntr = 0; -k.biggest_assertion_stats.true_cntr = 0; -k.biggest_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.trigonometry_cntr = 0; -k.assertions_stats.multiplication_cntr = 264; -k.biggest_literal_stats.log_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.unique_variables = 1; -k.biggest_literal_stats.equalto_cntr = 1; -k.middle_literal_stats.unique_variables = 1; -k.smallest_assertion_stats.false_cntr = 0; -k.biggest_literal_stats.false_cntr = 0; -k.smallest_literal_stats.uninterpretedfunction_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; -k.smallest_assertion_stats.min_cntr = 0; -k.biggest_literal_stats.true_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.assertions_stats.log_cntr = 0; -k.assertions_stats.notequalto_cntr = 0; -k.middle_literal_stats.disjunction_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.notequalto_cntr = 0; +k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.variable_cntr = 1; -k.middle_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.forall_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.log_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; -k.lemma_size = 6; -k.biggest_assertion_stats.log_cntr = 0; -k.biggest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.variable_cntr = 1; -k.middle_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.variable_cntr = 3; -k.biggest_literal_stats.sqrt_cntr = 0; +k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.pow_cntr = 26; -k.lemma_stats.addition_cntr = 0; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; -k.biggest_assertion_stats.disjunction_cntr = 0; +k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.conjunction_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.disjunction_cntr = 0; +k.middle_literal_stats.division_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.exp_cntr = 0; +k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; -k.smallest_literal_stats.division_cntr = 0; -k.assertions_stats.true_cntr = 0; -k.assertions_stats.variable_cntr = 1976; -k.theory_checksat_ms = 1.08095; -k.box_boolean_count = 3064; -k.biggest_literal_stats.pow_cntr = 0; +k.middle_literal_stats.ifthenelse_cntr = 0; +k.middle_literal_stats.inequality_cntr = 0; k.middle_literal_stats.log_cntr = 0; -k.assertions_stats.max_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; -k.smallest_literal_stats.exp_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 0; +k.middle_literal_stats.max_cntr = 0; +k.middle_literal_stats.min_cntr = 0; +k.middle_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.notequalto_cntr = 0; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; -k.middle_assertion_stats.exp_cntr = 0; -k.smallest_literal_stats.max_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_literal_stats.multiplication_cntr = 0; -k.middle_assertion_stats.sqrt_cntr = 0; -k.lemma_stats.constant_cntr = 5; -k.smallest_literal_stats.multiplication_cntr = 0; +k.middle_literal_stats.true_cntr = 0; +k.middle_literal_stats.uninterpretedfunction_cntr = 0; +k.middle_literal_stats.unique_variables = 1; +k.middle_literal_stats.variable_cntr = 1; +k.smallest_assertion_stats.abs_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.conjunction_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.disjunction_cntr = 0; +k.smallest_assertion_stats.division_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.exp_cntr = 0; +k.smallest_assertion_stats.false_cntr = 0; +k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.log_cntr = 0; +k.smallest_assertion_stats.max_cntr = 0; +k.smallest_assertion_stats.min_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.notequalto_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; -k.middle_assertion_stats.equalto_cntr = 0; -k.biggest_literal_stats.negation_cntr = 0; -k.biggest_literal_stats.max_cntr = 0; -k.smallest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 1118; +k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; -k.smallest_literal_stats.sqrt_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; -k.assertions_size = 1118; -k.biggest_assertion_stats.inequality_cntr = 0; -k.middle_literal_stats.max_cntr = 0; +k.smallest_assertion_stats.uninterpretedfunction_cntr = 0; +k.smallest_assertion_stats.unique_variables = 1; +k.smallest_assertion_stats.variable_cntr = 1; +k.smallest_literal_stats.abs_cntr = 0; +k.smallest_literal_stats.addition_cntr = 0; +k.smallest_literal_stats.conjunction_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; -k.biggest_literal_stats.trigonometry_cntr = 0; -k.smallest_assertion_stats.abs_cntr = 0; -k.lemma_stats.forall_cntr = 0; -expected_value = 0.19428732097796983; +k.smallest_literal_stats.division_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.exp_cntr = 0; +k.smallest_literal_stats.false_cntr = 0; +k.smallest_literal_stats.forall_cntr = 0; +k.smallest_literal_stats.ifthenelse_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.log_cntr = 0; +k.smallest_literal_stats.max_cntr = 0; +k.smallest_literal_stats.min_cntr = 0; +k.smallest_literal_stats.multiplication_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.notequalto_cntr = 0; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.sqrt_cntr = 0; +k.smallest_literal_stats.trigonometry_cntr = 0; +k.smallest_literal_stats.true_cntr = 0; +k.smallest_literal_stats.uninterpretedfunction_cntr = 0; +k.smallest_literal_stats.unique_variables = 1; +k.smallest_literal_stats.variable_cntr = 1; +k.theory_checksat_ms = 0.560366; +expected_value = 0.19257991774231606; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 3222: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 3469: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); From 9b68c59f519d7ee52e93dc827bfe6f6cf808e92f Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 14 Apr 2025 04:38:01 -0700 Subject: [PATCH 25/79] Revert "Upgrade SAT solver from PicoSAT to CaDiCaL." This reverts commit 299785e2 --- src/dreal/solver/sat_solver.cc | 73 ++++++++++++++-------------------- src/dreal/solver/sat_solver.h | 9 ++--- 2 files changed, 33 insertions(+), 49 deletions(-) diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 42903c1b7..ca7154a60 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -32,26 +32,21 @@ using std::cout; using std::set; using std::vector; -SatSolver::SatSolver(const Config& config) : cadical(new CaDiCaL::Solver) { +SatSolver::SatSolver(const Config& config) : sat_{picosat_init()} { + // Enable partial checks via picosat_deref_partial. See the call-site in // SatSolver::CheckSat(). + picosat_save_original_clauses(sat_); if (config.random_seed() != 0) { - cadical->set("seed", config.random_seed()); + picosat_set_seed(sat_, config.random_seed()); DREAL_LOG_DEBUG("SatSolver::Set Random Seed {}", config.random_seed()); } - // this actually doesn't work lol. - // cadical->set("phase", static_cast(config.sat_default_phase())); - // DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", - // config.sat_default_phase()); - - // todo: look into this? want to absolutely minimize calls to theory solver. - // eliminate as many variables as possible. ? - cadical->optimize(9); - cadical->set("condition", 1); // "globally blocked clause elim" - cadical->set("cover", 1); // "covered clause elimination" - cadical->set("block", 1); // "blocked clause elimination" + picosat_set_global_default_phase( + sat_, static_cast(config.sat_default_phase())); + DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", + config.sat_default_phase()); } -SatSolver::~SatSolver() { delete cadical; } +SatSolver::~SatSolver() { picosat_reset(sat_); } void SatSolver::AddFormula(const Formula& f) { DREAL_LOG_DEBUG("SatSolver::AddFormula({})", f); @@ -70,7 +65,7 @@ void SatSolver::AddLearnedClause(const vector& conflicting_conjunction, for (const Formula& f : conflicting_conjunction) { AddLiteral(!predicate_abstractor_.Convert(f)); } - cadical->add(0); + picosat_add(sat_, 0); } void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { @@ -84,7 +79,7 @@ void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { ) { // todo: audit? currently can't because it is already predicate_abstractor-ed AddLiteral(lit); - cadical->add(0); + picosat_add(sat_, 0); } } } @@ -129,7 +124,7 @@ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( // ==> for (const Formula& f : conflict_clause) AddLiteral(!predicate_abstractor_.Convert(f)); - cadical->add(0); + picosat_add(sat_, 0); } return match_statistics; } @@ -150,7 +145,7 @@ void SatSolver::AddClause(const Formula& f) { // f = b or f = ¬b. AddLiteral(f); } - cadical->add(0); + picosat_add(sat_, 0); } namespace { @@ -180,27 +175,22 @@ class SatSolverStat : public Stat { optional SatSolver::CheckSat() { static SatSolverStat stat{DREAL_LOG_INFO_ENABLED}; DREAL_LOG_DEBUG("SatSolver::CheckSat(#vars = {}, #clauses = {})", - cadical->vars(), - cadical->irredundant()); + picosat_variables(sat_), + picosat_added_original_clauses(sat_)); stat.num_check_sat_++; // Call SAT solver. TimerGuard check_sat_timer_guard(&stat.timer_check_sat_, DREAL_LOG_INFO_ENABLED); - const int ret{cadical->solve()}; - // check_sat_timer_guard.pause(); + const int ret{picosat_sat(sat_, -1 /* decision_limit == no limit */)}; + check_sat_timer_guard.pause(); Model model; - if (ret == CaDiCaL::SATISFIABLE) { + if (ret == PICOSAT_SATISFIABLE) { // SAT Case. const auto& var_to_formula_map = predicate_abstractor_.var_to_formula_map(); - // from CaDiCaL documentation: - // try to avoid mixing 'flip' and 'val' (for efficiency only). - std::vector model_is(cadical->vars()+1); - for (int i = 1; i <= cadical->vars(); ++i) model_is[i] = cadical->val(i) > 0 ? +1 : -1; - for (int i = 1; i <= cadical->vars(); ++i) if(cadical->flip(i)) model_is[i] = 0; // todo: use IPASIR-UP, see cvc5 paper. - // for (int i = 1; i <= cadical->vars(); ++i) if(model_is[i] == 0) cadical->flip(i); // restore default state. - for (int i = 1; i <= cadical->vars(); ++i) { - const auto model_i = model_is[i]; + for (int i = 1; i <= picosat_variables(sat_); ++i) { + const int model_i{has_picosat_pop_used_ ? picosat_deref(sat_, i) + : picosat_deref_partial(sat_, i)}; if (model_i == 0) { continue; } @@ -232,14 +222,14 @@ optional SatSolver::CheckSat() { } DREAL_LOG_DEBUG("SatSolver::CheckSat() Found a model."); return model; - } else if (ret == CaDiCaL::UNSATISFIABLE) { + } else if (ret == PICOSAT_UNSATISFIABLE) { DREAL_LOG_DEBUG("SatSolver::CheckSat() No solution."); // UNSAT Case. return {}; } else { - DREAL_ASSERT(ret == CaDiCaL::UNKNOWN); - DREAL_LOG_CRITICAL("CaDiCaL returns CaDiCaL::UNKNOWN."); - throw DREAL_RUNTIME_ERROR("CaDiCaL returns CaDiCaL::UNKNOWN."); + DREAL_ASSERT(ret == PICOSAT_UNKNOWN); + DREAL_LOG_CRITICAL("PICOSAT returns PICOSAT_UNKNOWN."); + throw DREAL_RUNTIME_ERROR("PICOSAT returns PICOSAT_UNKNOWN."); } } @@ -248,15 +238,13 @@ void SatSolver::Pop() { tseitin_variables_.pop(); to_sym_var_.pop(); to_sat_var_.pop(); - // picosat_pop(sat_); - throw DREAL_RUNTIME_ERROR("NOT YET IMPLEMENTED SatSolver::Pop()"); + picosat_pop(sat_); has_picosat_pop_used_ = true; } void SatSolver::Push() { DREAL_LOG_DEBUG("SatSolver::Push()"); - // picosat_push(sat_); - throw DREAL_RUNTIME_ERROR("NOT YET IMPLEMENTED SatSolver::Push()"); + picosat_push(sat_); to_sat_var_.push(); to_sym_var_.push(); tseitin_variables_.push(); @@ -270,14 +258,14 @@ void SatSolver::AddLiteral(const Formula& f) { const Variable& var{get_variable(f)}; DREAL_ASSERT(var.get_type() == Variable::Type::BOOLEAN); // Add l = b - cadical->add(to_sat_var_[var.get_id()]); + picosat_add(sat_, to_sat_var_[var.get_id()]); } else { // f = ¬b DREAL_ASSERT(is_negation(f) && is_variable(get_operand(f))); const Variable& var{get_variable(get_operand(f))}; DREAL_ASSERT(var.get_type() == Variable::Type::BOOLEAN); // Add l = ¬b - cadical->add(-to_sat_var_[var.get_id()]); + picosat_add(sat_, -to_sat_var_[var.get_id()]); } } @@ -288,8 +276,7 @@ void SatSolver::MakeSatVar(const Variable& var) { return; } // It's not in the maps, let's make one and add it. - const int sat_var{cadical_next_var++}; - // std::cout << "Assigning `" << var << "` (id #"<< var.get_id() <<") to " << sat_var << std::endl; + const int sat_var{picosat_inc_max_var(sat_)}; to_sat_var_.insert(var.get_id(), sat_var); to_sym_var_.insert(sat_var, var); DREAL_LOG_DEBUG("SatSolver::MakeSatVar({} ↦ {})", fmt::streamed(var), sat_var); diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 2717b50de..7f0783e00 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -20,11 +20,9 @@ #include #include -// #include "./picosat.h" +#include "./picosat.h" #include -#include "cadical.hpp" - #include "dreal/solver/config.h" #include "dreal/symbolic/symbolic.h" #include "dreal/util/optional.h" @@ -110,9 +108,8 @@ class SatSolver { // Member variables // ---------------- - CaDiCaL::Solver* const cadical; - int cadical_next_var = 1; - + // Pointer to the PicoSat solver. + PicoSAT* const sat_{}; TseitinCnfizer cnfizer_; PredicateAbstractor predicate_abstractor_; From eb8b10ddced1659ef132cc6ab388caac56401a3d Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Wed, 16 Apr 2025 22:42:01 -0700 Subject: [PATCH 26/79] Revert "Revert "Upgrade SAT solver from PicoSAT to CaDiCaL."" i.e. back to CaDiCaL... PicoSAT didn't help. This reverts commit 9b68c59f519d7ee52e93dc827bfe6f6cf808e92f. --- src/dreal/solver/sat_solver.cc | 73 ++++++++++++++++++++-------------- src/dreal/solver/sat_solver.h | 9 +++-- 2 files changed, 49 insertions(+), 33 deletions(-) diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index ca7154a60..42903c1b7 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -32,21 +32,26 @@ using std::cout; using std::set; using std::vector; -SatSolver::SatSolver(const Config& config) : sat_{picosat_init()} { - // Enable partial checks via picosat_deref_partial. See the call-site in +SatSolver::SatSolver(const Config& config) : cadical(new CaDiCaL::Solver) { // SatSolver::CheckSat(). - picosat_save_original_clauses(sat_); if (config.random_seed() != 0) { - picosat_set_seed(sat_, config.random_seed()); + cadical->set("seed", config.random_seed()); DREAL_LOG_DEBUG("SatSolver::Set Random Seed {}", config.random_seed()); } - picosat_set_global_default_phase( - sat_, static_cast(config.sat_default_phase())); - DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", - config.sat_default_phase()); + // this actually doesn't work lol. + // cadical->set("phase", static_cast(config.sat_default_phase())); + // DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", + // config.sat_default_phase()); + + // todo: look into this? want to absolutely minimize calls to theory solver. + // eliminate as many variables as possible. ? + cadical->optimize(9); + cadical->set("condition", 1); // "globally blocked clause elim" + cadical->set("cover", 1); // "covered clause elimination" + cadical->set("block", 1); // "blocked clause elimination" } -SatSolver::~SatSolver() { picosat_reset(sat_); } +SatSolver::~SatSolver() { delete cadical; } void SatSolver::AddFormula(const Formula& f) { DREAL_LOG_DEBUG("SatSolver::AddFormula({})", f); @@ -65,7 +70,7 @@ void SatSolver::AddLearnedClause(const vector& conflicting_conjunction, for (const Formula& f : conflicting_conjunction) { AddLiteral(!predicate_abstractor_.Convert(f)); } - picosat_add(sat_, 0); + cadical->add(0); } void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { @@ -79,7 +84,7 @@ void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { ) { // todo: audit? currently can't because it is already predicate_abstractor-ed AddLiteral(lit); - picosat_add(sat_, 0); + cadical->add(0); } } } @@ -124,7 +129,7 @@ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( // ==> for (const Formula& f : conflict_clause) AddLiteral(!predicate_abstractor_.Convert(f)); - picosat_add(sat_, 0); + cadical->add(0); } return match_statistics; } @@ -145,7 +150,7 @@ void SatSolver::AddClause(const Formula& f) { // f = b or f = ¬b. AddLiteral(f); } - picosat_add(sat_, 0); + cadical->add(0); } namespace { @@ -175,22 +180,27 @@ class SatSolverStat : public Stat { optional SatSolver::CheckSat() { static SatSolverStat stat{DREAL_LOG_INFO_ENABLED}; DREAL_LOG_DEBUG("SatSolver::CheckSat(#vars = {}, #clauses = {})", - picosat_variables(sat_), - picosat_added_original_clauses(sat_)); + cadical->vars(), + cadical->irredundant()); stat.num_check_sat_++; // Call SAT solver. TimerGuard check_sat_timer_guard(&stat.timer_check_sat_, DREAL_LOG_INFO_ENABLED); - const int ret{picosat_sat(sat_, -1 /* decision_limit == no limit */)}; - check_sat_timer_guard.pause(); + const int ret{cadical->solve()}; + // check_sat_timer_guard.pause(); Model model; - if (ret == PICOSAT_SATISFIABLE) { + if (ret == CaDiCaL::SATISFIABLE) { // SAT Case. const auto& var_to_formula_map = predicate_abstractor_.var_to_formula_map(); - for (int i = 1; i <= picosat_variables(sat_); ++i) { - const int model_i{has_picosat_pop_used_ ? picosat_deref(sat_, i) - : picosat_deref_partial(sat_, i)}; + // from CaDiCaL documentation: + // try to avoid mixing 'flip' and 'val' (for efficiency only). + std::vector model_is(cadical->vars()+1); + for (int i = 1; i <= cadical->vars(); ++i) model_is[i] = cadical->val(i) > 0 ? +1 : -1; + for (int i = 1; i <= cadical->vars(); ++i) if(cadical->flip(i)) model_is[i] = 0; // todo: use IPASIR-UP, see cvc5 paper. + // for (int i = 1; i <= cadical->vars(); ++i) if(model_is[i] == 0) cadical->flip(i); // restore default state. + for (int i = 1; i <= cadical->vars(); ++i) { + const auto model_i = model_is[i]; if (model_i == 0) { continue; } @@ -222,14 +232,14 @@ optional SatSolver::CheckSat() { } DREAL_LOG_DEBUG("SatSolver::CheckSat() Found a model."); return model; - } else if (ret == PICOSAT_UNSATISFIABLE) { + } else if (ret == CaDiCaL::UNSATISFIABLE) { DREAL_LOG_DEBUG("SatSolver::CheckSat() No solution."); // UNSAT Case. return {}; } else { - DREAL_ASSERT(ret == PICOSAT_UNKNOWN); - DREAL_LOG_CRITICAL("PICOSAT returns PICOSAT_UNKNOWN."); - throw DREAL_RUNTIME_ERROR("PICOSAT returns PICOSAT_UNKNOWN."); + DREAL_ASSERT(ret == CaDiCaL::UNKNOWN); + DREAL_LOG_CRITICAL("CaDiCaL returns CaDiCaL::UNKNOWN."); + throw DREAL_RUNTIME_ERROR("CaDiCaL returns CaDiCaL::UNKNOWN."); } } @@ -238,13 +248,15 @@ void SatSolver::Pop() { tseitin_variables_.pop(); to_sym_var_.pop(); to_sat_var_.pop(); - picosat_pop(sat_); + // picosat_pop(sat_); + throw DREAL_RUNTIME_ERROR("NOT YET IMPLEMENTED SatSolver::Pop()"); has_picosat_pop_used_ = true; } void SatSolver::Push() { DREAL_LOG_DEBUG("SatSolver::Push()"); - picosat_push(sat_); + // picosat_push(sat_); + throw DREAL_RUNTIME_ERROR("NOT YET IMPLEMENTED SatSolver::Push()"); to_sat_var_.push(); to_sym_var_.push(); tseitin_variables_.push(); @@ -258,14 +270,14 @@ void SatSolver::AddLiteral(const Formula& f) { const Variable& var{get_variable(f)}; DREAL_ASSERT(var.get_type() == Variable::Type::BOOLEAN); // Add l = b - picosat_add(sat_, to_sat_var_[var.get_id()]); + cadical->add(to_sat_var_[var.get_id()]); } else { // f = ¬b DREAL_ASSERT(is_negation(f) && is_variable(get_operand(f))); const Variable& var{get_variable(get_operand(f))}; DREAL_ASSERT(var.get_type() == Variable::Type::BOOLEAN); // Add l = ¬b - picosat_add(sat_, -to_sat_var_[var.get_id()]); + cadical->add(-to_sat_var_[var.get_id()]); } } @@ -276,7 +288,8 @@ void SatSolver::MakeSatVar(const Variable& var) { return; } // It's not in the maps, let's make one and add it. - const int sat_var{picosat_inc_max_var(sat_)}; + const int sat_var{cadical_next_var++}; + // std::cout << "Assigning `" << var << "` (id #"<< var.get_id() <<") to " << sat_var << std::endl; to_sat_var_.insert(var.get_id(), sat_var); to_sym_var_.insert(sat_var, var); DREAL_LOG_DEBUG("SatSolver::MakeSatVar({} ↦ {})", fmt::streamed(var), sat_var); diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 7f0783e00..2717b50de 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -20,9 +20,11 @@ #include #include -#include "./picosat.h" +// #include "./picosat.h" #include +#include "cadical.hpp" + #include "dreal/solver/config.h" #include "dreal/symbolic/symbolic.h" #include "dreal/util/optional.h" @@ -108,8 +110,9 @@ class SatSolver { // Member variables // ---------------- - // Pointer to the PicoSat solver. - PicoSAT* const sat_{}; + CaDiCaL::Solver* const cadical; + int cadical_next_var = 1; + TseitinCnfizer cnfizer_; PredicateAbstractor predicate_abstractor_; From 3ffeefd573d544edc7946de92aa4e948e4de0f75 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Wed, 16 Apr 2025 22:46:29 -0700 Subject: [PATCH 27/79] Update logging levels to make DEBUG mode more useful on large queries. --- src/dreal/solver/context_impl.cc | 8 ++++++-- src/dreal/solver/theory_solver.cc | 2 +- src/dreal/util/ibex_converter.cc | 6 +++--- .../pattern_matching/pattern_matching_trie_general.cc | 8 ++++++-- src/dreal/util/predicate_abstractor.h | 3 +++ 5 files changed, 19 insertions(+), 8 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 490d5bb13..a79ef4c77 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -207,6 +207,10 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, //////////////////////////////////////////////////////////////////////////////// DREAL_LOG_INFO("Initialized. Beginning SAT <=> Theory cycles."); + DREAL_LOG_INFO( + "{} continuous variables. {} integer variables. {} boolean variables.", + kunal_paper_data.box_continuous_count, kunal_paper_data.box_integer_count, kunal_paper_data.box_boolean_count + ); while (true) { // Note that 'DREAL_CHECK_INTERRUPT' is only defined in setup.py, // when we build dReal python package. @@ -396,7 +400,7 @@ optional Context::Impl::CheckSat() { } void Context::Impl::AddToBox(const Variable& v) { - DREAL_LOG_DEBUG("ContextImpl::AddToBox({})", fmt::streamed(v)); + DREAL_LOG_TRACE("ContextImpl::AddToBox({})", fmt::streamed(v)); const auto& variables = box().variables(); if (find_if(variables.begin(), variables.end(), [&v](const Variable& v_) { return v.equal_to(v_); @@ -408,7 +412,7 @@ void Context::Impl::AddToBox(const Variable& v) { void Context::Impl::DeclareVariable(const Variable& v, const bool is_model_variable) { - DREAL_LOG_DEBUG("ContextImpl::DeclareVariable({})", fmt::streamed(v)); + DREAL_LOG_TRACE("ContextImpl::DeclareVariable({})", fmt::streamed(v)); AddToBox(v); if (is_model_variable) { mark_model_variable(v); diff --git a/src/dreal/solver/theory_solver.cc b/src/dreal/solver/theory_solver.cc index dc7482916..1cc56751a 100644 --- a/src/dreal/solver/theory_solver.cc +++ b/src/dreal/solver/theory_solver.cc @@ -175,7 +175,7 @@ optional TheorySolver::BuildContractor( auto it = contractor_cache_.find(f); if (it == contractor_cache_.end()) { // There is no contractor for `f`, build one. - DREAL_LOG_DEBUG( + DREAL_LOG_TRACE( "TheorySolver::BuildContractor: Turn {} into a contractor", f); if (is_forall(f)) { // We should have `inner_delta < epsilon < delta`. diff --git a/src/dreal/util/ibex_converter.cc b/src/dreal/util/ibex_converter.cc index 6ef379fd8..6c21dc9f9 100644 --- a/src/dreal/util/ibex_converter.cc +++ b/src/dreal/util/ibex_converter.cc @@ -74,7 +74,7 @@ IbexConverter::IbexConverter(const vector& variables) symbolic_var_to_ibex_var_.reserve(variables.size()); for (const Variable& var : vars_) { // The variable is new, we need to make one. - DREAL_LOG_DEBUG("IbexConverter::IbexConverter: Create variable {}", fmt::streamed(var)); + DREAL_LOG_TRACE("IbexConverter::IbexConverter: Create variable {}", fmt::streamed(var)); const ibex::ExprSymbol* v{ &ibex::ExprSymbol::new_(var.get_name().c_str(), ibex::Dim::scalar())}; // Update Variable → ibex::ExprSymbol* @@ -98,7 +98,7 @@ IbexConverter::~IbexConverter() { } const ExprCtr* IbexConverter::Convert(const Formula& f) { - DREAL_LOG_DEBUG("IbexConverter::Convert({})", f); + DREAL_LOG_TRACE("IbexConverter::Convert({})", f); thread_local IbexConverterStat stat{DREAL_LOG_INFO_ENABLED}; TimerGuard timer_guard(&stat.timer_convert_, stat.enabled()); stat.increase_convert(); @@ -111,7 +111,7 @@ const ExprCtr* IbexConverter::Convert(const Formula& f) { } const ExprNode* IbexConverter::Convert(const Expression& e) { - DREAL_LOG_DEBUG("IbexConverter::Convert({})", fmt::streamed(e)); + DREAL_LOG_TRACE("IbexConverter::Convert({})", fmt::streamed(e)); const ExprNode* expr_node{Visit(e)}; if (expr_node) { need_to_delete_variables_ = false; diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index 18bbb30d2..6f81b3801 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -46,6 +46,8 @@ namespace dreal result.emplace_back(matches_vec, s); }; + bool did_time_out = false; + const auto ibegin = literals.begin(); const auto iend = literals.end(); std::unordered_set seen_truncateds; // lexo-compare for nary goes one by one... @@ -54,8 +56,8 @@ namespace dreal std::function(typeof(ibegin)) > match_next_literal = [&](const auto& it1) { return [&, /*copy*/ it1](const auto& f, auto& s2) { - if (std::chrono::steady_clock::now() - start_time > timeout) { - DREAL_LOG_ERROR("Pattern matching timed out after {} usec.", timeout.count()); + if (did_time_out || std::chrono::steady_clock::now() - start_time > timeout) { + did_time_out = true; return; } @@ -91,6 +93,8 @@ namespace dreal recMatchForm(*ibegin, f_root, substitutions, match_next_literal(ibegin), partial_matches, misses); DREAL_ASSERT(result.size() == stats.matches); + if (did_time_out) + DREAL_LOG_WARN("Pattern matching timed out after {} usec.", timeout.count()); DREAL_LOG_INFO( "Found {} matches of size {} ({} effective literals) with {} misses.", stats.matches, literals.size(), stats.matches / ::pow(2, literals.size()), stats.misses diff --git a/src/dreal/util/predicate_abstractor.h b/src/dreal/util/predicate_abstractor.h index 81053da46..9ba64195c 100644 --- a/src/dreal/util/predicate_abstractor.h +++ b/src/dreal/util/predicate_abstractor.h @@ -19,6 +19,7 @@ #include #include +#include "assert.h" #include "dreal/symbolic/symbolic.h" namespace dreal { @@ -43,10 +44,12 @@ class PredicateAbstractor { } const Variable& operator[](const Formula& f) const { + DREAL_ASSERT(formula_to_var_map_.count(f)); // creates debuggable stack trace return formula_to_var_map_.at(f); } const Formula& operator[](const Variable& var) const { + DREAL_ASSERT(var_to_formula_map_.count(var)); // creates debuggable stack trace return var_to_formula_map_.at(var); } From ee73de7922247b5dd90f228903799a7d0d6e5bdc Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 17 Apr 2025 01:56:00 -0700 Subject: [PATCH 28/79] Tap into SAT solver learned clauses via `CaDiCaL::Learner` listening interface. --- src/dreal/solver/sat_solver.cc | 39 ++++++++++++++++++++++++++++++++++ src/dreal/solver/sat_solver.h | 18 ++++++++++------ 2 files changed, 50 insertions(+), 7 deletions(-) diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 42903c1b7..7a0749b1a 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -49,6 +49,8 @@ SatSolver::SatSolver(const Config& config) : cadical(new CaDiCaL::Solver) { cadical->set("condition", 1); // "globally blocked clause elim" cadical->set("cover", 1); // "covered clause elimination" cadical->set("block", 1); // "blocked clause elimination" + + cadical->connect_learner(this); } SatSolver::~SatSolver() { delete cadical; } @@ -376,4 +378,41 @@ Formula SatSolver::MakeSatIntervalVar(PredicateNormalizer &pn, const Variable& v Formula SatSolver::theory_literal(const Variable& var) const { return predicate_abstractor_[var]; } + +bool SatSolver::learning(const int size) { + buffer_i = 0; + expected_clause_size = size; + return size < BUFFER_SIZE; +} + +void SatSolver::learn(const int new_lit) { + if (new_lit != 0) { + DREAL_ASSERT(buffer_i < expected_clause_size); + buffer[buffer_i] = new_lit; + buffer_i++; + return; + } // else { + + DREAL_ASSERT(buffer_i == expected_clause_size); + + set neg_conjunction; + for (int i = 0; i < expected_clause_size; i++) { + const int lit = buffer[i]; + const bool lit_is_neg = lit < 0; + + const auto sym_var_it = to_sym_var_.find(lit_is_neg ? -lit : +lit); + DREAL_ASSERT(sym_var_it != to_sym_var_.end()); + const auto theory_lit_it = predicate_abstractor_.var_to_formula_map().find(sym_var_it->second); + const Formula theory_lit = + theory_lit_it == predicate_abstractor_.var_to_formula_map().end() + ? Formula{sym_var_it->second} + : theory_lit_it->second; + neg_conjunction.emplace( + !(lit_is_neg ? !theory_lit : theory_lit) + ); + } + const Formula sat_clause = !make_conjunction(neg_conjunction); + std::cout << "LEARNED: " << sat_clause << std::endl; +} + } // namespace dreal diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 2717b50de..b2b290e97 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -35,7 +35,7 @@ namespace dreal { -class SatSolver { +class SatSolver : public CaDiCaL::Learner { public: using Literal = std::pair; @@ -129,12 +129,16 @@ class SatSolver { std::unordered_map> all_lb_predicates; std::unordered_map> all_ub_predicates; - /// @note We found an issue when picosat_deref_partial is used with - /// picosat_pop. When this variable is true, we use `picosat_deref` - /// instead. - /// - /// TODO(soonho): Remove this hack when it's not needed. - bool has_picosat_pop_used_{false}; + // learner stuff. +private: + static constexpr size_t BUFFER_SIZE = 3; + int buffer[BUFFER_SIZE] = {0}; + int buffer_i = 0; + int expected_clause_size = 0; + +public: + bool learning(int size) override; + void learn(int new_lit) override; }; } // namespace dreal From 84ee72c4c64bb9f366d3c38ff1fb5936314fba87 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 17 Apr 2025 01:59:01 -0700 Subject: [PATCH 29/79] Remove unnecessary lemma_stats measurements and retrain neural network. --- src/dreal/solver/context_impl.cc | 2 +- .../pattern_matching_heuristic.cc | 304 ++- .../test/pattern_matching_heuristic_test.cc | 1648 ++++++----------- 3 files changed, 691 insertions(+), 1263 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index a79ef4c77..dc1a44442 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -287,7 +287,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.lemma_size = explanation_vec.size(); const auto ranking_start2 = std::chrono::high_resolution_clock::now(); - kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation)); + // kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation.first)); // doing individual literals doesn't cost extra because they cache hit after running the entire conjunction kunal_paper_data.biggest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[0]); kunal_paper_data.middle_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size() / 2]); diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc index ba307588a..e1fb165be 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc @@ -1,13 +1,13 @@ -// This file was automatically generated on 2025-04-14 01:52:12.066920 by Kunal in the `WORTH_IT_regression` python notebook. +// This file was automatically generated on 2025-04-17 00:30:08.818979 by Kunal in the `WORTH_IT_regression` python notebook. // // Notes: -// len(df_overestimated) / len(df) = 0.015 -// len(df_valid_over) / len(df) = 0.189 -// len(df_valid_under) / len(df) = 0.784 -// len(df_underestimated) / len(df) = 0.012 +// len(df_overestimated) / len(df) = 0.012 +// len(df_valid_over) / len(df) = 0.191 +// len(df_valid_under) / len(df) = 0.787 +// len(df_underestimated) / len(df) = 0.010 // -// accuracy_score(y_test, y_pred) = 0.966657085369359 +// accuracy_score(y_test, y_pred) = 0.9698189134808853 // len(X_train) = 13913 // len(X_test) / len(X_train) = 0.25 // model = Pipeline(steps=[('standardscaler', StandardScaler()), ('mlpclassifier', MLPClassifier(hidden_layer_sizes=(8, 4), max_iter=1000, random_state=42))]) @@ -20,7 +20,7 @@ namespace dreal float relu(const float x) { return x < 0 ? 0 : x; } float sigmoid(const float x) { return 1 / (1 + expf(-x)); } - float PatternMatchingHeuristic::calculate(const statistics& k) { + float PatternMatchingHeuristic::calculate(const statistics &k) { const float LOG2P1_assertions_size = log2(1+k.assertions_size); const float LOG2P1_box_boolean_count = log2(1+k.box_boolean_count); @@ -111,32 +111,6 @@ const float box_boolean_count = k.box_boolean_count; const float box_continuous_count = k.box_continuous_count; const float box_integer_count = k.box_integer_count; const float lemma_size = k.lemma_size; -const float lemma_stats_abs_cntr = k.lemma_stats.abs_cntr; -const float lemma_stats_addition_cntr = k.lemma_stats.addition_cntr; -const float lemma_stats_conjunction_cntr = k.lemma_stats.conjunction_cntr; -const float lemma_stats_constant_cntr = k.lemma_stats.constant_cntr; -const float lemma_stats_disjunction_cntr = k.lemma_stats.disjunction_cntr; -const float lemma_stats_division_cntr = k.lemma_stats.division_cntr; -const float lemma_stats_equalto_cntr = k.lemma_stats.equalto_cntr; -const float lemma_stats_exp_cntr = k.lemma_stats.exp_cntr; -const float lemma_stats_false_cntr = k.lemma_stats.false_cntr; -const float lemma_stats_forall_cntr = k.lemma_stats.forall_cntr; -const float lemma_stats_ifthenelse_cntr = k.lemma_stats.ifthenelse_cntr; -const float lemma_stats_inequality_cntr = k.lemma_stats.inequality_cntr; -const float lemma_stats_log_cntr = k.lemma_stats.log_cntr; -const float lemma_stats_max_cntr = k.lemma_stats.max_cntr; -const float lemma_stats_min_cntr = k.lemma_stats.min_cntr; -const float lemma_stats_multiplication_cntr = k.lemma_stats.multiplication_cntr; -const float lemma_stats_negation_cntr = k.lemma_stats.negation_cntr; -const float lemma_stats_notequalto_cntr = k.lemma_stats.notequalto_cntr; -const float lemma_stats_pow_cntr = k.lemma_stats.pow_cntr; -const float lemma_stats_realconstant_cntr = k.lemma_stats.realconstant_cntr; -const float lemma_stats_sqrt_cntr = k.lemma_stats.sqrt_cntr; -const float lemma_stats_trigonometry_cntr = k.lemma_stats.trigonometry_cntr; -const float lemma_stats_true_cntr = k.lemma_stats.true_cntr; -const float lemma_stats_uninterpretedfunction_cntr = k.lemma_stats.uninterpretedfunction_cntr; -const float lemma_stats_unique_variables = k.lemma_stats.unique_variables; -const float lemma_stats_variable_cntr = k.lemma_stats.variable_cntr; const float middle_assertion_stats_abs_cntr = k.middle_assertion_stats.abs_cntr; const float middle_assertion_stats_addition_cntr = k.middle_assertion_stats.addition_cntr; const float middle_assertion_stats_conjunction_cntr = k.middle_assertion_stats.conjunction_cntr; @@ -243,7 +217,7 @@ const float smallest_literal_stats_unique_variables = k.smallest_literal_stats.u const float smallest_literal_stats_variable_cntr = k.smallest_literal_stats.variable_cntr; const float theory_checksat_ms = k.theory_checksat_ms; -float x0[220]; +float x0[194]; float x1[8]; float x2[4]; float x3_result[1]; @@ -337,150 +311,124 @@ x0[85] = 0.00046904838095628324*box_boolean_count - 0.5936472249093071; x0[86] = 0.0016902606416621386*box_continuous_count - 0.6017648612276244; x0[87] = 1.9019154961840616*box_integer_count - 0.9737183985710538; x0[88] = 0.0064402310088025709*lemma_size - 0.11973423085545294; -x0[89] = 28.615217352461183*lemma_stats_abs_cntr - 0.022623976919217494; -x0[90] = 0.0052312396662408259*lemma_stats_addition_cntr - 0.057936176701793296; -x0[91] = 0.0064400668754121719*lemma_stats_conjunction_cntr - 0.11951223651954426; -x0[92] = 0.0051204320855597965*lemma_stats_constant_cntr - 0.097456400343892496; -x0[93] = 1.0*lemma_stats_disjunction_cntr; -x0[94] = 1.1314935931259746*lemma_stats_division_cntr - 0.077829322836308321; -x0[95] = 0.010959097474016669*lemma_stats_equalto_cntr - 0.12607333761257372; -x0[96] = 1.0*lemma_stats_exp_cntr; -x0[97] = 1.0*lemma_stats_false_cntr; -x0[98] = 1.0*lemma_stats_forall_cntr; -x0[99] = 1.0*lemma_stats_ifthenelse_cntr; -x0[100] = 0.014886936153706839*lemma_stats_inequality_cntr - 0.10551288536742841; -x0[101] = 1.0*lemma_stats_log_cntr; -x0[102] = 1.0*lemma_stats_max_cntr; -x0[103] = 1.0*lemma_stats_min_cntr; -x0[104] = 0.0054124685449075819*lemma_stats_multiplication_cntr - 0.065841650884572944; -x0[105] = 0.016785227125474561*lemma_stats_negation_cntr - 0.080341796535172358; -x0[106] = 1.0*lemma_stats_notequalto_cntr; -x0[107] = 0.11292569409072524*lemma_stats_pow_cntr - 0.11682975927132171; -x0[108] = 0.18193265637824893*lemma_stats_realconstant_cntr - 0.19706210965429538; -x0[109] = 1.0*lemma_stats_sqrt_cntr; -x0[110] = 1.5980485926746135*lemma_stats_trigonometry_cntr - 0.087753117573737133; -x0[111] = 1.0*lemma_stats_true_cntr; -x0[112] = 1.0*lemma_stats_uninterpretedfunction_cntr; -x0[113] = 0.0066135984914860377*lemma_stats_unique_variables - 0.097686172442849412; -x0[114] = 0.0020688498721947095*lemma_stats_variable_cntr - 0.085178681584834798; -x0[115] = 1.0*middle_assertion_stats_abs_cntr; -x0[116] = 2.0684090968641597*middle_assertion_stats_addition_cntr - 0.23132642526562444; -x0[117] = 1.0*middle_assertion_stats_conjunction_cntr; -x0[118] = 0.97347244624775553*middle_assertion_stats_constant_cntr - 0.80750704392620909; -x0[119] = 1.0*middle_assertion_stats_disjunction_cntr; -x0[120] = 1.0*middle_assertion_stats_division_cntr; -x0[121] = 2.7895691267196265*middle_assertion_stats_equalto_cntr - 2.3671137145153391; -x0[122] = 1.0*middle_assertion_stats_exp_cntr; -x0[123] = 1.0*middle_assertion_stats_false_cntr; -x0[124] = 1.0*middle_assertion_stats_forall_cntr; -x0[125] = 1.0*middle_assertion_stats_ifthenelse_cntr; -x0[126] = 2.7895691267196265*middle_assertion_stats_inequality_cntr - 0.42245541220428762; -x0[127] = 1.0*middle_assertion_stats_log_cntr; -x0[128] = 1.0*middle_assertion_stats_max_cntr; -x0[129] = 1.0*middle_assertion_stats_min_cntr; -x0[130] = 1.0514943753608537*middle_assertion_stats_multiplication_cntr - 0.34379701814968183; -x0[131] = 2.0003360069220513*middle_assertion_stats_negation_cntr - 0.98183674198739934; -x0[132] = 1.0*middle_assertion_stats_notequalto_cntr; -x0[133] = 4.5109334446419505*middle_assertion_stats_pow_cntr - 0.21723031753828123; -x0[134] = 2.4930558858837699*middle_assertion_stats_realconstant_cntr - 0.50172906493743663; -x0[135] = 1.0*middle_assertion_stats_sqrt_cntr; -x0[136] = 26.394155405579589*middle_assertion_stats_trigonometry_cntr - 0.03794171696338617; -x0[137] = 1.0*middle_assertion_stats_true_cntr; -x0[138] = 1.0*middle_assertion_stats_uninterpretedfunction_cntr; -x0[139] = 1.5862324617799162*middle_assertion_stats_unique_variables - 2.171563983290596; -x0[140] = 1.3853974121446897*middle_assertion_stats_variable_cntr - 1.9345576743439254; -x0[141] = 117.95761981271234*middle_literal_stats_abs_cntr - 0.008478230418508757; -x0[142] = 0.17166362569978674*middle_literal_stats_addition_cntr - 0.060988521658452227; -x0[143] = 1.0*middle_literal_stats_conjunction_cntr; -x0[144] = 0.090286815587543409*middle_literal_stats_constant_cntr - 0.095497791862739087; -x0[145] = 1.0*middle_literal_stats_disjunction_cntr; -x0[146] = 1.7689855005756907*middle_literal_stats_division_cntr - 0.033439458538877788; -x0[147] = 2.0532837374454407*middle_literal_stats_equalto_cntr - 1.2590069405697588; -x0[148] = 1.0*middle_literal_stats_exp_cntr; -x0[149] = 1.0*middle_literal_stats_false_cntr; -x0[150] = 1.0*middle_literal_stats_forall_cntr; -x0[151] = 1.0*middle_literal_stats_ifthenelse_cntr; -x0[152] = 2.0532837374454407*middle_literal_stats_inequality_cntr - 0.79427679687568187; -x0[153] = 1.0*middle_literal_stats_log_cntr; -x0[154] = 1.0*middle_literal_stats_max_cntr; -x0[155] = 1.0*middle_literal_stats_min_cntr; -x0[156] = 0.19811233121892721*middle_literal_stats_multiplication_cntr - 0.082830405426615364; -x0[157] = 2.5529411624742262*middle_literal_stats_negation_cntr - 0.48313764686226096; -x0[158] = 1.0*middle_literal_stats_notequalto_cntr; -x0[159] = 0.16942371481996552*middle_literal_stats_pow_cntr - 0.032428329804180853; -x0[160] = 0.72913826386016745*middle_literal_stats_realconstant_cntr - 0.40845997473773771; -x0[161] = 1.0*middle_literal_stats_sqrt_cntr; -x0[162] = 3.2027278540994542*middle_literal_stats_trigonometry_cntr - 0.043967585720764445; -x0[163] = 1.0*middle_literal_stats_true_cntr; -x0[164] = 1.0*middle_literal_stats_uninterpretedfunction_cntr; -x0[165] = 1.6169472673232148*middle_literal_stats_unique_variables - 1.8369487894279259; -x0[166] = 0.15532919408550064*middle_literal_stats_variable_cntr - 0.22999617101670369; -x0[167] = 117.95761981271234*smallest_assertion_stats_abs_cntr - 0.008478230418508757; -x0[168] = 1.4456995849575351*smallest_assertion_stats_addition_cntr - 0.17342576060476719; -x0[169] = 1.0*smallest_assertion_stats_conjunction_cntr; -x0[170] = 1.0264539941560433*smallest_assertion_stats_constant_cntr - 0.72301079154238657; -x0[171] = 1.0*smallest_assertion_stats_disjunction_cntr; -x0[172] = 11.916838896706651*smallest_assertion_stats_division_cntr - 0.017130509446857831; -x0[173] = 2.0160297845385511*smallest_assertion_stats_equalto_cntr - 1.1348771129523418; -x0[174] = 1.0*smallest_assertion_stats_exp_cntr; -x0[175] = 1.0*smallest_assertion_stats_false_cntr; -x0[176] = 1.0*smallest_assertion_stats_forall_cntr; -x0[177] = 1.0*smallest_assertion_stats_ifthenelse_cntr; -x0[178] = 2.0160297845385511*smallest_assertion_stats_inequality_cntr - 0.88115267158620925; -x0[179] = 1.0*smallest_assertion_stats_log_cntr; -x0[180] = 1.0*smallest_assertion_stats_max_cntr; -x0[181] = 1.0*smallest_assertion_stats_min_cntr; -x0[182] = 1.7094086275698364*smallest_assertion_stats_multiplication_cntr - 0.17729293822922976; -x0[183] = 2.0747529068139507*smallest_assertion_stats_negation_cntr - 1.3133291777697451; -x0[184] = 1.0*smallest_assertion_stats_notequalto_cntr; -x0[185] = 1.8874366036972476*smallest_assertion_stats_pow_cntr - 0.04666701586083901; -x0[186] = 1.6935753858341813*smallest_assertion_stats_realconstant_cntr - 0.74179892196316399; -x0[187] = 1.0*smallest_assertion_stats_sqrt_cntr; -x0[188] = 17.208229650322913*smallest_assertion_stats_trigonometry_cntr - 0.01855268056888117; -x0[189] = 1.0*smallest_assertion_stats_true_cntr; -x0[190] = 1.0*smallest_assertion_stats_uninterpretedfunction_cntr; -x0[191] = 2.390572553702162*smallest_assertion_stats_unique_variables - 2.4223597974623075; -x0[192] = 2.0922980271737206*smallest_assertion_stats_variable_cntr - 2.1450829482933913; -x0[193] = 41.714812421160595*smallest_literal_stats_abs_cntr - 0.023986092098705149; -x0[194] = 0.1717450336334706*smallest_literal_stats_addition_cntr - 0.059227533341004238; -x0[195] = 1.0*smallest_literal_stats_conjunction_cntr; -x0[196] = 0.090339966682452699*smallest_literal_stats_constant_cntr - 0.097404574153918844; -x0[197] = 1.0*smallest_literal_stats_disjunction_cntr; -x0[198] = 1.7697667925338136*smallest_literal_stats_division_cntr - 0.033199822673134864; -x0[199] = 2.0051965684798647*smallest_literal_stats_equalto_cntr - 1.0747323230902286; -x0[200] = 1.0*smallest_literal_stats_exp_cntr; -x0[201] = 1.0*smallest_literal_stats_false_cntr; -x0[202] = 1.0*smallest_literal_stats_forall_cntr; -x0[203] = 1.0*smallest_literal_stats_ifthenelse_cntr; -x0[204] = 2.0051965684798647*smallest_literal_stats_inequality_cntr - 0.93046424538963612; -x0[205] = 1.0*smallest_literal_stats_log_cntr; -x0[206] = 1.0*smallest_literal_stats_max_cntr; -x0[207] = 1.0*smallest_literal_stats_min_cntr; -x0[208] = 0.1984602857866811*smallest_literal_stats_multiplication_cntr - 0.072348923273919827; -x0[209] = 2.0731409307148403*smallest_literal_stats_negation_cntr - 0.76366328397279937; -x0[210] = 1.0*smallest_literal_stats_notequalto_cntr; -x0[211] = 0.16945087581388943*smallest_literal_stats_pow_cntr - 0.029827154091009504; -x0[212] = 0.72943489750124979*smallest_literal_stats_realconstant_cntr - 0.4083115777862239; -x0[213] = 1.0*smallest_literal_stats_sqrt_cntr; -x0[214] = 3.2392414057685444*smallest_literal_stats_trigonometry_cntr - 0.039113962205787063; -x0[215] = 1.0*smallest_literal_stats_true_cntr; -x0[216] = 1.0*smallest_literal_stats_uninterpretedfunction_cntr; -x0[217] = 1.8363223514790834*smallest_literal_stats_unique_variables - 1.9094426406129448; -x0[218] = 0.15542016244619064*smallest_literal_stats_variable_cntr - 0.21487147449525459; -x0[219] = 0.00032842472077025258*theory_checksat_ms - 0.040918510018383925; -x1[0] = relu(-0.068987151721099635*x0[0] + 0.11554164845276675*x0[1] + 0.042264035809676068*x0[2] - 0.082545385391382217*x0[3] + 0.47604599652106533*x0[4] - 1.1098751443858104*x0[5] + 0.012141316538451642*x0[6] - 0.070635953891904302*x0[7] + 0.16873307665984202*x0[8] - 0.16331670968133108*x0[9] + 0.26350338866248713*x0[10] + 4.137463735290108e-315*x0[11] + 0.16336746821966627*x0[12] - 0.057326990714608984*x0[13] + 9.6447809651410175e-317*x0[14] - 3.6194970660118597e-315*x0[15] - 4.2445272864408861e-315*x0[16] - 3.6812689425384359e-315*x0[17] + 0.16996581321337711*x0[18] - 0.18512844073140786*x0[19] + 3.2661676003985589e-315*x0[20] - 1.194981014528379e-316*x0[21] + 0.096030731392715105*x0[22] - 0.014681760266069564*x0[23] - 2.6241663880765488e-316*x0[24] + 0.020396150536906014*x0[25] - 0.23606320247107435*x0[26] + 2.2054370082641609e-316*x0[27] + 0.27103253075289552*x0[28] + 6.0128092949251897e-316*x0[29] + 3.7260027923452007e-315*x0[30] + 0.13530830519993778*x0[31] + 0.16238930585268582*x0[32] + 5.4097241118039054e-316*x0[33] - 0.043209003672510238*x0[34] + 4.3830864306289664e-315*x0[35] - 0.030106365820035189*x0[36] - 4.8343676219569922e-316*x0[37] + 0.31363443019406168*x0[38] + 0.076147524611650905*x0[39] + 2.4269988696922137e-315*x0[40] + 3.2349822657648756e-316*x0[41] - 3.3476375036755912e-315*x0[42] - 6.1259799717615856e-316*x0[43] - 0.17850226649202344*x0[44] - 0.11128512852668694*x0[45] - 1.2780732465820651e-315*x0[46] - 1.1125381378936786e-315*x0[47] + 0.13702880328994632*x0[48] - 0.15825322607578995*x0[49] + 1.2276983380353739e-315*x0[50] + 0.1958735384914522*x0[51] - 0.11962967874457925*x0[52] - 4.3679077557387445e-315*x0[53] + 0.15833440120298811*x0[54] + 4.1077754096820108e-315*x0[55] - 1.4173582917796411e-315*x0[56] - 0.23621745012269893*x0[57] + 0.13598572811335924*x0[58] - 0.21600890203918824*x0[59] + 0.11567974644629454*x0[60] - 9.4311841336158297e-316*x0[61] + 0.10337047267289246*x0[62] - 1.0623399763911306e-315*x0[63] + 0.15666760022380757*x0[64] + 0.23768246607185087*x0[65] - 4.4063908055700809e-315*x0[66] + 1.0465307897456555e-316*x0[67] + 1.5442237173389748e-315*x0[68] + 1.8086856841666268e-315*x0[69] - 0.14097254853807686*x0[70] - 4.766321788598167e-316*x0[71] + 4.738666958137849e-316*x0[72] - 3.2708601025050347e-315*x0[73] + 0.11013721540294361*x0[74] + 0.18675641258819567*x0[75] + 3.6920315252884043e-315*x0[76] - 0.27068736829800027*x0[77] - 0.036128946827851331*x0[78] - 1.3798542280848828e-315*x0[79] - 0.049438306224489151*x0[80] - 1.1425426161085496e-316*x0[81] - 5.4401124098564046e-316*x0[82] + 0.64473610193934849*x0[83] - 0.019392119291802956*x0[84] + 0.42048700261231603*x0[85] + 0.069283766669278088*x0[86] - 0.12663149368950047*x0[87] + 0.16932681652887568*x0[88] + 0.0515859183147842*x0[89] + 0.087081127876916714*x0[90] + 0.21446598518947407*x0[91] + 0.06214564911070284*x0[92] - 1.615197596163283e-315*x0[93] + 0.026006173586733829*x0[94] + 0.46942333729579516*x0[95] + 4.0321178774669438e-315*x0[96] + 1.5877865376926231e-315*x0[97] + 8.6950889194297005e-316*x0[98] + 3.1573682533549032e-315*x0[99] - 0.3221770044009013*x0[100] - 2.1315171296287999e-315*x0[101] + 1.2114651689559201e-316*x0[102] - 3.9081726417293243e-315*x0[103] + 0.19415086138395268*x0[104] - 0.22634288441987377*x0[105] + 4.2051532386238396e-315*x0[106] + 0.32903122500970233*x0[107] - 0.11253413864222656*x0[108] + 4.1269168813637397e-315*x0[109] - 0.16564097227537167*x0[110] + 2.1583662378338799e-316*x0[111] + 2.3595168788703919e-315*x0[112] + 0.52475331147107773*x0[113] + 0.3258981296098169*x0[114] + 1.2495851200628148e-315*x0[115] + 0.4369774737670773*x0[116] + 2.7286753036363143e-316*x0[117] + 0.40365582445715703*x0[118] + 1.1051567378569328e-315*x0[119] + 4.2586108845897267e-315*x0[120] - 0.028392325058851493*x0[121] + 9.7352897895274025e-316*x0[122] + 9.6741194231026686e-316*x0[123] - 7.1049324130625109e-316*x0[124] + 1.5400007455783677e-315*x0[125] - 0.031245348104709837*x0[126] + 3.5100498556274688e-317*x0[127] + 4.289358244850341e-315*x0[128] + 4.3473430044477585e-316*x0[129] + 0.41157356305692971*x0[130] + 0.27610336456668466*x0[131] + 1.9633172235323476e-315*x0[132] + 0.012843150556949708*x0[133] - 0.23116750401753153*x0[134] + 5.4213035283454867e-316*x0[135] + 0.049761272983511344*x0[136] + 3.4881704845847154e-315*x0[137] + 3.5225504130998129e-315*x0[138] - 0.12606027997680164*x0[139] + 0.08585887508236123*x0[140] - 0.11598433043679698*x0[141] - 0.016225668470037851*x0[142] - 2.001587197672602e-315*x0[143] - 1.1161932568754958*x0[144] - 7.9361056695408942e-316*x0[145] - 0.11685165970855191*x0[146] + 0.29392391440965721*x0[147] + 7.6892982393679037e-316*x0[148] + 2.7275697279999589e-315*x0[149] + 2.0379832252840887e-315*x0[150] - 1.3995647991620868e-315*x0[151] - 0.33860358939092011*x0[152] + 6.2828998650978364e-316*x0[153] - 2.0327463418863992e-316*x0[154] + 1.3379979994037863e-315*x0[155] + 0.035443266990276667*x0[156] - 0.048312666759740434*x0[157] + 9.5652766625107128e-316*x0[158] - 0.19689829052635352*x0[159] + 0.029616782696256155*x0[160] + 4.5124173228115511e-315*x0[161] + 0.24717447544636675*x0[162] - 1.2654639502017277e-315*x0[163] + 3.5249275111416489e-315*x0[164] + 0.15827549804410543*x0[165] + 0.10686237236390256*x0[166] - 0.16854080470628283*x0[167] + 0.042222595871171206*x0[168] + 1.0827163552733268e-315*x0[169] + 0.23800517547828104*x0[170] - 1.0791512763860655e-316*x0[171] - 0.045033098103362271*x0[172] - 0.089116016475911108*x0[173] - 2.5373250772077772e-315*x0[174] - 3.4812872114134198e-315*x0[175] - 2.1720336252013509e-316*x0[176] + 4.7550379221259279e-316*x0[177] + 0.2977433028647376*x0[178] + 1.5386723413950815e-315*x0[179] - 3.7503931976857212e-315*x0[180] + 3.9209978250342684e-315*x0[181] - 0.019811460094703529*x0[182] + 0.14879756594080343*x0[183] + 6.0052516221473207e-316*x0[184] + 0.081101073016967298*x0[185] - 0.11373166707524276*x0[186] + 1.5121301023032899e-315*x0[187] - 0.081805316477419482*x0[188] + 4.0307231103861081e-316*x0[189] - 4.2871069210999668e-315*x0[190] + 0.068180144197317064*x0[191] - 0.12715299017359996*x0[192] + 0.22242628903295669*x0[193] + 0.085477871348458884*x0[194] - 3.1752222690140731e-315*x0[195] + 0.0027282081744045804*x0[196] + 1.9985552156172034e-315*x0[197] + 0.19710054621499934*x0[198] - 0.12941398279204377*x0[199] + 3.4531573121313432e-315*x0[200] - 1.621371104509076e-315*x0[201] + 3.7042373824843171e-315*x0[202] + 7.9530832473289369e-316*x0[203] + 0.062388840116023851*x0[204] - 3.8162855273513924e-315*x0[205] - 6.6778090555535386e-316*x0[206] + 1.236097582471743e-315*x0[207] + 0.22506284120091843*x0[208] + 0.12849128595681772*x0[209] + 2.4244628653167058e-315*x0[210] - 0.16051125832721633*x0[211] - 0.15916880628328395*x0[212] + 1.5523593085840971e-315*x0[213] + 0.37356789384284522*x0[214] + 2.1359221398766171e-315*x0[215] - 1.2911914552809012e-315*x0[216] + 0.11538269556462218*x0[217] + 0.024322405024433155*x0[218] - 0.51934445836637055*x0[219] + 0.065331610888346409); -x1[1] = relu(0.36548106268703812*x0[0] + 0.10043923039264817*x0[1] + 0.11372761339710191*x0[2] - 0.10902695157359135*x0[3] + 0.039492437455893419*x0[4] + 0.13311261929796794*x0[5] - 0.16794813689797758*x0[6] - 0.29484466185566094*x0[7] - 0.2279349785452707*x0[8] + 0.03649574346044749*x0[9] - 0.046185881571367736*x0[10] - 3.7359790103319353e-315*x0[11] + 0.067191796057522485*x0[12] - 0.22665399842064352*x0[13] - 3.1973052692127599e-315*x0[14] - 2.1154938297543866e-315*x0[15] - 1.3906422898002072e-315*x0[16] - 9.834994262527314e-317*x0[17] - 0.091898939274539265*x0[18] - 0.19446164871570823*x0[19] - 3.0224282388357392e-315*x0[20] + 1.1646676662343539e-316*x0[21] - 0.13848524184531869*x0[22] - 0.028012937425625307*x0[23] - 3.1766618626709559e-315*x0[24] - 0.24382259236688439*x0[25] - 0.31126269617490543*x0[26] - 3.0013671047310329e-315*x0[27] + 0.33703119586022612*x0[28] - 1.479111270295264e-315*x0[29] - 2.3234112383422484e-316*x0[30] + 0.21509915755719691*x0[31] + 0.04138984849918198*x0[32] - 4.1371351964575929e-315*x0[33] + 0.38030207207019318*x0[34] - 1.6734343391213924e-315*x0[35] + 0.028446886895532229*x0[36] - 8.8257142438417635e-316*x0[37] + 0.1566930104510405*x0[38] + 0.59082679533470239*x0[39] - 1.9058716180116108e-316*x0[40] - 9.0032153309736939e-316*x0[41] - 1.2805411538896067e-315*x0[42] + 2.3147317993968098e-315*x0[43] - 0.55014602713367744*x0[44] - 0.14779051416223424*x0[45] - 3.357890927074238e-316*x0[46] + 1.3861036545578158e-315*x0[47] + 0.091613146206414642*x0[48] + 0.2003748034695832*x0[49] - 2.2260968079040939e-316*x0[50] - 0.41814470166685047*x0[51] - 0.23713700531236087*x0[52] + 2.259913550989497e-315*x0[53] - 0.206479900539359*x0[54] - 9.9146012319988245e-316*x0[55] + 4.092387280601891e-315*x0[56] + 0.068708461570517507*x0[57] + 0.013561631936672158*x0[58] - 0.072595277563544211*x0[59] - 0.34565552957792384*x0[60] + 4.0679494548406827e-315*x0[61] - 0.17819904216398916*x0[62] - 3.729558894059677e-315*x0[63] + 0.19834166097138436*x0[64] + 0.21528954546253617*x0[65] - 4.444249756618247e-315*x0[66] - 8.7504071276860094e-316*x0[67] - 4.0799647113917429e-315*x0[68] - 1.2283358012942641e-315*x0[69] - 0.3470024405709512*x0[70] + 2.9852109160198577e-315*x0[71] + 3.8135876818922762e-316*x0[72] - 1.065606674212899e-315*x0[73] - 0.053409106333301544*x0[74] + 0.16555310817081342*x0[75] - 6.1063799923385467e-316*x0[76] - 0.22411196307041836*x0[77] - 0.24315334255468815*x0[78] + 2.1031483990135237e-315*x0[79] - 0.040007247322914642*x0[80] - 3.5879797785520486e-315*x0[81] + 6.3430485531735352e-316*x0[82] - 0.087292817249553484*x0[83] + 0.079061536190714529*x0[84] - 0.50461906181206861*x0[85] - 0.004474011393827069*x0[86] - 0.17516021077108407*x0[87] - 0.12678060556747633*x0[88] - 0.22655047806958725*x0[89] - 0.25598917943996791*x0[90] - 0.3935891074154152*x0[91] - 0.066000298044610078*x0[92] - 2.3199672549447828e-316*x0[93] + 0.013518080571751821*x0[94] - 0.55648968841772528*x0[95] - 3.3972171196928283e-316*x0[96] + 3.5599175316788571e-316*x0[97] - 8.4056923388932903e-316*x0[98] - 6.5469049793040919e-316*x0[99] + 0.14273099432396447*x0[100] - 4.0461808681376963e-315*x0[101] - 5.3595983358591296e-316*x0[102] - 1.0358587050000358e-315*x0[103] - 0.52192100938332164*x0[104] + 0.21852905329759689*x0[105] + 3.4016278413395114e-316*x0[106] - 0.62277209500568143*x0[107] - 0.16704758454400409*x0[108] + 1.1431360383557695e-316*x0[109] + 0.13459019061375765*x0[110] - 5.6774864964336544e-316*x0[111] - 1.7762897009556871e-315*x0[112] - 0.38742658320129442*x0[113] - 0.37278676318778525*x0[114] + 1.3634040604331191e-315*x0[115] - 0.88161355349528625*x0[116] - 3.3824469679225267e-315*x0[117] + 0.055998092321175537*x0[118] - 4.0750344648964883e-315*x0[119] - 3.5486487836153807e-316*x0[120] + 0.03203576329269054*x0[121] + 2.4836971021104864e-316*x0[122] - 3.7765802332220916e-315*x0[123] - 4.3295541708692444e-316*x0[124] - 2.8544910817904017e-315*x0[125] - 0.043230491889202777*x0[126] - 1.7713481156538604e-316*x0[127] - 2.8462000970183493e-315*x0[128] - 1.4877908673417092e-315*x0[129] + 0.26980771940774678*x0[130] - 0.14098095658199894*x0[131] - 9.5813458512023119e-316*x0[132] + 0.11320682689940034*x0[133] - 0.375189750919734*x0[134] + 2.3451654427942843e-315*x0[135] - 0.28625386615667325*x0[136] + 1.4901665968217062e-315*x0[137] + 7.8890110357399191e-316*x0[138] + 0.083882858024735357*x0[139] + 0.2396443825699188*x0[140] - 0.26414838026816639*x0[141] - 0.20224505780353061*x0[142] + 4.8620925109258905e-316*x0[143] - 0.34868541515203183*x0[144] - 1.1107253270479272e-315*x0[145] - 0.15499857984136145*x0[146] - 0.042924624090722951*x0[147] + 2.4977846181998985e-315*x0[148] + 1.7375889954447318e-315*x0[149] + 3.9386007466509089e-315*x0[150] + 2.4415590188597505e-315*x0[151] - 0.025994887525081101*x0[152] + 2.6852633956341882e-315*x0[153] + 3.8978268527581875e-315*x0[154] - 2.6411640002265304e-315*x0[155] + 0.049563497368312878*x0[156] - 0.23570376697210341*x0[157] + 3.2169083563087112e-317*x0[158] + 0.078906175810176338*x0[159] - 0.14330725336833172*x0[160] - 1.4958919135168744e-315*x0[161] - 0.29536324915647555*x0[162] + 1.308528460885637e-315*x0[163] - 3.034739999002838e-315*x0[164] + 0.22092396413219087*x0[165] - 0.078449334930107278*x0[166] - 0.13658351038020106*x0[167] - 0.21651836059143725*x0[168] + 4.3679225381828681e-315*x0[169] + 0.14432812381438595*x0[170] - 1.0538141375143276e-315*x0[171] - 0.19256348568677681*x0[172] - 0.16396710637105699*x0[173] - 2.3549321818878386e-315*x0[174] - 3.2801697468850261e-315*x0[175] + 9.1663695916619925e-316*x0[176] - 3.2978541942738868e-316*x0[177] + 0.25810564906734657*x0[178] + 1.0924352885749895e-315*x0[179] + 2.3688530545755649e-315*x0[180] - 5.0076492896603093e-316*x0[181] - 0.067761734007159541*x0[182] - 0.022124100031660293*x0[183] - 4.8837923681568838e-316*x0[184] - 0.14960171980744152*x0[185] - 0.22548851809699808*x0[186] + 4.4853849854210544e-315*x0[187] - 0.22950338273945475*x0[188] + 2.1047289891244167e-316*x0[189] + 4.008593460509141e-315*x0[190] - 0.17830743375114533*x0[191] - 0.021307545215911463*x0[192] - 0.20412857554357877*x0[193] - 0.072747082717303277*x0[194] - 1.1583690950516291e-315*x0[195] + 0.33770661755256498*x0[196] + 3.3989691901080799e-315*x0[197] - 0.20341865459649677*x0[198] - 0.3776218289283701*x0[199] + 6.7289018661869194e-317*x0[200] - 3.9937100343082174e-315*x0[201] + 1.699490383033081e-315*x0[202] - 8.8798014381348943e-316*x0[203] + 0.34505179889299287*x0[204] + 1.3632815074496681e-315*x0[205] - 1.2665359639587611e-315*x0[206] - 2.8994800127494579e-315*x0[207] - 0.022392931874527434*x0[208] + 0.24201861277042419*x0[209] - 3.3455319144687709e-315*x0[210] + 0.12031738839393706*x0[211] - 0.3220041904631617*x0[212] + 1.0737146620103882e-315*x0[213] - 0.20892426411462492*x0[214] - 9.1796227543919902e-316*x0[215] + 1.0435598050348925e-315*x0[216] - 0.74262290795371155*x0[217] - 0.20921812114562088*x0[218] - 0.688297814981082*x0[219] + 0.31495767376215922); -x1[2] = relu(0.12974666418603656*x0[0] - 0.30537922411437174*x0[1] - 0.10554178861101569*x0[2] - 0.093229905782649614*x0[3] - 1.2627542502560476*x0[4] - 2.8761481666402271*x0[5] + 0.28862250586041571*x0[6] - 0.32968335907188689*x0[7] + 0.17231214846602189*x0[8] + 0.20356302158615994*x0[9] + 0.25671502615591174*x0[10] - 4.4504522764987639e-315*x0[11] - 0.25980656890923326*x0[12] + 0.12021114350411655*x0[13] - 3.4636124822958127e-315*x0[14] + 1.7851108774536046e-315*x0[15] + 4.3741849388196609e-315*x0[16] + 1.2194750501381147e-315*x0[17] - 0.22808722828315869*x0[18] + 0.025977818706774018*x0[19] - 3.0586020801856346e-315*x0[20] - 5.9367204681045856e-317*x0[21] + 0.33282389620520131*x0[22] + 0.27191901465232898*x0[23] - 1.7338703214294914e-315*x0[24] - 0.31437166736238537*x0[25] + 0.085911462193404342*x0[26] - 2.3655732244889301e-315*x0[27] - 0.051110051946586535*x0[28] - 8.4703463621868509e-316*x0[29] - 4.0728105469674889e-315*x0[30] - 0.16365764447490302*x0[31] + 0.29667729202004578*x0[32] + 3.7857149931854246e-315*x0[33] - 0.17266905815002792*x0[34] - 9.373188237778755e-316*x0[35] + 0.01914531278889792*x0[36] + 1.5382989858678322e-315*x0[37] + 0.068833526215544144*x0[38] + 0.3498541146353118*x0[39] + 2.0565565511170389e-316*x0[40] - 4.4762403490854611e-315*x0[41] - 2.7960274144811574e-315*x0[42] - 2.3118489658785778e-315*x0[43] - 0.37996502221194778*x0[44] - 0.12430056687693675*x0[45] + 5.0410845893638406e-316*x0[46] - 1.7631042795663907e-315*x0[47] + 0.10725022545286172*x0[48] - 0.29690019497500109*x0[49] + 4.090352634281157e-315*x0[50] - 0.25305838507352335*x0[51] - 0.24656182547798255*x0[52] + 1.2071072036388999e-315*x0[53] - 0.32248900036029138*x0[54] + 9.779865429633056e-317*x0[55] - 2.8326887257005221e-315*x0[56] - 0.03603310017105088*x0[57] - 0.0023155656416912595*x0[58] - 0.16848734126075851*x0[59] - 0.25009700094280907*x0[60] + 1.1020627555036377e-315*x0[61] - 0.46418770264284182*x0[62] - 2.4496279211239972e-315*x0[63] - 0.38450219279104375*x0[64] + 0.47113140218856103*x0[65] - 1.2757586626663974e-315*x0[66] - 2.1709366463072331e-315*x0[67] - 3.8160887706485925e-315*x0[68] + 1.6888165739983573e-316*x0[69] - 0.43677616711778833*x0[70] - 1.7141429965862369e-315*x0[71] - 8.2072269100573304e-316*x0[72] - 1.2167931185334511e-315*x0[73] - 0.16030378289623223*x0[74] - 0.45731941201834808*x0[75] + 3.5514364008023462e-316*x0[76] - 0.10806081391489798*x0[77] + 0.80879647653360165*x0[78] - 1.2275193084079468e-315*x0[79] - 0.29014636346191808*x0[80] + 3.8683545919383297e-315*x0[81] + 3.7389538487547359e-315*x0[82] - 0.21875317143948755*x0[83] - 0.28059810809589525*x0[84] - 0.54128709561644439*x0[85] - 0.15416412440858715*x0[86] - 0.10753239496175063*x0[87] - 0.27781805629148842*x0[88] - 0.24102081324789762*x0[89] - 0.33258640932140732*x0[90] - 0.3355512273027943*x0[91] - 0.33872585364621755*x0[92] - 3.3523537110517545e-315*x0[93] - 0.356009775928392*x0[94] - 0.26479121770408459*x0[95] - 3.3239067056162076e-315*x0[96] + 6.2287572366392422e-317*x0[97] - 1.9860922515998513e-315*x0[98] + 4.1103009793910785e-316*x0[99] - 0.28588739249727124*x0[100] - 8.0866515725735825e-316*x0[101] - 3.6781052030566044e-315*x0[102] + 2.5073433605972102e-315*x0[103] - 0.21356245929500633*x0[104] + 0.032695010504490168*x0[105] - 1.1919412509390585e-315*x0[106] - 0.22093929303911466*x0[107] + 0.29489802388469044*x0[108] + 3.4348119877126358e-315*x0[109] - 0.34612118997558455*x0[110] + 6.069552833163186e-316*x0[111] + 1.0915665334246552e-315*x0[112] - 0.0032151282484916273*x0[113] - 0.18604707239205276*x0[114] - 1.4585578775734758e-315*x0[115] + 0.31428750982487624*x0[116] - 9.5637626971521615e-316*x0[117] - 0.025399265795624123*x0[118] + 9.6066063901363185e-316*x0[119] - 6.61072650198441e-316*x0[120] - 0.020949738525819189*x0[121] - 4.0309444913206967e-315*x0[122] - 1.4834561576946388e-315*x0[123] - 4.3506648301142898e-315*x0[124] + 6.0486953084517874e-316*x0[125] - 0.016202071466653829*x0[126] - 4.1225052753395505e-315*x0[127] - 3.4878171337754662e-315*x0[128] - 1.4630640675249049e-315*x0[129] + 0.32109194354401166*x0[130] + 0.061701822726256086*x0[131] + 2.028563784695622e-315*x0[132] + 0.068077758747455044*x0[133] + 0.50188942151013205*x0[134] + 4.0726512009153922e-315*x0[135] + 0.12260244327259055*x0[136] - 3.5474196125170617e-315*x0[137] + 7.4900284716605142e-316*x0[138] - 0.026540946740957236*x0[139] + 0.062466186966101095*x0[140] - 0.12054904798610294*x0[141] - 0.24679433645566526*x0[142] + 1.9639496868469019e-315*x0[143] + 0.17149688708000566*x0[144] - 9.7374733126491979e-316*x0[145] - 0.16622159384746388*x0[146] - 0.012828716930871028*x0[147] - 1.6241808410150058e-315*x0[148] - 1.8796890537693352e-316*x0[149] - 1.110881753172057e-316*x0[150] - 7.3243697922134463e-316*x0[151] + 0.14733011115990149*x0[152] + 1.7572615629924577e-317*x0[153] - 3.1418629566068721e-315*x0[154] - 2.2541537089869974e-315*x0[155] - 0.10726609782367032*x0[156] + 0.27318105405295545*x0[157] + 6.6563864185564267e-316*x0[158] - 0.24065839662921507*x0[159] - 0.24408484690853133*x0[160] + 1.2480550284015832e-316*x0[161] - 0.16141434425690054*x0[162] - 1.7354897253375217e-315*x0[163] - 3.6318273981065857e-315*x0[164] - 0.013899596317506788*x0[165] - 0.17603263217297518*x0[166] - 0.28005343488926765*x0[167] + 0.33207308453132317*x0[168] + 1.3385554981378971e-315*x0[169] + 0.19721126196447789*x0[170] - 2.9997139215547964e-315*x0[171] - 0.23216808680726522*x0[172] + 0.018241773999925142*x0[173] - 1.416954027505588e-315*x0[174] + 3.5548116152025672e-315*x0[175] - 3.0147533786273331e-315*x0[176] - 4.2790816201289656e-315*x0[177] - 0.089946746727668656*x0[178] + 3.8178907614566999e-315*x0[179] - 6.3603166415613326e-316*x0[180] - 3.4391673246004201e-315*x0[181] + 0.29175113631408162*x0[182] - 0.012573416067162066*x0[183] + 6.8287154288814327e-316*x0[184] - 0.19027619698542975*x0[185] - 0.15614459016677595*x0[186] - 1.6302166779685852e-315*x0[187] - 0.17094637136663515*x0[188] - 1.2708845864944185e-315*x0[189] - 3.7313139436907731e-316*x0[190] - 0.25783033875386069*x0[191] - 0.29985741178482467*x0[192] - 0.10781083749249318*x0[193] - 0.29043520753278751*x0[194] - 4.4670102393931372e-315*x0[195] + 0.17754310836985715*x0[196] - 1.187355160691384e-315*x0[197] - 0.14254923640834669*x0[198] + 0.10614656597632453*x0[199] + 3.7602730185242956e-315*x0[200] + 2.9439053037384255e-315*x0[201] - 4.0243015415608511e-316*x0[202] - 2.7604792183399037e-315*x0[203] + 0.10472560659253061*x0[204] - 3.7503109653996273e-316*x0[205] + 3.0142320603204673e-315*x0[206] + 4.0457042677124356e-316*x0[207] - 0.26492322524543993*x0[208] - 0.046839947658766194*x0[209] + 4.2637447997661664e-315*x0[210] - 0.29773189644440901*x0[211] - 0.098758467620957621*x0[212] + 4.4022057237038534e-315*x0[213] - 0.33651676574224038*x0[214] - 4.1968792595913171e-315*x0[215] - 2.4005724692317461e-315*x0[216] - 0.03995719902042804*x0[217] - 0.32334995233413216*x0[218] + 0.52696685749471195*x0[219] + 0.081428598376102876); -x1[3] = relu(0.30552176448799473*x0[0] + 0.18517317183165111*x0[1] - 0.081709701477156185*x0[2] + 0.047233622702488522*x0[3] + 0.096348891497154573*x0[4] + 0.46337947070106161*x0[5] + 0.37438361213272697*x0[6] - 0.065202792719418576*x0[7] + 0.065085391214392413*x0[8] + 0.35942748261478846*x0[9] - 0.14474283198332219*x0[10] - 4.1072286914602922e-315*x0[11] - 0.17446752717277222*x0[12] + 0.27303931640425044*x0[13] + 1.1046039031025188e-315*x0[14] - 4.5458549545049308e-315*x0[15] + 3.0098326280737916e-315*x0[16] - 2.7830259238504948e-315*x0[17] + 0.18361961510700617*x0[18] - 0.010978724954091459*x0[19] - 4.4939436500193671e-315*x0[20] + 8.8396716971499078e-316*x0[21] - 0.39899130272347921*x0[22] + 0.20539064490895417*x0[23] + 3.5348216203587012e-315*x0[24] + 0.063681188430122437*x0[25] + 0.10132352316511242*x0[26] - 2.326954528934528e-316*x0[27] + 0.042663554669163779*x0[28] + 4.6285632926111418e-316*x0[29] + 2.5373992166985922e-315*x0[30] + 0.019057102672238268*x0[31] - 0.032563176346525773*x0[32] + 9.4780566355024346e-316*x0[33] - 0.24070633059049032*x0[34] + 1.9664434041437822e-315*x0[35] + 0.05047044189830293*x0[36] + 4.5012343988914139e-315*x0[37] - 0.11137046611983535*x0[38] + 0.15969071198053142*x0[39] - 1.7514868743173006e-316*x0[40] + 1.4534978350924023e-315*x0[41] + 3.7720467412030734e-316*x0[42] - 1.3592953413531128e-316*x0[43] - 0.050020564987897212*x0[44] + 0.083073960257907281*x0[45] + 5.3949474482483916e-316*x0[46] - 2.7088664332582137e-316*x0[47] + 0.11840416593891791*x0[48] + 0.14764492482759922*x0[49] - 7.3733936041417378e-316*x0[50] - 0.054063768786389979*x0[51] + 0.22655233428422489*x0[52] + 4.3612726220974161e-315*x0[53] + 0.055958206826821177*x0[54] + 2.0005259743092738e-315*x0[55] - 6.7454700117742535e-316*x0[56] - 0.08435946810228187*x0[57] + 0.18378472874771609*x0[58] + 0.15879754061552781*x0[59] - 0.089661631177470016*x0[60] + 1.3645574813866177e-315*x0[61] + 1.2341645619150532*x0[62] - 5.4657643970016113e-316*x0[63] - 0.094802215141132434*x0[64] - 0.0049400144007782738*x0[65] + 1.3502225273404554e-315*x0[66] - 1.0462315737092212e-315*x0[67] - 6.3504110206147323e-317*x0[68] - 6.2562028797051109e-316*x0[69] - 0.041551354996453356*x0[70] + 1.4113916338977925e-315*x0[71] + 4.0375933006991019e-315*x0[72] - 1.1816203134699075e-315*x0[73] + 0.040820155808511394*x0[74] - 0.011164962198379039*x0[75] + 3.2157816297220573e-315*x0[76] + 0.10958051058793751*x0[77] + 0.084793781240607463*x0[78] - 1.9644303534324279e-315*x0[79] - 0.027768960962353251*x0[80] - 3.9972914223024479e-315*x0[81] + 3.6505630887327287e-315*x0[82] - 1.8947531124803547*x0[83] - 0.55737924741212308*x0[84] - 0.13347503084545892*x0[85] + 0.031259258019895361*x0[86] + 0.032025138009694115*x0[87] - 0.11382083014959343*x0[88] + 0.12855196893434143*x0[89] - 0.020824254826141055*x0[90] - 0.11182752448799671*x0[91] - 0.13745606696236123*x0[92] - 1.9856479383645463e-315*x0[93] + 0.13928153979382682*x0[94] - 0.23447101356988911*x0[95] - 5.101494094693979e-316*x0[96] + 4.2078409260932772e-315*x0[97] - 1.0554171878494806e-315*x0[98] + 6.5615339172314992e-316*x0[99] + 0.064714709002614959*x0[100] + 3.713432507388259e-315*x0[101] - 7.6046209212059475e-316*x0[102] + 2.8027790636237445e-315*x0[103] - 0.20304240848063088*x0[104] - 0.18700773689401523*x0[105] + 1.7781201054790868e-315*x0[106] - 0.43520363092997966*x0[107] - 0.04642389817576692*x0[108] + 7.6928135658446287e-316*x0[109] - 0.094120205864645451*x0[110] - 2.4514245908450989e-315*x0[111] + 3.334621951936648e-315*x0[112] - 0.38579360652605188*x0[113] - 0.24243533086032254*x0[114] + 2.8705802504967186e-315*x0[115] + 0.06457611639469471*x0[116] + 6.480962729245565e-316*x0[117] + 0.055557656474422165*x0[118] - 3.2377619284949431e-315*x0[119] + 1.3812494052402045e-315*x0[120] + 0.17143134952620767*x0[121] + 5.524312361791349e-316*x0[122] + 1.1806420387878596e-315*x0[123] + 1.3999378533092921e-315*x0[124] + 1.5459968398913957e-315*x0[125] + 0.12838932295480834*x0[126] + 3.7286281386114461e-315*x0[127] - 1.1363692806857326e-315*x0[128] + 4.1065530171643527e-315*x0[129] + 0.0087151682768617407*x0[130] - 0.10969391276032552*x0[131] - 4.1074001421207121e-315*x0[132] - 0.013896146060786979*x0[133] + 0.017558500986448584*x0[134] + 1.1853380141758256e-315*x0[135] + 0.15495996298577536*x0[136] + 2.6733884537265469e-315*x0[137] + 2.0967761774649733e-315*x0[138] + 0.070128087740295053*x0[139] + 0.13555023978469949*x0[140] + 0.0014239841419500948*x0[141] + 0.20313047672368476*x0[142] - 3.0367491614175596e-315*x0[143] + 0.57118167714209844*x0[144] - 3.3784875406587243e-315*x0[145] + 0.19951587068147847*x0[146] - 0.10434501865160488*x0[147] - 7.4095749701114193e-316*x0[148] + 8.9416837037487209e-316*x0[149] - 2.1655977284723645e-316*x0[150] - 2.9750305007016969e-315*x0[151] + 0.044187630905968757*x0[152] - 2.783150517325063e-315*x0[153] + 2.9114812823020843e-315*x0[154] - 8.9711087220115234e-316*x0[155] + 0.15685560342292165*x0[156] + 0.079089044732057245*x0[157] + 2.1538893805598445e-315*x0[158] + 0.11906038233020137*x0[159] - 0.091651444802566914*x0[160] + 6.3094315361254635e-316*x0[161] + 0.093912268526120252*x0[162] + 3.1290691020045307e-315*x0[163] + 4.4417149132970068e-315*x0[164] + 0.26888719965906627*x0[165] + 0.14078901397361382*x0[166] - 0.14586115972566185*x0[167] - 0.04791248262903839*x0[168] + 6.5715151302219132e-316*x0[169] - 0.078851612593291445*x0[170] - 4.8667980909500117e-317*x0[171] + 0.046191178126052244*x0[172] + 0.070270588514731752*x0[173] + 6.4208723409160754e-316*x0[174] - 7.4617367905827069e-316*x0[175] - 3.8015832157349212e-315*x0[176] + 2.5745245197879357e-315*x0[177] - 0.043453602962628499*x0[178] + 2.8176762890781564e-315*x0[179] - 3.7882695349039645e-316*x0[180] + 1.0998772758818847e-315*x0[181] + 0.020728707539182618*x0[182] + 0.011887117037732032*x0[183] + 1.6256864714861118e-315*x0[184] - 0.061522126351435391*x0[185] + 0.016189288465616663*x0[186] - 4.4693029213787247e-315*x0[187] + 0.02741990526158114*x0[188] - 3.5031275166855564e-315*x0[189] + 8.165887399931937e-316*x0[190] + 0.13376105932333801*x0[191] + 0.0077975553109673728*x0[192] - 0.0012653582390094169*x0[193] - 0.11414584533883582*x0[194] - 4.3517278914018206e-315*x0[195] - 0.25977500527406*x0[196] + 1.0024994568213688e-315*x0[197] + 0.01431189070188311*x0[198] - 0.071470385852233878*x0[199] - 3.8317202072966633e-315*x0[200] - 3.2869852688343075e-315*x0[201] + 1.8887983644112509e-315*x0[202] - 3.705619175401293e-315*x0[203] + 0.010830751590326267*x0[204] + 1.4989402442044938e-315*x0[205] - 3.7355935699589887e-315*x0[206] - 1.3922581463169004e-315*x0[207] + 0.075713222414364109*x0[208] - 0.23193115923725827*x0[209] - 6.4107221080682191e-316*x0[210] + 0.094734645059620023*x0[211] + 0.079705999385160597*x0[212] - 1.3901727792169643e-315*x0[213] + 0.18165002969943983*x0[214] + 4.4479483073397323e-316*x0[215] + 1.3559124491727555e-315*x0[216] + 0.0072678091832688438*x0[217] - 0.099986995734145392*x0[218] + 0.027386461334829255*x0[219] - 0.080243531666927381); -x1[4] = relu(0.29069400172231313*x0[0] + 0.16760523031018423*x0[1] + 0.020929512561935086*x0[2] + 0.03236475923353458*x0[3] + 0.42135771384245102*x0[4] - 0.072427199557434652*x0[5] + 0.42910503060156979*x0[6] - 0.0081560934888373609*x0[7] - 0.25531675480131288*x0[8] + 0.37456942407176813*x0[9] + 0.046263189836989974*x0[10] + 4.3405005410988093e-316*x0[11] - 0.19251435587885468*x0[12] - 0.014008349040404502*x0[13] + 1.5134598602264458e-315*x0[14] + 3.7621511991956482e-315*x0[15] - 2.7766333764412745e-315*x0[16] - 3.2962371717622694e-315*x0[17] + 0.13229714829708705*x0[18] + 0.047433835880700652*x0[19] + 1.7587620255369082e-315*x0[20] - 1.5738506948158278e-315*x0[21] - 0.37438543065305196*x0[22] + 0.38590054936509893*x0[23] + 2.0599488601886059e-315*x0[24] - 0.149573040069201*x0[25] + 0.046660845204104746*x0[26] - 3.6384242762449566e-315*x0[27] + 0.21560565418651767*x0[28] - 2.1261787503254852e-316*x0[29] + 7.8332203525064922e-316*x0[30] + 0.14008122810411006*x0[31] + 0.1311992857204671*x0[32] - 4.4633242181764305e-315*x0[33] + 0.18977734074024533*x0[34] + 4.16921144014517e-316*x0[35] + 0.075398773582794204*x0[36] - 7.1458073038545551e-317*x0[37] + 0.078154796418435896*x0[38] + 0.054360166921264975*x0[39] + 2.3533977622115495e-316*x0[40] + 1.3568651065510666e-315*x0[41] - 6.2745403237767671e-317*x0[42] - 3.577251973082891e-316*x0[43] - 0.23723728706144825*x0[44] + 0.13162900657254314*x0[45] + 1.3694276939652462e-315*x0[46] - 9.4459057582583968e-316*x0[47] + 0.059606286346456198*x0[48] + 0.12442730135383319*x0[49] + 9.4115114771362876e-316*x0[50] - 0.12802961488244277*x0[51] + 0.20876362504895743*x0[52] + 1.0035538176128764e-315*x0[53] - 0.078373113914876405*x0[54] - 1.5176751887915116e-315*x0[55] - 8.2703033817437198e-316*x0[56] - 0.098988147857606665*x0[57] - 0.068379396357125935*x0[58] - 0.10381362819727652*x0[59] + 0.015176873026743899*x0[60] - 5.7924985559321007e-316*x0[61] + 0.99202343312919727*x0[62] - 1.2411030751648592e-315*x0[63] - 0.0065978473910931635*x0[64] - 0.20766923669838144*x0[65] + 3.1708337210335753e-315*x0[66] + 7.0222553196677429e-317*x0[67] - 1.5848530130391278e-315*x0[68] + 2.9042677558904825e-315*x0[69] + 0.26893834725147175*x0[70] + 5.9583420159307131e-316*x0[71] + 3.7315638124505008e-315*x0[72] - 7.5884916541318141e-316*x0[73] + 0.15125459878355413*x0[74] + 0.15760147433434496*x0[75] - 3.3880443512593607e-315*x0[76] - 0.10004369164930388*x0[77] - 0.1550031726860723*x0[78] + 1.9748172733685809e-315*x0[79] - 0.033518701518102177*x0[80] - 1.960936864657249e-316*x0[81] - 4.4655025042023799e-315*x0[82] - 1.7671486848735229*x0[83] - 0.68482534657288574*x0[84] - 0.090323811232421738*x0[85] + 0.028451753328348508*x0[86] + 0.012805021461149684*x0[87] - 0.3041490617344228*x0[88] + 0.13189207703371161*x0[89] - 0.019767775256588266*x0[90] - 0.17135204038276811*x0[91] - 0.08605469202017979*x0[92] - 3.2298243340573916e-315*x0[93] + 0.0097057972387141755*x0[94] - 0.49593235444809408*x0[95] - 6.001651316379511e-316*x0[96] + 2.7239331775763702e-315*x0[97] + 3.6303216342377553e-315*x0[98] + 5.7192169112980374e-316*x0[99] + 0.064983271309508525*x0[100] - 1.5828267954783118e-316*x0[101] + 2.5273010731917769e-315*x0[102] - 3.4213279234030542e-315*x0[103] - 0.0071998530002897274*x0[104] - 0.35895989443243603*x0[105] + 1.9976576020924955e-316*x0[106] - 0.231295999518454*x0[107] + 0.15602249556905129*x0[108] + 6.0784705698509268e-316*x0[109] + 0.18772016610246597*x0[110] + 2.4675237396774618e-315*x0[111] - 5.6736836237510497e-316*x0[112] - 0.43115698204550812*x0[113] - 0.28944888590534107*x0[114] - 8.1204229357294151e-316*x0[115] + 0.14670726586780791*x0[116] - 2.0794588109696596e-315*x0[117] + 0.1945711455940165*x0[118] - 4.5423527751150416e-315*x0[119] + 2.2099861572234959e-315*x0[120] + 0.088671774119677027*x0[121] - 1.0563074941432865e-315*x0[122] - 3.6042993992382117e-316*x0[123] - 4.0656706165744916e-315*x0[124] - 2.9154620581424435e-315*x0[125] + 0.13073816524731313*x0[126] + 3.3804180626445973e-315*x0[127] + 2.4065117459955023e-315*x0[128] - 2.2287503356747781e-316*x0[129] + 0.029612306127695161*x0[130] + 0.1323268544044898*x0[131] + 1.9321391615449711e-316*x0[132] + 0.0048520978511106842*x0[133] - 0.04275178437267102*x0[134] + 3.1511805455624486e-315*x0[135] + 0.26545524227159834*x0[136] - 4.1940955751668925e-315*x0[137] + 3.8504886445938127e-315*x0[138] - 0.25941328135839392*x0[139] - 0.059293247549308224*x0[140] - 0.10160476599151444*x0[141] + 0.20628346224426189*x0[142] + 2.3895004729304131e-316*x0[143] + 0.44648842260616167*x0[144] - 3.8671634836573662e-315*x0[145] + 0.056031654432887781*x0[146] + 0.066655385868827882*x0[147] - 3.7598768470455214e-315*x0[148] - 2.9922050179968285e-315*x0[149] + 1.8315454790769875e-315*x0[150] - 3.5811830310973091e-315*x0[151] + 0.22971347835549064*x0[152] - 7.9845118994118841e-316*x0[153] - 4.3841913788019516e-315*x0[154] + 2.9663883192466112e-316*x0[155] + 0.014092990295056864*x0[156] + 0.10001567461616452*x0[157] + 1.1519066472348352e-315*x0[158] + 0.12897295687930499*x0[159] - 0.054184268860286905*x0[160] - 9.0136410548256713e-316*x0[161] - 0.12528924749102494*x0[162] - 8.7516002468141514e-316*x0[163] + 2.9695675378051269e-315*x0[164] + 0.27304335818561815*x0[165] - 0.059375410832698657*x0[166] - 0.047786178545295738*x0[167] + 0.14236140406080158*x0[168] - 6.3477718701543421e-316*x0[169] + 0.017292640791317253*x0[170] - 1.7117493967518298e-315*x0[171] - 0.07891854514225316*x0[172] + 0.12425057043745065*x0[173] - 3.6233974573716405e-316*x0[174] + 1.0973307874333721e-315*x0[175] - 1.8915759668875752e-315*x0[176] + 8.6161587210798634e-316*x0[177] + 0.073217865888395295*x0[178] - 1.0396364939698011e-315*x0[179] + 8.4038375176456731e-316*x0[180] + 1.4905371065308355e-315*x0[181] - 0.05228836575445444*x0[182] - 0.12557885615997436*x0[183] - 3.3547029981383861e-315*x0[184] - 0.041588774800736868*x0[185] - 0.077896519314059651*x0[186] - 4.0026118917261008e-315*x0[187] + 0.060990345498683485*x0[188] + 2.0262549665260413e-315*x0[189] + 1.6169752344757069e-315*x0[190] + 0.072387783931134764*x0[191] + 0.065832159759649206*x0[192] - 0.11772683266937917*x0[193] + 0.0019782833576902571*x0[194] - 7.342531941793958e-316*x0[195] - 0.059657303567147289*x0[196] - 1.0440847399022859e-315*x0[197] - 0.0098820283245415613*x0[198] - 0.14046100171267614*x0[199] - 5.0993266287056735e-317*x0[200] + 1.2465077481965328e-315*x0[201] + 1.1878316623035156e-315*x0[202] + 4.7638315989299979e-316*x0[203] + 0.034575161939913029*x0[204] + 2.2936455420540125e-315*x0[205] + 2.3723562616219975e-315*x0[206] + 9.4668592305182178e-316*x0[207] - 0.18876709867133787*x0[208] - 0.1538813433762091*x0[209] + 4.9176371494676884e-316*x0[210] + 0.038284601881223387*x0[211] + 0.14858891822617426*x0[212] + 1.4856732377550997e-315*x0[213] - 0.14784136170861462*x0[214] + 1.5085315158839277e-315*x0[215] + 3.7881931968210255e-315*x0[216] + 0.060312953238198574*x0[217] + 0.030760870450419808*x0[218] + 0.35675426147557476*x0[219] - 0.14131318185711164); -x1[5] = relu(0.19927398925638523*x0[0] - 0.1205492243147388*x0[1] - 0.04100761258268279*x0[2] + 0.093864947355285056*x0[3] - 0.58619923666309359*x0[4] + 0.50324025825306595*x0[5] + 0.25781265725304398*x0[6] - 0.0123605517385613*x0[7] + 0.21781845935659919*x0[8] - 0.0050964057862784963*x0[9] + 0.1038946068664057*x0[10] - 1.2074241862759587e-315*x0[11] + 0.082778167351877915*x0[12] - 0.12416318212626473*x0[13] + 1.31747010540998e-315*x0[14] - 7.8638963449845647e-316*x0[15] - 1.5299718651344429e-315*x0[16] - 3.0154033368064067e-316*x0[17] + 0.19270491656006727*x0[18] + 0.12075750640666305*x0[19] + 3.9578816189546119e-315*x0[20] + 3.4342725618998499e-315*x0[21] - 0.38918259337294797*x0[22] - 0.587366500957064*x0[23] - 9.9968209688252372e-316*x0[24] - 0.27431751462108966*x0[25] + 0.11381331391170335*x0[26] + 9.1282294036262441e-317*x0[27] + 0.16294083181186347*x0[28] + 3.4955138069821362e-315*x0[29] - 4.3001986676428117e-317*x0[30] - 0.13448341109289241*x0[31] + 0.15241400048074444*x0[32] + 2.2192396658648068e-315*x0[33] + 0.20497433096507345*x0[34] + 2.5705039173158653e-315*x0[35] - 0.18346608120172761*x0[36] + 2.8235048210273973e-315*x0[37] - 0.11882183603553655*x0[38] + 0.26393994555185535*x0[39] - 3.6624218401091557e-315*x0[40] - 1.8618197023125184e-315*x0[41] - 3.1884619635145651e-315*x0[42] + 1.1429605956449312e-316*x0[43] - 0.34115120800127674*x0[44] + 0.020516057388326833*x0[45] - 5.2690791855007465e-316*x0[46] + 4.2041763028596919e-315*x0[47] - 0.034827786798764589*x0[48] + 0.12013020218567212*x0[49] - 2.005795382048429e-315*x0[50] - 0.33745199182408786*x0[51] + 0.085209110218205028*x0[52] - 1.4905379316204641e-315*x0[53] + 0.015675198838680918*x0[54] + 1.8193945768028616e-315*x0[55] - 2.6793864847769065e-315*x0[56] + 0.30986450033013807*x0[57] + 0.17739018428072043*x0[58] + 0.048148047758204901*x0[59] + 0.27548910311914215*x0[60] + 1.3617640638689701e-315*x0[61] + 0.46617261201004645*x0[62] + 2.9936147602073896e-315*x0[63] + 0.063962536810752257*x0[64] + 0.43049256538869535*x0[65] + 7.737993102389194e-316*x0[66] - 1.0975405874692221e-315*x0[67] - 3.6606466276590529e-315*x0[68] + 3.2077167145675725e-315*x0[69] - 0.41173766287251762*x0[70] + 1.6420587200448699e-315*x0[71] + 3.825619316719496e-316*x0[72] + 3.3191614669426947e-316*x0[73] + 0.11718296068279814*x0[74] - 0.033108179359557635*x0[75] + 2.9394272854101223e-315*x0[76] - 0.44806566040007767*x0[77] - 0.20815348940112666*x0[78] - 1.1996123809518384e-315*x0[79] - 0.028822986329027533*x0[80] - 3.3742131317237288e-315*x0[81] - 9.4137826969102198e-316*x0[82] - 0.43401552341724081*x0[83] + 0.091167643039512247*x0[84] + 0.18418939235065146*x0[85] - 0.17011563455013448*x0[86] + 0.097513597520361261*x0[87] - 0.098891230791751675*x0[88] + 0.18107574264207099*x0[89] + 0.10970518891502369*x0[90] - 0.14034083367278655*x0[91] + 0.0079221565143696212*x0[92] + 8.4389724031708984e-316*x0[93] - 0.0794221534306149*x0[94] - 0.16061091958410056*x0[95] + 2.9673252653373845e-316*x0[96] - 2.5984189029826574e-315*x0[97] + 1.7951697970887965e-315*x0[98] - 1.4808559000818892e-315*x0[99] - 0.057173451548101814*x0[100] + 8.1354035001769675e-316*x0[101] - 3.8305762526409389e-315*x0[102] - 4.1299130436598147e-315*x0[103] - 0.036808429038378714*x0[104] + 0.056858257408024207*x0[105] - 7.5679580882643936e-316*x0[106] - 0.35245798975897752*x0[107] + 0.081787255478491652*x0[108] - 2.3870208562670651e-315*x0[109] - 0.26235107406639491*x0[110] + 4.1570663678456651e-316*x0[111] + 3.3839814666493192e-315*x0[112] - 0.23155663306388202*x0[113] + 0.036606547821178129*x0[114] + 3.7314273317564936e-316*x0[115] + 0.10206624672145607*x0[116] + 1.2892262103614385e-315*x0[117] + 0.010000767608356611*x0[118] + 1.0953233789516933e-316*x0[119] - 4.3849121612913564e-315*x0[120] - 0.10031654458216717*x0[121] - 2.3151104957736906e-315*x0[122] - 1.8918874357520264e-316*x0[123] + 3.7471824478576879e-315*x0[124] - 2.2959281648630507e-315*x0[125] - 0.13907889215754193*x0[126] - 7.7286072879085833e-316*x0[127] + 5.0998194097808355e-316*x0[128] + 2.248321807510052e-315*x0[129] + 0.17891962058010172*x0[130] + 0.055612554287111489*x0[131] - 1.0195516088779949e-315*x0[132] - 0.09258477001507244*x0[133] + 0.2463733177433689*x0[134] - 1.9725857912945437e-315*x0[135] + 0.11659396062129435*x0[136] - 3.3355448962070182e-315*x0[137] + 4.0895014085799371e-316*x0[138] - 0.04193591137548864*x0[139] + 0.064154090720174181*x0[140] - 0.04507103655106378*x0[141] + 0.31306951422853208*x0[142] - 9.155519514826802e-316*x0[143] + 0.82407568605996617*x0[144] - 1.4091224546149776e-315*x0[145] - 0.15812456322113022*x0[146] - 0.1813022198221097*x0[147] - 1.7652780646543065e-315*x0[148] - 3.9797710047080064e-315*x0[149] - 6.9163480007039883e-316*x0[150] + 1.3193029357957008e-315*x0[151] + 0.018864689181407161*x0[152] - 3.2502666805846205e-317*x0[153] - 2.8684674775754076e-315*x0[154] - 4.0227980503939916e-316*x0[155] + 0.34301955609062068*x0[156] + 0.75746782498880172*x0[157] + 1.5727184297532841e-315*x0[158] - 0.014082888673405758*x0[159] - 0.01899419634737199*x0[160] - 1.4866326934766976e-315*x0[161] - 0.082914865982255198*x0[162] - 1.7158056164163089e-315*x0[163] + 1.9145830180636789e-315*x0[164] - 0.35379198551182589*x0[165] + 0.48198963027594449*x0[166] + 0.022660392245362211*x0[167] - 0.12230706435597118*x0[168] - 5.9382181787033887e-316*x0[169] - 0.29712273349902352*x0[170] - 1.1978295895347284e-315*x0[171] + 0.05290382049990866*x0[172] + 0.11576476605758083*x0[173] - 8.3131681219243897e-316*x0[174] - 3.3838264930781882e-315*x0[175] - 4.2251445378010106e-315*x0[176] + 1.6885437460080673e-315*x0[177] - 0.012666350971152047*x0[178] - 3.0307449100807189e-315*x0[179] + 3.778976703577901e-316*x0[180] + 2.3841995487437097e-315*x0[181] + 0.23233981422063088*x0[182] + 0.13814230754308823*x0[183] + 8.5200566783300387e-316*x0[184] - 0.38323887403075069*x0[185] + 0.013956518989964747*x0[186] + 1.1622127824972367e-315*x0[187] + 0.15980847534453158*x0[188] - 7.318764666867942e-316*x0[189] + 3.4898641317373463e-315*x0[190] - 0.010866437235708577*x0[191] - 0.026097962861189573*x0[192] + 0.064495448842976658*x0[193] + 0.3571513066246082*x0[194] - 9.7379227147606551e-316*x0[195] + 0.34543645769132819*x0[196] + 1.2360879975982137e-315*x0[197] - 0.036402155473145577*x0[198] + 0.065308295893071369*x0[199] - 3.8348153951701343e-315*x0[200] + 1.2394155494855803e-317*x0[201] - 4.3290703027383333e-315*x0[202] - 2.4562248486689327e-315*x0[203] - 0.31149649326623852*x0[204] + 3.364301922894674e-316*x0[205] - 3.9513242808898777e-315*x0[206] - 2.1131247207540439e-315*x0[207] + 0.50796072721098018*x0[208] - 0.0050792291580543684*x0[209] - 3.7056973514084344e-315*x0[210] - 0.27552281694415032*x0[211] - 0.072712398148648119*x0[212] - 3.3551478004986805e-315*x0[213] - 0.30986832042685986*x0[214] - 2.6474951303353162e-315*x0[215] - 1.0741199391190153e-315*x0[216] - 0.14270637724220506*x0[217] + 0.32906182622090491*x0[218] + 0.017156783001235746*x0[219] - 0.032573065939152247); -x1[6] = relu(-0.69175685435097534*x0[0] - 0.073259776102597582*x0[1] - 0.16612501465788987*x0[2] + 0.076990963852144906*x0[3] + 0.15318627673744295*x0[4] - 2.449113521757937*x0[5] + 0.046071204904858575*x0[6] + 0.13745602935818388*x0[7] + 0.47221002508096932*x0[8] - 0.03155548643097969*x0[9] - 0.0042934013342856075*x0[10] - 2.4751475826672782e-315*x0[11] + 0.037499280806761896*x0[12] - 0.071027609199154268*x0[13] + 1.6772503045436118e-315*x0[14] - 1.3722955029471881e-315*x0[15] + 4.0876292308061815e-315*x0[16] - 4.5418841489093047e-315*x0[17] + 0.18113812579824187*x0[18] + 0.0083189607645983727*x0[19] + 2.8558057558893901e-316*x0[20] + 3.8751891699995712e-315*x0[21] + 0.013745566006527777*x0[22] - 0.40026963861032477*x0[23] + 4.3685318693438841e-315*x0[24] + 0.2411921789153634*x0[25] + 0.11526444695820917*x0[26] + 2.3444010787742598e-315*x0[27] - 0.014831933555889675*x0[28] + 3.7095529310141375e-315*x0[29] - 1.9916403716511385e-315*x0[30] - 0.082862493729145253*x0[31] - 0.11220160676568139*x0[32] - 2.6164646111717573e-315*x0[33] + 0.29369876719171284*x0[34] + 2.6455539464128059e-316*x0[35] - 0.10402057274144116*x0[36] - 3.8795965221185497e-315*x0[37] + 0.16226499929539548*x0[38] + 0.028812663549905769*x0[39] + 1.022225808355301e-315*x0[40] + 1.0949818313707232e-316*x0[41] + 8.1104240845954445e-316*x0[42] + 3.6512496176509074e-315*x0[43] + 0.0025101349832723613*x0[44] + 0.23664621920737422*x0[45] - 7.9849239501605157e-317*x0[46] - 1.8101887158524356e-315*x0[47] + 0.19853837137670094*x0[48] + 0.38434593228074038*x0[49] + 1.085445489909794e-315*x0[50] + 0.59002757628494373*x0[51] - 0.030073391706366318*x0[52] + 1.5853622119157011e-315*x0[53] + 0.14787430193898041*x0[54] - 1.1366090458030029e-315*x0[55] - 4.306844858473294e-315*x0[56] - 0.15326416165935353*x0[57] - 0.073974662280186468*x0[58] + 0.22304008434643072*x0[59] + 0.0087244592094778417*x0[60] + 4.3099450956976655e-315*x0[61] + 0.60216525172918589*x0[62] - 3.6334032748312174e-316*x0[63] + 0.31863415552864455*x0[64] - 0.055376163200107964*x0[65] + 6.0882546506486501e-316*x0[66] + 4.1619532205552454e-315*x0[67] - 1.6608879224758012e-315*x0[68] + 4.1820900023024908e-316*x0[69] - 0.0071978667359952741*x0[70] - 4.0742736630897703e-315*x0[71] - 1.4726048901612418e-315*x0[72] + 3.3965450174915081e-315*x0[73] + 0.29886637479743189*x0[74] + 0.031799270134990135*x0[75] + 4.0930892638934716e-316*x0[76] + 0.20377727748834015*x0[77] + 0.087036398975240487*x0[78] - 1.592723340438998e-315*x0[79] + 0.096959421331665144*x0[80] + 3.5819319605065576e-317*x0[81] - 2.0474079721375917e-315*x0[82] - 0.31266085651883047*x0[83] + 0.17903329143753843*x0[84] + 0.56047504179232843*x0[85] - 0.10478458065912233*x0[86] - 0.019548359120354603*x0[87] + 0.37776740190477487*x0[88] - 0.088631967667007594*x0[89] + 0.132662586809035*x0[90] + 0.25021691460167284*x0[91] + 0.3928222921752102*x0[92] - 1.4118552008713159e-315*x0[93] + 0.37146578481143211*x0[94] + 0.47128727076912191*x0[95] + 2.0734836008114814e-315*x0[96] - 4.1344911251033701e-316*x0[97] + 5.8903053721929005e-316*x0[98] + 4.5238733464580836e-315*x0[99] + 0.18330658487299753*x0[100] + 1.8674741452907906e-315*x0[101] - 1.1982475690711101e-315*x0[102] + 3.4023753972462644e-315*x0[103] + 0.43248855540466935*x0[104] + 0.084006202566176469*x0[105] - 1.5235605234680548e-315*x0[106] + 0.3375218890843602*x0[107] + 0.021317318579911457*x0[108] + 3.1845619822292704e-315*x0[109] + 0.25282300746932745*x0[110] + 1.9355915144144773e-315*x0[111] + 3.1815544020761199e-316*x0[112] + 0.39175651907158349*x0[113] + 0.41280319591114045*x0[114] - 1.9998313427145032e-315*x0[115] - 0.54485302787792977*x0[116] - 3.1669502069562564e-315*x0[117] + 0.12718622714395481*x0[118] - 4.4857331139564271e-315*x0[119] + 1.0599476364241204e-316*x0[120] - 0.056391786102969112*x0[121] - 2.7998720900580567e-316*x0[122] + 3.2401696487255083e-315*x0[123] - 1.3274946528981908e-315*x0[124] + 1.7614190315297391e-315*x0[125] - 0.028974892634997255*x0[126] + 6.9230404163162955e-316*x0[127] + 4.3361819626950755e-315*x0[128] - 2.9656193258314851e-315*x0[129] + 0.098436311881766089*x0[130] + 0.014011795886977645*x0[131] + 9.6555448275210086e-316*x0[132] - 0.0047672024221148889*x0[133] - 0.11068839585133443*x0[134] - 1.649172944202314e-316*x0[135] - 0.032622922682044912*x0[136] + 2.094855245293286e-315*x0[137] - 2.6373655889567077e-315*x0[138] - 0.017080509834069245*x0[139] - 0.071260567350901957*x0[140] + 0.13252383289649677*x0[141] + 0.2006719481280704*x0[142] - 1.9106227212443399e-315*x0[143] + 0.59170450009268205*x0[144] + 3.1863738790535769e-315*x0[145] + 0.052441943571770171*x0[146] + 0.15773015918156358*x0[147] - 1.037346015516994e-315*x0[148] + 1.4538853604223743e-315*x0[149] - 2.1359217248614746e-316*x0[150] + 2.4738954770416792e-315*x0[151] - 0.13666402755094928*x0[152] - 7.8099082602599896e-316*x0[153] - 4.3415380888363888e-315*x0[154] - 1.2021079806388294e-315*x0[155] + 0.4428751346657781*x0[156] - 0.12081610345297228*x0[157] + 3.3434160141119218e-315*x0[158] - 0.068787557489457682*x0[159] - 0.083282023844394176*x0[160] + 2.8934926633983614e-315*x0[161] + 0.031073068533075825*x0[162] + 6.998555385889255e-316*x0[163] + 3.4669359581416012e-315*x0[164] + 0.26041910584865169*x0[165] + 0.47459633413715557*x0[166] + 0.19106994479878797*x0[167] + 0.020880076347458285*x0[168] - 4.4055475442070719e-316*x0[169] + 0.14405417299191606*x0[170] - 8.1213549905702946e-316*x0[171] + 0.23691592640105333*x0[172] - 0.016839111541910215*x0[173] + 2.6501436779242902e-315*x0[174] - 7.3425333251777664e-316*x0[175] + 3.3172579901102751e-315*x0[176] - 2.8834795584705083e-316*x0[177] - 0.083434371266855004*x0[178] - 2.4654381354260156e-315*x0[179] + 3.0560766043490396e-315*x0[180] + 3.409784914558915e-315*x0[181] + 0.086423279885682783*x0[182] + 0.037162294201192173*x0[183] + 2.6790824763037075e-315*x0[184] + 0.16954251622791217*x0[185] + 0.074221214147128109*x0[186] + 3.0172513597107371e-315*x0[187] + 0.19046534348180422*x0[188] - 7.2866801426401406e-316*x0[189] - 3.2755078027387456e-316*x0[190] + 0.056576793803165423*x0[191] + 0.15442399723861561*x0[192] + 0.16782353645572379*x0[193] + 0.24934054855554305*x0[194] + 1.274491389225471e-315*x0[195] + 0.54588051148554584*x0[196] + 2.297271475006872e-315*x0[197] + 0.069919753271801402*x0[198] - 0.027240057739273148*x0[199] - 6.7534497648333647e-316*x0[200] - 1.3711563456688849e-315*x0[201] - 1.2224510347932136e-315*x0[202] + 5.9340600234148596e-316*x0[203] + 0.052580595810483174*x0[204] - 6.2633484029212191e-316*x0[205] + 3.5830595566487481e-315*x0[206] - 1.8864652382118948e-315*x0[207] + 0.29271320843413928*x0[208] + 0.1204617925922734*x0[209] + 1.7370787343270199e-315*x0[210] - 0.031675613721639483*x0[211] - 0.018201387102496431*x0[212] - 1.415623568009215e-317*x0[213] + 0.25589275890158147*x0[214] - 7.1257235353511084e-316*x0[215] - 1.7257095674210263e-315*x0[216] + 0.14041241208532609*x0[217] + 0.26532830007439068*x0[218] + 0.060769729048821976*x0[219] - 0.034215271354308852); -x1[7] = relu(-0.5798585062428222*x0[0] + 0.014655685582705337*x0[1] - 0.24917260040685649*x0[2] - 0.16793912560351976*x0[3] + 0.96009926398157031*x0[4] + 0.089238711448498736*x0[5] - 0.032931425158341736*x0[6] - 0.10552506567570924*x0[7] - 0.024293681297777675*x0[8] - 0.29432762849155353*x0[9] - 0.074009980938980827*x0[10] - 3.5570082211826644e-315*x0[11] + 0.02193291046816075*x0[12] - 0.20963159030742592*x0[13] - 3.9745931127484304e-315*x0[14] - 4.1558622063503385e-315*x0[15] + 2.0443293157006305e-316*x0[16] - 4.18748505587604e-315*x0[17] - 0.17003089632246088*x0[18] + 0.089672223448042723*x0[19] + 1.2513591171114289e-315*x0[20] + 7.2947961590043747e-316*x0[21] + 0.13554977282745342*x0[22] - 0.16225602318328497*x0[23] - 4.3866200227126182e-315*x0[24] + 0.25702024203470664*x0[25] - 0.14652805850799744*x0[26] + 2.9546526248005939e-315*x0[27] - 0.49921068507240501*x0[28] + 4.7390147309459567e-316*x0[29] - 4.2782234330427958e-315*x0[30] - 0.036540974247909599*x0[31] - 0.10172298072064948*x0[32] - 2.0462907167893686e-315*x0[33] - 0.13760349119439974*x0[34] - 2.6457766020367607e-315*x0[35] - 0.025849419034976017*x0[36] + 3.6171806787565846e-316*x0[37] - 0.038891445840461392*x0[38] - 0.12305761688046855*x0[39] - 8.321075741399208e-316*x0[40] - 3.13470566474708e-316*x0[41] + 1.3956875251338749e-315*x0[42] - 1.6124075185294012e-315*x0[43] + 0.066557270359213161*x0[44] + 0.1458502187213323*x0[45] + 3.132592190252552e-315*x0[46] + 4.9274640163503416e-316*x0[47] - 0.060276719337161673*x0[48] + 0.17323072436999029*x0[49] + 4.0101775387234937e-316*x0[50] + 0.87050847393712816*x0[51] + 0.11582488644258129*x0[52] + 3.6674029457219932e-316*x0[53] - 0.050556718985850582*x0[54] + 7.0668229559099338e-316*x0[55] - 1.2621382263572507e-315*x0[56] - 0.50845858615925332*x0[57] - 0.031230973165135012*x0[58] - 0.050353304412716141*x0[59] + 0.049276536951018891*x0[60] - 3.1635313418562254e-315*x0[61] + 0.35973447676790937*x0[62] + 2.1458737286909065e-315*x0[63] + 0.14833907711069613*x0[64] - 0.033674806684162825*x0[65] + 3.2855927843367556e-315*x0[66] - 4.8555112600838975e-316*x0[67] - 1.8110144724696124e-316*x0[68] + 1.3232089100972797e-315*x0[69] - 0.060106110792126057*x0[70] - 9.1056497142931366e-316*x0[71] - 4.7664767769912674e-316*x0[72] + 4.3797426042192257e-315*x0[73] + 0.067453326783830092*x0[74] + 0.022280658556195463*x0[75] + 6.932709478631667e-316*x0[76] - 0.33093547023177466*x0[77] + 0.13652684131367113*x0[78] - 1.6424510032270113e-315*x0[79] + 0.14844747803766775*x0[80] - 8.366990447624785e-316*x0[81] - 1.0727773107857853e-315*x0[82] + 0.076630024949652417*x0[83] + 0.0074826160664123774*x0[84] + 0.47023072982298852*x0[85] - 0.018550472951964096*x0[86] - 0.17964799203915691*x0[87] + 0.65674203339543713*x0[88] + 0.014311503707155889*x0[89] + 0.19974480740349371*x0[90] + 0.74965304934984323*x0[91] + 0.35438621710186968*x0[92] + 4.4307322292424726e-315*x0[93] + 0.45503118227917205*x0[94] + 0.97217137243343243*x0[95] - 2.9073535021694615e-316*x0[96] + 2.5445752138837359e-315*x0[97] - 6.3421438695694353e-316*x0[98] + 1.6550209373973445e-315*x0[99] + 0.18262621898909714*x0[100] - 4.2733627608717886e-315*x0[101] - 4.5930398244554624e-316*x0[102] - 3.5840445209796408e-315*x0[103] + 0.6209743889375281*x0[104] + 0.12129608152421856*x0[105] + 2.6216191733515367e-315*x0[106] + 0.11412754946416373*x0[107] - 0.041875160373276973*x0[108] + 3.2172759559711864e-315*x0[109] - 0.67622207577255411*x0[110] - 1.0381686941051972e-315*x0[111] - 2.9896938997079016e-315*x0[112] + 0.74936346541040222*x0[113] + 0.46634662729538157*x0[114] - 3.2206950977479791e-315*x0[115] - 0.36424138103682097*x0[116] + 1.3625792178373871e-315*x0[117] - 0.15591849692910284*x0[118] - 3.8548933485209295e-315*x0[119] - 9.6470907220353253e-317*x0[120] + 0.061536370956154857*x0[121] - 5.752975675779901e-316*x0[122] + 2.9614198073670862e-315*x0[123] - 1.2846565181525495e-315*x0[124] + 2.2158078414228854e-316*x0[125] - 0.0007169935823068081*x0[126] - 2.6752052368600908e-315*x0[127] + 3.1885481977323903e-316*x0[128] + 8.8989832403952932e-316*x0[129] - 0.088693374025696117*x0[130] - 0.14695513568960208*x0[131] + 3.4941809858519761e-315*x0[132] + 0.072408230349909508*x0[133] - 0.016252381802660174*x0[134] - 3.7003302866537222e-315*x0[135] - 0.16429358954842985*x0[136] + 1.4821693192541371e-316*x0[137] + 3.474707190794885e-315*x0[138] + 0.076399926685802907*x0[139] + 0.15937420773585473*x0[140] - 0.19050406700458825*x0[141] - 0.42822102957504632*x0[142] + 3.444154986464378e-315*x0[143] + 0.21371441918101949*x0[144] + 1.3349341155296358e-315*x0[145] + 0.074585922063554036*x0[146] + 0.12435581401104769*x0[147] - 3.1602317787876957e-315*x0[148] - 1.6949765498861107e-315*x0[149] - 1.3461713570268768e-315*x0[150] + 3.4817402103227787e-315*x0[151] + 0.15967211024809189*x0[152] + 5.3857569379175819e-316*x0[153] + 1.4001803110843323e-315*x0[154] + 3.9030029759627515e-315*x0[155] + 0.088070257465248547*x0[156] + 0.065713954542295477*x0[157] - 4.0709627315707297e-315*x0[158] - 0.4222863426532168*x0[159] - 0.081134603368763852*x0[160] - 2.9568706040605302e-315*x0[161] + 0.21894864916871506*x0[162] - 2.0939301864219516e-315*x0[163] - 4.0183332680843405e-315*x0[164] - 0.20792068597911548*x0[165] - 0.034960499983784574*x0[166] + 0.013635230972462957*x0[167] - 0.021997457378894147*x0[168] + 5.2174181993746482e-316*x0[169] + 0.28904175688549083*x0[170] + 1.4001985470473203e-315*x0[171] + 0.0044580192810556966*x0[172] - 0.096140171492987231*x0[173] - 2.3354102994214378e-315*x0[174] - 6.0288000753987937e-316*x0[175] + 1.8639677169363472e-315*x0[176] - 4.1637130329791673e-317*x0[177] - 0.037139652790063572*x0[178] - 7.1981122057368783e-316*x0[179] + 3.7961991699439615e-315*x0[180] + 2.9774380974158507e-316*x0[181] + 0.21833515712938145*x0[182] - 0.20283395108307353*x0[183] + 1.539654114061902e-315*x0[184] + 0.30826459149397556*x0[185] - 0.019316612144518606*x0[186] + 2.7722502977674762e-315*x0[187] + 0.14293116416053891*x0[188] - 1.6857164108838326e-317*x0[189] - 2.9818984973632232e-315*x0[190] - 0.11752874198452666*x0[191] + 0.092138009244107949*x0[192] - 0.027138620267259227*x0[193] - 0.1462190041577493*x0[194] + 4.0461482351017885e-316*x0[195] + 0.19515242401520264*x0[196] - 4.1034024494726393e-315*x0[197] + 0.21914708043521711*x0[198] + 0.24706091923924056*x0[199] + 3.2372248544346314e-315*x0[200] + 3.6509959297637373e-315*x0[201] + 4.361400950708267e-316*x0[202] + 2.7431182900765962e-315*x0[203] + 0.019296175484747262*x0[204] - 1.1325138147151281e-315*x0[205] + 1.9910408476931925e-315*x0[206] - 3.6738779675094738e-315*x0[207] + 0.16361405470866078*x0[208] - 0.072282350137092402*x0[209] + 1.5198983755033551e-315*x0[210] - 0.11034541354513923*x0[211] - 0.031813189900719817*x0[212] - 3.250322332138968e-315*x0[213] + 0.033774455779959044*x0[214] + 2.800541855328872e-315*x0[215] + 3.853685847141837e-315*x0[216] - 1.0091985909737637*x0[217] - 0.24606158367023956*x0[218] - 0.19550029779303305*x0[219] + 0.053108968311719872); -x2[0] = relu(0.4067235107513465*x1[0] + 0.44353683178652814*x1[1] + 1.6605495207297656*x1[2] - 1.2007219899371433*x1[3] - 0.20345339775021135*x1[4] - 0.60668456699393625*x1[5] + 1.340810942913528*x1[6] + 0.81665439951304775*x1[7] + 0.5531201327256402); -x2[1] = relu(-0.58639435981898291*x1[0] + 0.88359644940698245*x1[1] - 0.98955175866203871*x1[2] + 1.1362962743013854*x1[3] + 0.98099014772509752*x1[4] + 1.0177049509185954*x1[5] - 0.6521974082329971*x1[6] - 1.1282778717495878*x1[7] + 0.39185486720026275); -x2[2] = relu(-0.57771741578230318*x1[0] + 0.69433440361493526*x1[1] - 0.7692689959690725*x1[2] + 0.9194416260004975*x1[3] + 0.64530414634630873*x1[4] + 0.54396998984811018*x1[5] - 1.8790530143739812*x1[6] - 0.81202815488230973*x1[7] + 0.0099081660491244748); -x2[3] = relu(0.47141837202986575*x1[0] - 0.79455663136308785*x1[1] + 1.0382638451144521*x1[2] + 0.11634479070220931*x1[3] + 0.34018826737390551*x1[4] + 0.18160649407733312*x1[5] - 0.36989575976492861*x1[6] - 1.3992201021724771*x1[7] - 0.32405384144867277); -x3_result[0] = sigmoid(-0.89868928342981602*x2[0] + 1.4199944189224629*x2[1] + 2.1579744471653157*x2[2] - 2.2929148050486901*x2[3] - 0.56308214764676823); +x0[89] = 1.0*middle_assertion_stats_abs_cntr; +x0[90] = 2.0684090968641597*middle_assertion_stats_addition_cntr - 0.23132642526562444; +x0[91] = 1.0*middle_assertion_stats_conjunction_cntr; +x0[92] = 0.97347244624775553*middle_assertion_stats_constant_cntr - 0.80750704392620909; +x0[93] = 1.0*middle_assertion_stats_disjunction_cntr; +x0[94] = 1.0*middle_assertion_stats_division_cntr; +x0[95] = 2.7895691267196265*middle_assertion_stats_equalto_cntr - 2.3671137145153391; +x0[96] = 1.0*middle_assertion_stats_exp_cntr; +x0[97] = 1.0*middle_assertion_stats_false_cntr; +x0[98] = 1.0*middle_assertion_stats_forall_cntr; +x0[99] = 1.0*middle_assertion_stats_ifthenelse_cntr; +x0[100] = 2.7895691267196265*middle_assertion_stats_inequality_cntr - 0.42245541220428762; +x0[101] = 1.0*middle_assertion_stats_log_cntr; +x0[102] = 1.0*middle_assertion_stats_max_cntr; +x0[103] = 1.0*middle_assertion_stats_min_cntr; +x0[104] = 1.0514943753608537*middle_assertion_stats_multiplication_cntr - 0.34379701814968183; +x0[105] = 2.0003360069220513*middle_assertion_stats_negation_cntr - 0.98183674198739934; +x0[106] = 1.0*middle_assertion_stats_notequalto_cntr; +x0[107] = 4.5109334446419505*middle_assertion_stats_pow_cntr - 0.21723031753828123; +x0[108] = 2.4930558858837699*middle_assertion_stats_realconstant_cntr - 0.50172906493743663; +x0[109] = 1.0*middle_assertion_stats_sqrt_cntr; +x0[110] = 26.394155405579589*middle_assertion_stats_trigonometry_cntr - 0.03794171696338617; +x0[111] = 1.0*middle_assertion_stats_true_cntr; +x0[112] = 1.0*middle_assertion_stats_uninterpretedfunction_cntr; +x0[113] = 1.5862324617799162*middle_assertion_stats_unique_variables - 2.171563983290596; +x0[114] = 1.3853974121446897*middle_assertion_stats_variable_cntr - 1.9345576743439254; +x0[115] = 117.95761981271234*middle_literal_stats_abs_cntr - 0.008478230418508757; +x0[116] = 0.17166362569978674*middle_literal_stats_addition_cntr - 0.060988521658452227; +x0[117] = 1.0*middle_literal_stats_conjunction_cntr; +x0[118] = 0.090286815587543409*middle_literal_stats_constant_cntr - 0.095497791862739087; +x0[119] = 1.0*middle_literal_stats_disjunction_cntr; +x0[120] = 1.7689855005756907*middle_literal_stats_division_cntr - 0.033439458538877788; +x0[121] = 2.0532837374454407*middle_literal_stats_equalto_cntr - 1.2590069405697588; +x0[122] = 1.0*middle_literal_stats_exp_cntr; +x0[123] = 1.0*middle_literal_stats_false_cntr; +x0[124] = 1.0*middle_literal_stats_forall_cntr; +x0[125] = 1.0*middle_literal_stats_ifthenelse_cntr; +x0[126] = 2.0532837374454407*middle_literal_stats_inequality_cntr - 0.79427679687568187; +x0[127] = 1.0*middle_literal_stats_log_cntr; +x0[128] = 1.0*middle_literal_stats_max_cntr; +x0[129] = 1.0*middle_literal_stats_min_cntr; +x0[130] = 0.19811233121892721*middle_literal_stats_multiplication_cntr - 0.082830405426615364; +x0[131] = 2.5529411624742262*middle_literal_stats_negation_cntr - 0.48313764686226096; +x0[132] = 1.0*middle_literal_stats_notequalto_cntr; +x0[133] = 0.16942371481996552*middle_literal_stats_pow_cntr - 0.032428329804180853; +x0[134] = 0.72913826386016745*middle_literal_stats_realconstant_cntr - 0.40845997473773771; +x0[135] = 1.0*middle_literal_stats_sqrt_cntr; +x0[136] = 3.2027278540994542*middle_literal_stats_trigonometry_cntr - 0.043967585720764445; +x0[137] = 1.0*middle_literal_stats_true_cntr; +x0[138] = 1.0*middle_literal_stats_uninterpretedfunction_cntr; +x0[139] = 1.6169472673232148*middle_literal_stats_unique_variables - 1.8369487894279259; +x0[140] = 0.15532919408550064*middle_literal_stats_variable_cntr - 0.22999617101670369; +x0[141] = 117.95761981271234*smallest_assertion_stats_abs_cntr - 0.008478230418508757; +x0[142] = 1.4456995849575351*smallest_assertion_stats_addition_cntr - 0.17342576060476719; +x0[143] = 1.0*smallest_assertion_stats_conjunction_cntr; +x0[144] = 1.0264539941560433*smallest_assertion_stats_constant_cntr - 0.72301079154238657; +x0[145] = 1.0*smallest_assertion_stats_disjunction_cntr; +x0[146] = 11.916838896706651*smallest_assertion_stats_division_cntr - 0.017130509446857831; +x0[147] = 2.0160297845385511*smallest_assertion_stats_equalto_cntr - 1.1348771129523418; +x0[148] = 1.0*smallest_assertion_stats_exp_cntr; +x0[149] = 1.0*smallest_assertion_stats_false_cntr; +x0[150] = 1.0*smallest_assertion_stats_forall_cntr; +x0[151] = 1.0*smallest_assertion_stats_ifthenelse_cntr; +x0[152] = 2.0160297845385511*smallest_assertion_stats_inequality_cntr - 0.88115267158620925; +x0[153] = 1.0*smallest_assertion_stats_log_cntr; +x0[154] = 1.0*smallest_assertion_stats_max_cntr; +x0[155] = 1.0*smallest_assertion_stats_min_cntr; +x0[156] = 1.7094086275698364*smallest_assertion_stats_multiplication_cntr - 0.17729293822922976; +x0[157] = 2.0747529068139507*smallest_assertion_stats_negation_cntr - 1.3133291777697451; +x0[158] = 1.0*smallest_assertion_stats_notequalto_cntr; +x0[159] = 1.8874366036972476*smallest_assertion_stats_pow_cntr - 0.04666701586083901; +x0[160] = 1.6935753858341813*smallest_assertion_stats_realconstant_cntr - 0.74179892196316399; +x0[161] = 1.0*smallest_assertion_stats_sqrt_cntr; +x0[162] = 17.208229650322913*smallest_assertion_stats_trigonometry_cntr - 0.01855268056888117; +x0[163] = 1.0*smallest_assertion_stats_true_cntr; +x0[164] = 1.0*smallest_assertion_stats_uninterpretedfunction_cntr; +x0[165] = 2.390572553702162*smallest_assertion_stats_unique_variables - 2.4223597974623075; +x0[166] = 2.0922980271737206*smallest_assertion_stats_variable_cntr - 2.1450829482933913; +x0[167] = 41.714812421160595*smallest_literal_stats_abs_cntr - 0.023986092098705149; +x0[168] = 0.1717450336334706*smallest_literal_stats_addition_cntr - 0.059227533341004238; +x0[169] = 1.0*smallest_literal_stats_conjunction_cntr; +x0[170] = 0.090339966682452699*smallest_literal_stats_constant_cntr - 0.097404574153918844; +x0[171] = 1.0*smallest_literal_stats_disjunction_cntr; +x0[172] = 1.7697667925338136*smallest_literal_stats_division_cntr - 0.033199822673134864; +x0[173] = 2.0051965684798647*smallest_literal_stats_equalto_cntr - 1.0747323230902286; +x0[174] = 1.0*smallest_literal_stats_exp_cntr; +x0[175] = 1.0*smallest_literal_stats_false_cntr; +x0[176] = 1.0*smallest_literal_stats_forall_cntr; +x0[177] = 1.0*smallest_literal_stats_ifthenelse_cntr; +x0[178] = 2.0051965684798647*smallest_literal_stats_inequality_cntr - 0.93046424538963612; +x0[179] = 1.0*smallest_literal_stats_log_cntr; +x0[180] = 1.0*smallest_literal_stats_max_cntr; +x0[181] = 1.0*smallest_literal_stats_min_cntr; +x0[182] = 0.1984602857866811*smallest_literal_stats_multiplication_cntr - 0.072348923273919827; +x0[183] = 2.0731409307148403*smallest_literal_stats_negation_cntr - 0.76366328397279937; +x0[184] = 1.0*smallest_literal_stats_notequalto_cntr; +x0[185] = 0.16945087581388943*smallest_literal_stats_pow_cntr - 0.029827154091009504; +x0[186] = 0.72943489750124979*smallest_literal_stats_realconstant_cntr - 0.4083115777862239; +x0[187] = 1.0*smallest_literal_stats_sqrt_cntr; +x0[188] = 3.2392414057685444*smallest_literal_stats_trigonometry_cntr - 0.039113962205787063; +x0[189] = 1.0*smallest_literal_stats_true_cntr; +x0[190] = 1.0*smallest_literal_stats_uninterpretedfunction_cntr; +x0[191] = 1.8363223514790834*smallest_literal_stats_unique_variables - 1.9094426406129448; +x0[192] = 0.15542016244619064*smallest_literal_stats_variable_cntr - 0.21487147449525459; +x0[193] = 0.00032842472077025258*theory_checksat_ms - 0.040918510018383925; +x1[0] = relu(-0.010604471219204154*x0[0] + 0.027266101716757168*x0[1] - 0.037271076771114721*x0[2] + 0.064705193927656557*x0[3] - 0.14781597203471636*x0[4] - 2.6577952380339518*x0[5] - 0.11872629571988673*x0[6] - 0.22970312975575521*x0[7] - 0.16757446029045237*x0[8] - 0.30519253071338182*x0[9] + 0.10400937080078945*x0[10] - 2.8907555397204009e-315*x0[11] - 0.031177938698050425*x0[12] + 0.1698814353107499*x0[13] + 3.2078235266195469e-316*x0[14] - 7.9454434608407292e-316*x0[15] + 2.6790589439569961e-315*x0[16] - 2.2427428132965561e-315*x0[17] - 0.27174011381741225*x0[18] - 0.20660426636980991*x0[19] - 4.060998000610261e-315*x0[20] + 1.1069668115790062e-315*x0[21] + 0.3384585317724943*x0[22] - 0.037180891951755508*x0[23] + 6.2422281835059267e-316*x0[24] + 0.10726415257510583*x0[25] - 0.092034327737386082*x0[26] + 1.4336084320140295e-315*x0[27] - 0.038199344896797771*x0[28] - 1.5955856801142405e-315*x0[29] - 4.4586757224970297e-315*x0[30] + 0.11518763641979353*x0[31] + 0.094465126589046017*x0[32] - 2.7588952735232754e-316*x0[33] + 0.051998035969074319*x0[34] - 3.3410160062460881e-315*x0[35] - 0.01810989007724877*x0[36] + 2.8681410434625439e-316*x0[37] - 0.22733726855685196*x0[38] - 0.056738334335730535*x0[39] + 1.8673265332977827e-315*x0[40] + 2.7493787786793396e-316*x0[41] + 6.0787623650213606e-316*x0[42] + 1.0199772316099177e-315*x0[43] - 0.052102185899596677*x0[44] - 0.12564852143164001*x0[45] + 6.049828003351443e-316*x0[46] - 2.4391067240266175e-315*x0[47] + 0.14211035824959398*x0[48] - 0.0092550269356592631*x0[49] - 1.9036378533542899e-315*x0[50] + 0.44062410596348389*x0[51] - 0.059118784515769809*x0[52] + 2.9365397434462854e-315*x0[53] + 0.32954089211380921*x0[54] - 3.1057557498906313e-315*x0[55] + 2.6258382864594497e-315*x0[56] - 0.17364036084915935*x0[57] + 0.16771410002994902*x0[58] - 0.24045903368207214*x0[59] + 0.11001556152495123*x0[60] + 5.947857695893139e-316*x0[61] + 0.083433618994753239*x0[62] + 3.9148294302679098e-315*x0[63] + 0.17055865705869269*x0[64] + 0.17755920232087261*x0[65] + 2.9702972134761569e-315*x0[66] + 9.4946129729208331e-316*x0[67] + 7.1030706254892873e-317*x0[68] + 1.1127353392555596e-315*x0[69] - 0.074789998945546665*x0[70] - 1.8625190374122373e-316*x0[71] - 8.7482608077073458e-317*x0[72] + 3.635606545756877e-315*x0[73] - 0.091640694571276812*x0[74] - 0.0015346467034230964*x0[75] + 4.4526816489124933e-315*x0[76] + 0.056286498838058682*x0[77] + 0.077950106594501981*x0[78] - 1.5967483549172858e-315*x0[79] + 0.11036692125669507*x0[80] - 3.8148056228784653e-315*x0[81] - 1.7742441110808976e-315*x0[82] - 0.16814224709051598*x0[83] - 0.14635374818083768*x0[84] + 0.13103573985556882*x0[85] + 0.049465969972096256*x0[86] + 0.0063274215832842574*x0[87] - 0.20429488347717009*x0[88] - 3.7576017785002081e-315*x0[89] + 0.17147453466499471*x0[90] + 4.36941070837405e-315*x0[91] + 0.084097192495086986*x0[92] - 7.8281434327429567e-316*x0[93] - 1.8927611315588192e-315*x0[94] - 0.024360131964515423*x0[95] - 1.6289210995068086e-315*x0[96] - 2.7283072247301626e-316*x0[97] - 3.8862993328720454e-315*x0[98] + 3.1188031836857007e-315*x0[99] - 0.024254269088224974*x0[100] - 1.712810274269206e-315*x0[101] + 6.0884882448860039e-316*x0[102] - 3.9952889594178839e-315*x0[103] - 0.026716790992688928*x0[104] + 0.017253120347038579*x0[105] + 4.1584152856345667e-315*x0[106] - 0.011020606105697108*x0[107] - 0.099363698905047371*x0[108] - 3.0171189945835598e-315*x0[109] - 0.18200189164175046*x0[110] - 4.567685166015923e-316*x0[111] - 3.9748786728104137e-317*x0[112] - 0.040115380375649275*x0[113] + 0.072377139225336964*x0[114] + 0.034182829290026112*x0[115] + 0.074543540655131316*x0[116] - 1.4865135989527675e-315*x0[117] + 0.2211786933658508*x0[118] + 9.6762432136878818e-316*x0[119] + 0.33370705712277732*x0[120] + 0.17194692458058436*x0[121] + 5.631560426698223e-316*x0[122] - 3.7075671230824948e-315*x0[123] + 3.4629589520221197e-315*x0[124] - 3.7155303743490349e-315*x0[125] - 0.23533139072174863*x0[126] - 4.2253866052641906e-315*x0[127] - 2.6626568884178244e-315*x0[128] - 1.2078850210664607e-316*x0[129] + 0.27930827661300128*x0[130] + 0.13110947143745785*x0[131] + 9.4653685850581502e-316*x0[132] + 0.072034726970716237*x0[133] - 0.048801338977910107*x0[134] + 1.466273769933769e-315*x0[135] + 0.79263637177496837*x0[136] - 2.037720812197613e-315*x0[137] - 4.2108850720448764e-315*x0[138] + 0.17832432345053645*x0[139] + 0.26112493582174345*x0[140] - 0.13080034413340536*x0[141] + 0.018884147650994065*x0[142] + 9.4400782045591347e-316*x0[143] - 0.010182022914375*x0[144] - 7.1998780457616795e-316*x0[145] - 0.16946818608746372*x0[146] - 0.023456113839292515*x0[147] - 1.7335439811891003e-315*x0[148] - 9.1516703481931821e-316*x0[149] - 4.0084745438488435e-315*x0[150] + 3.7297396529168645e-315*x0[151] - 0.024020673460228924*x0[152] + 4.8140282732949519e-316*x0[153] - 3.6335593995753032e-316*x0[154] + 2.6849086960257258e-315*x0[155] + 0.13919898173981574*x0[156] - 0.013555132203867417*x0[157] - 2.1765002997824256e-315*x0[158] + 0.1103065489989429*x0[159] + 0.094501719337912293*x0[160] - 3.7901772014130609e-315*x0[161] - 0.12226847477492556*x0[162] + 4.2646548933890883e-316*x0[163] + 1.7521583490552506e-315*x0[164] - 0.063245371189561764*x0[165] + 0.063818714236848387*x0[166] - 0.19204719948368626*x0[167] + 0.038119739555118229*x0[168] + 1.152859032877041e-315*x0[169] + 0.28644785675094142*x0[170] - 4.5216106246132598e-315*x0[171] + 0.062298367394911729*x0[172] + 0.15179773895274531*x0[173] + 3.8130761263225722e-317*x0[174] + 7.7295827711197322e-316*x0[175] + 1.3455879346683287e-316*x0[176] + 1.6677417098093531e-316*x0[177] + 0.069908924879240511*x0[178] + 1.4852079267298464e-315*x0[179] + 1.3063738653074056e-315*x0[180] - 3.2779782100184551e-315*x0[181] + 0.18321113552533522*x0[182] - 0.077422510910335432*x0[183] - 3.2623968815081856e-316*x0[184] + 0.20299665391443966*x0[185] + 0.05711336257898162*x0[186] - 1.4675036376646487e-315*x0[187] + 0.19794979011610742*x0[188] - 1.0284381552015137e-315*x0[189] + 3.2832205627228441e-315*x0[190] + 0.19800054924888708*x0[191] - 0.063610817654348464*x0[192] + 0.0141930355424144*x0[193] + 0.20051833763403767); +x1[1] = relu(0.35595955458365103*x0[0] + 0.21849870976418062*x0[1] + 0.067010144682555478*x0[2] + 0.12823494260030222*x0[3] + 1.2917038514496597*x0[4] - 0.51822747453597884*x0[5] + 0.0089812119971229808*x0[6] - 0.35116822559537536*x0[7] + 0.14315630677246652*x0[8] + 0.22627366612950178*x0[9] + 0.13103291758869043*x0[10] - 4.0747359899585227e-315*x0[11] + 0.068026642011724731*x0[12] - 0.10419827440185407*x0[13] - 2.8301541145901355e-316*x0[14] + 7.1100988575210728e-316*x0[15] - 1.5649223999452354e-315*x0[16] + 5.3656873490981709e-316*x0[17] - 0.0010935625891157455*x0[18] - 0.24717162820414251*x0[19] + 3.9726304814362342e-315*x0[20] + 7.4359041730373806e-316*x0[21] - 0.16670304057799951*x0[22] - 0.030429018174880158*x0[23] + 4.4192149710997946e-315*x0[24] - 0.10991995643611759*x0[25] - 0.080904610088844572*x0[26] + 5.866762205443838e-316*x0[27] - 0.18151794507395252*x0[28] - 8.3207672962165093e-316*x0[29] - 3.3765053937535174e-316*x0[30] + 0.070027342362614056*x0[31] + 0.055336741948584678*x0[32] + 5.8394594461627466e-316*x0[33] - 0.12362281935667087*x0[34] + 7.7169282677328004e-316*x0[35] - 0.14472664256349044*x0[36] - 2.7400784523774288e-315*x0[37] + 0.11781354125141837*x0[38] + 0.30907512057311426*x0[39] + 7.0128448513114047e-316*x0[40] - 1.3981132095913229e-315*x0[41] + 3.8711066067548558e-316*x0[42] + 1.8117338567532395e-315*x0[43] - 0.26581557804949368*x0[44] - 0.19551779793008708*x0[45] - 3.6967750495541261e-316*x0[46] - 3.2362094408379855e-315*x0[47] - 0.037488407849211119*x0[48] - 0.095239847940959604*x0[49] + 7.8936300060563243e-317*x0[50] - 0.32934229351671684*x0[51] - 0.14290456943115476*x0[52] + 1.8404355876138128e-315*x0[53] - 0.38384930630195951*x0[54] + 2.4411568000174711e-315*x0[55] - 4.1860060802465271e-315*x0[56] - 0.12266533305053159*x0[57] - 0.21318316497122691*x0[58] - 0.11229461467432734*x0[59] + 0.12933501828345867*x0[60] - 3.7375087512065583e-315*x0[61] - 0.31465481218198599*x0[62] + 2.5306788270894175e-315*x0[63] + 0.18714272541345425*x0[64] - 0.15009999077242628*x0[65] + 4.058406221163994e-315*x0[66] - 1.1136035064677754e-315*x0[67] + 3.4353539036162768e-315*x0[68] - 1.140701910316434e-315*x0[69] + 0.010133865681169288*x0[70] - 1.6838758780146932e-315*x0[71] - 1.1245996834550976e-316*x0[72] + 2.7343863368936612e-315*x0[73] + 0.34397010262554401*x0[74] - 0.017069435803989754*x0[75] + 1.3919091630479604e-315*x0[76] - 0.63110721116486967*x0[77] + 0.034759865450227939*x0[78] - 1.2261099663905588e-316*x0[79] - 0.30905319952561228*x0[80] - 3.8462146210300209e-315*x0[81] - 4.2104227748200628e-315*x0[82] + 0.77599115846136679*x0[83] + 0.46655783329702699*x0[84] + 0.27737369858653338*x0[85] - 0.15951918463541795*x0[86] + 0.056738929761302556*x0[87] + 0.7711025054916234*x0[88] - 3.5331538078986913e-315*x0[89] + 0.36771193255369722*x0[90] + 1.8070159843758498e-315*x0[91] + 0.24298722744484058*x0[92] + 5.4658551074541877e-316*x0[93] + 1.8300568988113195e-316*x0[94] - 0.08609174518152328*x0[95] + 2.7600035072328054e-315*x0[96] - 6.3787217726264691e-316*x0[97] + 2.7740208363565693e-315*x0[98] + 1.0907798574000645e-315*x0[99] - 0.098529028830319207*x0[100] + 2.3287118611489079e-315*x0[101] + 8.6784898453329367e-316*x0[102] + 3.9471726522085302e-315*x0[103] + 0.084363624210194915*x0[104] + 0.12167924264658619*x0[105] + 7.7098464295784411e-316*x0[106] - 0.052738036403747086*x0[107] + 0.082365646736473189*x0[108] - 3.6645835107074355e-316*x0[109] + 0.030805705698796985*x0[110] + 4.3278433302321382e-315*x0[111] + 1.2639788382768935e-315*x0[112] + 0.14455176149367713*x0[113] - 0.022306931580147234*x0[114] - 0.24785041418815973*x0[115] - 0.49987769428270301*x0[116] + 3.3841667906730742e-315*x0[117] - 1.1738787440849205*x0[118] + 3.740564715208406e-315*x0[119] - 0.20900038984179647*x0[120] + 0.14145805873815104*x0[121] + 1.6358586655519258e-315*x0[122] - 4.1577041720098509e-315*x0[123] + 7.2525264220809915e-316*x0[124] - 7.82549138716921e-316*x0[125] - 0.15335613017544966*x0[126] + 1.3992438936438e-315*x0[127] - 3.9863808273662984e-315*x0[128] + 3.5820667416147431e-316*x0[129] - 0.18263171994319596*x0[130] - 0.18891601395572905*x0[131] + 1.3265058002706654e-315*x0[132] - 0.44378808143255855*x0[133] - 0.19509549026675943*x0[134] - 1.7762898195314421e-315*x0[135] - 0.15799686419746059*x0[136] - 3.7521086825398982e-315*x0[137] + 6.4191161845779327e-316*x0[138] - 0.039461670740293567*x0[139] - 0.056512943520428391*x0[140] - 0.32429827243914328*x0[141] - 0.14203445008318971*x0[142] - 3.1227067864721795e-316*x0[143] - 0.017123575555485018*x0[144] + 1.0476335245045474e-315*x0[145] - 0.31893598578317406*x0[146] - 0.084708646863697154*x0[147] - 2.9526248608143064e-315*x0[148] - 2.286877366415572e-315*x0[149] - 3.3335620279659683e-315*x0[150] - 1.1279611154000621e-314*x0[151] + 0.011470838283458514*x0[152] + 2.0388447423727114e-315*x0[153] - 2.1621940707129125e-315*x0[154] + 3.3929864405081461e-315*x0[155] - 0.034468439894934019*x0[156] - 0.02329839173520569*x0[157] + 2.2622304471323872e-316*x0[158] - 0.40589700232859077*x0[159] + 0.10081784767102071*x0[160] - 7.4711605987114828e-316*x0[161] - 0.3813702595731987*x0[162] - 9.1374562277820231e-316*x0[163] + 3.4016525248591776e-315*x0[164] - 0.36430812788300071*x0[165] - 0.24865247863859968*x0[166] - 0.18604818501531628*x0[167] - 0.26920914655018746*x0[168] - 4.3659065329589516e-315*x0[169] - 0.52953995058821468*x0[170] + 2.9339968715583003e-315*x0[171] - 0.24276519488157741*x0[172] + 0.21847197517640135*x0[173] - 6.7317088013406373e-316*x0[174] + 4.9544763638448076e-316*x0[175] + 3.281014011201296e-315*x0[176] + 1.7677181659473002e-316*x0[177] - 0.11842692925840342*x0[178] - 1.1052697603140755e-316*x0[179] - 3.7306547118995271e-316*x0[180] + 2.8758307503436075e-315*x0[181] - 0.18893292847927098*x0[182] + 0.20372791965396206*x0[183] - 2.389646024669678e-316*x0[184] - 0.3725734682795292*x0[185] - 0.046311917203790201*x0[186] + 4.1014182274917198e-315*x0[187] - 0.2827362060208492*x0[188] - 1.286496685413111e-315*x0[189] - 1.0208596279127337e-315*x0[190] - 0.11256103250379379*x0[191] - 0.16880938880406901*x0[192] + 0.072337069637963547*x0[193] + 0.38173211624652204); +x1[2] = relu(0.29194204364386095*x0[0] - 0.20823675934474145*x0[1] - 0.04785935829868216*x0[2] - 0.081434829144280671*x0[3] - 0.67762707725575522*x0[4] - 0.20211523669613735*x0[5] + 0.37015936753730894*x0[6] - 0.29343202389791789*x0[7] - 0.053966481616455175*x0[8] + 0.27982172485373574*x0[9] + 0.2506536895259846*x0[10] + 1.9891883781980495e-316*x0[11] - 0.32096461826666256*x0[12] + 0.13163556499234216*x0[13] + 3.7372309677378405e-315*x0[14] - 2.9837667028491862e-315*x0[15] + 3.4833132461699468e-316*x0[16] - 3.8861657029368147e-315*x0[17] - 0.0073924823766479426*x0[18] + 4.4254479462212236e-5*x0[19] + 3.3758066218886347e-315*x0[20] - 1.5390609833134131e-315*x0[21] + 0.36824670861726688*x0[22] + 0.28506374483984215*x0[23] - 8.5060606879015187e-316*x0[24] - 0.21890759473566568*x0[25] + 0.083407082110472874*x0[26] - 1.9337394204092251e-315*x0[27] + 0.064180170393168437*x0[28] + 1.132512100307337e-315*x0[29] + 3.4172269265690925e-315*x0[30] - 0.13914282890285229*x0[31] + 0.19216273296731928*x0[32] - 1.607143328123466e-315*x0[33] - 0.02394047422155772*x0[34] + 3.0812556372734518e-315*x0[35] - 0.24818826257336915*x0[36] - 2.2444830063736817e-315*x0[37] - 0.12226600567852904*x0[38] + 0.27008996597634899*x0[39] + 3.319987939955058e-315*x0[40] + 2.7435815062635112e-315*x0[41] - 4.4140294161820515e-315*x0[42] + 4.1716964569460271e-315*x0[43] - 0.3021055352398872*x0[44] - 0.14178638237086788*x0[45] - 1.168057420986532e-315*x0[46] + 4.0841337064805417e-315*x0[47] - 0.16479019827922697*x0[48] - 0.20166661591514004*x0[49] + 3.720824979436128e-315*x0[50] - 0.2200466391539517*x0[51] + 0.015649256194966949*x0[52] + 1.2240768072074188e-315*x0[53] - 0.2216612695694761*x0[54] + 3.5406655918593745e-315*x0[55] + 2.2326342746485524e-315*x0[56] - 0.10105838910008869*x0[57] - 0.13843669670816311*x0[58] - 0.1231140315745224*x0[59] - 0.039156397142408858*x0[60] - 2.3934137198782987e-315*x0[61] - 0.20990844674345413*x0[62] + 1.8126489651424667e-315*x0[63] - 0.2729618843688883*x0[64] + 0.33426689493537987*x0[65] + 3.1188809446776997e-315*x0[66] - 1.537835325021836e-315*x0[67] + 2.2420658988958455e-315*x0[68] - 4.3750176469404746e-316*x0[69] - 0.2977549880968699*x0[70] - 1.7893507363779865e-315*x0[71] - 1.0671275466091792e-316*x0[72] + 9.1125238472499842e-316*x0[73] + 0.10327410236506049*x0[74] - 0.328868026582124*x0[75] + 6.2021889059406937e-316*x0[76] - 0.058936274095886872*x0[77] + 0.38729608264263193*x0[78] + 4.259822382959894e-315*x0[79] - 0.18216129593805694*x0[80] - 3.8987399799441749e-315*x0[81] - 2.4716296425832867e-315*x0[82] + 0.43962701991415604*x0[83] + 0.10228340073734475*x0[84] - 0.27176830349065156*x0[85] - 0.12911630928584711*x0[86] - 0.096946494983023088*x0[87] - 0.12506854046789972*x0[88] - 7.5237006264346618e-316*x0[89] - 0.048687133002365074*x0[90] + 1.6314654140664796e-315*x0[91] - 0.43389565427809013*x0[92] - 1.1761026772689687e-315*x0[93] - 1.6929594873617122e-315*x0[94] + 0.017670803516904678*x0[95] + 4.1754649574816506e-315*x0[96] + 1.4904811881810392e-315*x0[97] - 6.1056817293612793e-316*x0[98] - 1.1119123148214044e-315*x0[99] - 0.07778284820619151*x0[100] + 2.3009333660574359e-315*x0[101] + 3.2485345704214608e-315*x0[102] - 1.0701365052054815e-315*x0[103] + 0.041041554936070951*x0[104] - 0.061562863794148888*x0[105] + 1.1755020811885712e-316*x0[106] + 0.12313724467370499*x0[107] + 0.49030460756466004*x0[108] - 2.3744098158349979e-315*x0[109] - 0.31252146881928822*x0[110] - 6.654822009095435e-316*x0[111] - 2.7582806212752537e-315*x0[112] + 0.088264417001042247*x0[113] - 0.0045235861217796658*x0[114] - 0.024457629198201679*x0[115] - 0.26330450611172579*x0[116] + 2.4222086364603341e-315*x0[117] - 0.021029180161929662*x0[118] + 1.4542644421704589e-316*x0[119] - 0.23735682974843086*x0[120] + 0.55286475576418603*x0[121] - 3.4819530488623506e-315*x0[122] + 4.3834441736818071e-315*x0[123] - 1.7546488203408377e-315*x0[124] - 1.5066733992184527e-315*x0[125] - 0.59246002077475313*x0[126] + 4.3252060572212022e-315*x0[127] + 2.4431047971052375e-315*x0[128] + 1.2932140661625026e-315*x0[129] - 0.20120044839080783*x0[130] + 0.71795686054828767*x0[131] - 3.6994598022736275e-318*x0[132] - 0.23338503932859103*x0[133] + 0.0088156123764411842*x0[134] + 7.0114868130706808e-316*x0[135] + 0.015695199977588361*x0[136] + 1.5349175017745655e-315*x0[137] + 1.478522719535312e-315*x0[138] - 0.054978806495855667*x0[139] - 0.023757816526809247*x0[140] - 0.070480796056049635*x0[141] + 0.16950688212444961*x0[142] - 2.6438124490023753e-315*x0[143] + 0.052004973184636913*x0[144] + 2.3045279011385022e-316*x0[145] - 0.11041508090885449*x0[146] + 0.1670028358702062*x0[147] + 3.6137994565181103e-315*x0[148] + 4.4243930853889113e-316*x0[149] - 8.816743839756176e-316*x0[150] - 3.4224690124780327e-316*x0[151] - 0.024096565949011484*x0[152] + 1.3980927404516157e-315*x0[153] + 1.7715912700614612e-315*x0[154] - 1.2192668607562701e-316*x0[155] + 0.12985063456993887*x0[156] - 0.29046306788409626*x0[157] - 3.1355574833270749e-317*x0[158] - 0.16115022190491157*x0[159] + 0.015419871914820117*x0[160] + 1.4108592633424291e-315*x0[161] - 0.10150753824572871*x0[162] + 9.7074318980866438e-316*x0[163] - 1.7564248084740045e-315*x0[164] - 0.035587141763902007*x0[165] - 0.14298343098193858*x0[166] - 0.28640762499134842*x0[167] - 0.21029502357147883*x0[168] + 1.6643214810881396e-315*x0[169] + 0.13052226359768129*x0[170] + 1.5966468787742865e-315*x0[171] - 0.2004122829817187*x0[172] + 0.14492248579197378*x0[173] + 2.9132320434433744e-316*x0[174] - 2.9549997997892701e-315*x0[175] + 1.1755533454399837e-315*x0[176] - 1.866051517848186e-315*x0[177] - 0.22113897197935611*x0[178] - 1.4322027263197949e-315*x0[179] - 1.6789350140487094e-316*x0[180] - 3.7036117817415835e-315*x0[181] - 0.25488032520412862*x0[182] - 0.34215634075067247*x0[183] + 3.6374313920417611e-316*x0[184] - 0.13914554599267623*x0[185] - 0.24793086128808425*x0[186] + 3.8698489181874588e-315*x0[187] - 0.1297302262010688*x0[188] + 9.4846210881124689e-316*x0[189] + 3.3413037846628213e-315*x0[190] - 0.2112723331584945*x0[191] - 0.26372430623515336*x0[192] + 0.020920978793589503*x0[193] + 0.070354441665743603); +x1[3] = relu(0.13416892103684652*x0[0] + 0.047510156729375801*x0[1] - 0.094854171226347705*x0[2] + 0.012905546275151407*x0[3] - 0.2281446184135372*x0[4] + 0.46179447950489633*x0[5] + 0.23956833181796691*x0[6] + 0.05973744950875659*x0[7] + 0.19626443709263236*x0[8] + 0.22367808286548455*x0[9] - 0.19326907620812253*x0[10] + 1.3200686584962514e-315*x0[11] - 0.2468007164855732*x0[12] + 0.37445734414648862*x0[13] - 1.502092200220672e-315*x0[14] + 3.3230231680217497e-315*x0[15] - 1.2357745919964307e-315*x0[16] + 1.5750585865067805e-315*x0[17] - 0.13221767196310852*x0[18] - 0.099056653258644059*x0[19] - 3.828349375258721e-315*x0[20] - 1.7001249757705688e-315*x0[21] - 0.12543933831463402*x0[22] + 0.47770770249719152*x0[23] - 4.8611343694189105e-316*x0[24] + 0.067544702728677547*x0[25] + 0.067531286660511877*x0[26] + 9.6483953517797337e-316*x0[27] + 0.18202992331654927*x0[28] - 6.9553177249591041e-316*x0[29] - 1.1104798604131039e-315*x0[30] + 0.10218662235616527*x0[31] + 0.0049372923665933566*x0[32] + 5.7876110115306161e-316*x0[33] - 0.26192680902476961*x0[34] - 4.7585089803207856e-316*x0[35] - 0.13105128088993784*x0[36] - 3.6561631202614244e-315*x0[37] - 0.14230006353369315*x0[38] - 0.20254268282252047*x0[39] - 1.2425833600683335e-315*x0[40] - 3.769595553076987e-315*x0[41] - 1.878287340125519e-316*x0[42] + 5.7333390366859406e-316*x0[43] + 0.31907536882364607*x0[44] + 0.00069446970936557883*x0[45] - 1.5118821356962986e-315*x0[46] - 1.563212547439421e-315*x0[47] - 0.074646473034921876*x0[48] + 0.062787952057580143*x0[49] - 1.2945806962048076e-316*x0[50] - 0.29085226082951843*x0[51] + 0.0381358596059602*x0[52] - 3.3578778442159361e-315*x0[53] - 0.21013293030579305*x0[54] - 4.2968513234856727e-316*x0[55] - 1.3103728326448447e-315*x0[56] - 0.21153855459442142*x0[57] + 0.037312436527544006*x0[58] + 0.36000613102194068*x0[59] - 0.050812737576326275*x0[60] - 3.5647860594936332e-315*x0[61] + 0.19161528780322509*x0[62] + 2.4723158552994521e-316*x0[63] - 0.26019930080352177*x0[64] - 0.25676855471928989*x0[65] - 1.9115503349291289e-314*x0[66] + 7.3908554156692695e-316*x0[67] - 9.412032963425473e-316*x0[68] - 2.2256841642766873e-316*x0[69] + 0.20737504866290105*x0[70] + 3.0130987379574414e-315*x0[71] - 7.6595193218829851e-316*x0[72] + 8.4898898205000055e-316*x0[73] - 0.068162602395390709*x0[74] + 0.22596245185089928*x0[75] - 1.2410787621944273e-315*x0[76] - 0.21577029424071759*x0[77] - 0.031873444900685922*x0[78] - 7.2917665978706408e-316*x0[79] - 0.31073090155190242*x0[80] - 4.1775606011470202e-315*x0[81] + 6.2974702068396469e-316*x0[82] - 0.89474992662359576*x0[83] + 0.034150899648201442*x0[84] - 0.48205791053867231*x0[85] + 0.10962755099489437*x0[86] + 0.0014027243945583467*x0[87] - 0.080727257803559757*x0[88] + 5.165605732721535e-316*x0[89] + 0.56090279860838754*x0[90] + 4.5341023481918564e-315*x0[91] + 0.12431891858423963*x0[92] + 8.0167077860362581e-316*x0[93] - 1.1323193850615202e-315*x0[94] + 0.096705393156629571*x0[95] + 6.0076898855161119e-316*x0[96] - 2.8795988408047449e-315*x0[97] + 4.0131171156811505e-315*x0[98] - 2.2734477283775363e-315*x0[99] + 0.02410813188866336*x0[100] - 4.1015685272018412e-315*x0[101] + 2.4012033564768902e-316*x0[102] - 1.3863778511099447e-315*x0[103] + 0.0026748885278293742*x0[104] + 0.059490405628182301*x0[105] + 2.0628969746006229e-315*x0[106] - 0.0026014331959179878*x0[107] - 0.07047302967244308*x0[108] + 3.6375937617756103e-315*x0[109] - 0.14886345292632638*x0[110] + 6.2426741765644276e-316*x0[111] - 3.6750486807605769e-315*x0[112] + 0.015715767686520853*x0[113] + 0.0080825335017057128*x0[114] + 0.29555289009468894*x0[115] + 0.22670130020161569*x0[116] - 1.2492685277376162e-315*x0[117] - 0.58262224903590565*x0[118] - 1.0917291501913274e-315*x0[119] - 0.21209079342986303*x0[120] - 0.0052721769932511115*x0[121] - 3.0321446029960436e-317*x0[122] - 4.4544126128433546e-316*x0[123] - 2.568271377941346e-315*x0[124] - 2.7638283065487725e-315*x0[125] + 0.32383779476023344*x0[126] - 3.3413517979622841e-315*x0[127] - 2.7205270247854067e-315*x0[128] - 1.8312057101323425e-315*x0[129] - 0.049989768829541883*x0[130] - 0.17967238430395124*x0[131] - 1.9951471359702211e-315*x0[132] - 0.341563886016366*x0[133] - 0.045187676745713938*x0[134] - 5.1928702019150738e-316*x0[135] - 0.22755832845958757*x0[136] + 1.6775050892565157e-315*x0[137] - 4.1843402934556652e-315*x0[138] + 0.26400976959149747*x0[139] + 0.20905229419524798*x0[140] + 0.194095075427487*x0[141] + 0.12096305775860074*x0[142] + 1.7567934357930231e-315*x0[143] - 0.013783442255454926*x0[144] + 3.7635244299549817e-315*x0[145] + 0.067473740382389652*x0[146] - 0.0011748332504337075*x0[147] - 3.527510184958063e-316*x0[148] - 2.015682925133048e-315*x0[149] + 1.6496690701018984e-315*x0[150] - 1.9502918053024569e-315*x0[151] - 0.062732666449079447*x0[152] + 4.351133599599064e-315*x0[153] - 3.4782780156656074e-315*x0[154] - 2.3952528150164088e-315*x0[155] - 0.040192180175834737*x0[156] - 0.066549074974210087*x0[157] + 2.6830112369128725e-316*x0[158] - 0.1891636510058301*x0[159] - 0.11291838284227655*x0[160] - 4.3113438647102325e-315*x0[161] - 0.014399171583824519*x0[162] - 2.4063615994457311e-316*x0[163] - 2.5558285668616878e-315*x0[164] - 0.094063356567477441*x0[165] + 0.050126597575029679*x0[166] - 0.018077743329138411*x0[167] + 0.03341105652206626*x0[168] - 1.3996575303431547e-315*x0[169] - 0.27848811905024257*x0[170] - 3.3490492666146439e-315*x0[171] - 0.14351054949058167*x0[172] - 0.19640232889270967*x0[173] + 1.1932859247040623e-316*x0[174] + 7.7885262848655305e-316*x0[175] + 3.7088828347193394e-315*x0[176] - 4.0440234069787191e-316*x0[177] + 0.22489268046626434*x0[178] - 1.8145002291174338e-315*x0[179] + 3.61630513020362e-315*x0[180] + 4.3535946146908461e-316*x0[181] + 0.0016106837869763143*x0[182] - 0.22563994957533343*x0[183] - 1.5606038709480663e-316*x0[184] - 0.49420529771196059*x0[185] - 0.061152350818013491*x0[186] + 3.1608164066664196e-315*x0[187] - 0.254898094582025*x0[188] + 1.9677824455604235e-315*x0[189] - 1.2612184490476703e-315*x0[190] - 0.052162706779991332*x0[191] + 0.032778558839055581*x0[192] - 0.13041000048315537*x0[193] - 0.085532793195484819); +x1[4] = relu(0.060993705006815932*x0[0] + 0.053969115230583092*x0[1] + 0.18209032103965594*x0[2] - 0.027874382183623831*x0[3] - 1.13506562806172*x0[4] + 0.14338624065691041*x0[5] + 0.16563484084651597*x0[6] - 0.076211525809581002*x0[7] - 0.073485643964444847*x0[8] + 0.10770903155316724*x0[9] - 0.070976767888317513*x0[10] - 2.7375845572169159e-315*x0[11] - 0.058738868527608956*x0[12] + 0.036307443519697793*x0[13] - 7.5312617082654871e-316*x0[14] - 2.7643378018647334e-317*x0[15] + 4.9742083082018507e-316*x0[16] + 1.0460199555117944e-315*x0[17] - 0.29156239365156594*x0[18] + 0.21405528100336899*x0[19] - 1.6371539376930019e-315*x0[20] - 1.6716298730443993e-315*x0[21] + 0.2582635176819244*x0[22] + 0.0026667213625620732*x0[23] - 3.7338417070513083e-315*x0[24] + 0.016498559618569164*x0[25] - 0.0076061773059896663*x0[26] + 1.41473790593248e-315*x0[27] + 0.36550420052508314*x0[28] - 2.0348531711979906e-315*x0[29] - 2.2726805679459563e-315*x0[30] + 0.31112899129052463*x0[31] + 0.17151582295692627*x0[32] + 1.3894380640763467e-315*x0[33] + 0.16962855207152697*x0[34] - 2.4705384986044463e-315*x0[35] + 0.053605302986353257*x0[36] + 1.8938985250227668e-315*x0[37] - 0.21877407603967036*x0[38] + 0.066635276421805223*x0[39] - 6.5244535988192094e-316*x0[40] - 2.5899708003945711e-315*x0[41] + 2.5638124651315675e-316*x0[42] + 3.1873781909951607e-315*x0[43] - 0.26083419538400404*x0[44] + 0.3010857324249433*x0[45] - 3.0577683789928727e-316*x0[46] + 1.0479907685510858e-315*x0[47] + 0.027474545710185063*x0[48] - 0.0029552234160596107*x0[49] + 2.4636647164342072e-316*x0[50] - 0.12049953401345563*x0[51] + 0.071493672137110442*x0[52] + 3.1433941796784327e-315*x0[53] - 0.02206014327399913*x0[54] + 2.9683840628383917e-315*x0[55] + 3.5551301837903491e-316*x0[56] - 0.068230792609540111*x0[57] - 0.10722430630503435*x0[58] - 0.073272839836553486*x0[59] - 0.037954362045998877*x0[60] + 1.2315919508144937e-315*x0[61] - 0.075889520418426726*x0[62] + 5.4322513807719891e-316*x0[63] + 0.018913287043562408*x0[64] + 0.34340322318581695*x0[65] - 9.8693016029177245e-315*x0[66] - 5.3032882414122298e-316*x0[67] + 2.4994837840657934e-316*x0[68] - 4.0770884884718522e-315*x0[69] - 0.2783271035183808*x0[70] + 1.5368160922977478e-315*x0[71] + 2.0977766603978018e-315*x0[72] + 2.3060864213369955e-315*x0[73] + 0.018983752404814782*x0[74] - 0.43193442360187473*x0[75] - 1.9125780601476035e-315*x0[76] - 0.13799670650220675*x0[77] - 0.19566167881320362*x0[78] - 8.4932861265626474e-316*x0[79] - 0.013346309729279245*x0[80] + 8.5856956214885838e-316*x0[81] + 2.6054365867129042e-315*x0[82] - 0.076603183769396746*x0[83] - 0.071055304349414108*x0[84] - 0.27977385199162547*x0[85] + 0.19333446421179093*x0[86] - 0.048459511565573786*x0[87] - 0.25558424069998859*x0[88] + 1.2907460056946108e-317*x0[89] - 0.17475486019316858*x0[90] + 1.8774958963674459e-317*x0[91] + 0.0015052131610918183*x0[92] + 1.9473596442701441e-316*x0[93] - 4.2153414700605176e-315*x0[94] - 0.039126978360831087*x0[95] + 1.7899638125565979e-315*x0[96] - 2.5694267356321764e-315*x0[97] + 3.6572081777968207e-315*x0[98] + 1.6897100917188612e-316*x0[99] - 0.14764627247712095*x0[100] + 7.5405881360554677e-316*x0[101] - 5.7537916251940078e-316*x0[102] + 8.4708665144987925e-316*x0[103] + 0.28520987698812517*x0[104] - 0.12542070500059005*x0[105] + 3.409015081232191e-315*x0[106] - 0.094762777368625858*x0[107] + 0.064653191299968771*x0[108] + 1.2805131453081439e-315*x0[109] + 0.015209825988026282*x0[110] + 2.9259502318920552e-316*x0[111] + 1.908628030012385e-315*x0[112] + 0.053647611251371359*x0[113] + 0.010808929927513897*x0[114] + 0.038948886321826352*x0[115] + 0.36430002350799179*x0[116] + 3.7820614814882142e-315*x0[117] + 0.61296850883123377*x0[118] - 1.7567039456825919e-315*x0[119] + 0.10695575937244212*x0[120] - 0.10554113556581278*x0[121] + 1.3798716933054632e-316*x0[122] - 1.802332158062115e-316*x0[123] + 3.2075051803613056e-315*x0[124] - 1.0227909700475788e-315*x0[125] + 0.33863444771783069*x0[126] - 1.6709153948326354e-315*x0[127] - 1.6143598189289429e-315*x0[128] - 3.7092587989131988e-315*x0[129] + 0.096805226339999162*x0[130] + 0.48504174806844164*x0[131] - 1.4580415246263507e-315*x0[132] + 0.0011772511625272662*x0[133] - 0.037007183409264663*x0[134] - 3.3352348700142528e-315*x0[135] + 0.1205532173469151*x0[136] + 3.0450083728279279e-315*x0[137] - 1.5014191000067473e-315*x0[138] - 0.69259834287174615*x0[139] + 0.041320449548341132*x0[140] - 0.070957616216232242*x0[141] + 0.063185075349207628*x0[142] + 4.9563393371755812e-316*x0[143] - 0.050658360039429827*x0[144] + 4.1377524919568199e-315*x0[145] + 0.098648830495825443*x0[146] + 0.13242844399131659*x0[147] + 2.5023682578819696e-315*x0[148] + 1.7000447345690278e-315*x0[149] + 1.6814783009518371e-315*x0[150] + 1.7738722130473035e-315*x0[151] + 0.18236380775781763*x0[152] + 2.21646259697938e-315*x0[153] + 4.0543462317786371e-315*x0[154] - 2.6462504851009693e-315*x0[155] - 0.14451170860920068*x0[156] - 0.11302716052166858*x0[157] - 1.3716118247877859e-315*x0[158] + 0.00066584555912307909*x0[159] - 0.11567715703788534*x0[160] + 2.2738195819452222e-315*x0[161] - 0.084196711548529229*x0[162] - 2.2167083847568731e-315*x0[163] + 3.9556990296168871e-315*x0[164] + 0.37774465022948578*x0[165] + 0.084254280687681746*x0[166] - 0.12817754182139912*x0[167] + 0.32337465577474384*x0[168] + 5.9172336791210089e-316*x0[169] + 0.36554774683102692*x0[170] + 3.2054214288560314e-316*x0[171] + 0.088448308020802072*x0[172] + 0.021965416711745293*x0[173] - 9.9632415995793785e-316*x0[174] - 4.4738236121568592e-316*x0[175] + 4.0951418349158368e-315*x0[176] - 3.3516631653798751e-315*x0[177] + 0.18779371968875808*x0[178] + 2.6738792980643773e-315*x0[179] + 3.2982673912548168e-315*x0[180] + 2.4235259192259325e-315*x0[181] + 0.067185207548842843*x0[182] + 0.23966065543676532*x0[183] - 4.0529190095255261e-316*x0[184] - 0.028358904975152147*x0[185] - 0.086523469356962007*x0[186] - 1.4715754105156589e-315*x0[187] + 0.31083280761910809*x0[188] - 2.8703240329934418e-315*x0[189] + 1.5243907414980136e-315*x0[190] + 0.25653856267672209*x0[191] + 0.26294174453199454*x0[192] - 0.43899771783012131*x0[193] - 0.070618834633514649); +x1[5] = relu(-0.16717114640072983*x0[0] - 0.007949960636605715*x0[1] - 0.064905776631083587*x0[2] - 0.031199079374833141*x0[3] + 0.68067386867708612*x0[4] + 0.32442234330631198*x0[5] - 0.0034045797250766966*x0[6] + 0.065984826317643575*x0[7] + 0.21691883969825215*x0[8] - 0.28556043583542384*x0[9] - 0.20006045069426742*x0[10] - 1.3167725785905249e-315*x0[11] - 0.20538438566650052*x0[12] - 0.0019847912161448694*x0[13] - 3.6359741058941006e-315*x0[14] - 5.9570741446703553e-316*x0[15] + 3.9973540154791195e-316*x0[16] - 1.5363701684084373e-315*x0[17] - 1.9826864811016678*x0[18] + 0.26870482252495331*x0[19] - 1.6375657068242154e-315*x0[20] - 2.0243475717530501e-316*x0[21] + 0.52784832032104889*x0[22] - 0.34429778704252201*x0[23] + 1.880569755426986e-315*x0[24] + 0.20709895071839068*x0[25] + 0.02708587741480116*x0[26] + 8.7381351299220878e-316*x0[27] - 0.32327571640141722*x0[28] - 3.7791660690586391e-315*x0[29] + 4.3753451136505382e-316*x0[30] - 0.14265651686298086*x0[31] + 0.12992469622990621*x0[32] - 2.2604606051758547e-316*x0[33] - 0.15044077939785772*x0[34] - 3.5884272587481435e-315*x0[35] - 0.059933123332877196*x0[36] + 6.7420389234901444e-316*x0[37] + 0.21034087461419274*x0[38] - 0.19087419273763842*x0[39] + 6.2115060452965325e-316*x0[40] + 1.2820803857652863e-315*x0[41] - 3.7299849318067424e-315*x0[42] - 2.8946843596174434e-315*x0[43] + 0.10811980567574854*x0[44] + 0.15478280237524811*x0[45] + 2.9771798937686776e-315*x0[46] - 1.4709226658063428e-315*x0[47] + 0.077464425731614925*x0[48] + 0.10800872892810255*x0[49] - 5.478768896492057e-316*x0[50] + 0.72517759666491499*x0[51] + 0.076384661504528467*x0[52] + 4.1010602621093385e-315*x0[53] - 0.02154912400259227*x0[54] - 4.1011467433599865e-315*x0[55] + 3.8183524509807692e-316*x0[56] + 0.21109542508873558*x0[57] + 0.14070248205262942*x0[58] + 0.24989567202116389*x0[59] + 0.52420500481868837*x0[60] - 3.6661512353489108e-315*x0[61] - 0.0021651132137535355*x0[62] - 3.3450036693615503e-315*x0[63] + 0.17386645596651459*x0[64] - 0.28403008576037014*x0[65] - 2.0247213521767548e-315*x0[66] - 6.1333864604518272e-316*x0[67] - 2.0125188496865773e-316*x0[68] - 1.1767491028786745e-315*x0[69] + 0.3041930056329098*x0[70] - 2.2158470801164781e-315*x0[71] + 5.7578183096141785e-316*x0[72] - 1.9000927989476545e-315*x0[73] - 0.18524793100626746*x0[74] - 0.23882893612279385*x0[75] - 4.1194117228233672e-315*x0[76] + 0.1139797320463917*x0[77] - 0.057203465868416903*x0[78] + 3.4882776573046113e-315*x0[79] - 0.003461601421414186*x0[80] + 2.2518040809950702e-316*x0[81] + 2.7000579048408297e-315*x0[82] + 0.49301282275764324*x0[83] + 0.010469169748950567*x0[84] + 0.77033772040323145*x0[85] - 0.14163076892936569*x0[86] - 0.029479150826341369*x0[87] + 0.21002840838771161*x0[88] + 4.0786431055517434e-315*x0[89] + 0.27815667662828503*x0[90] + 2.9780799627996453e-315*x0[91] - 0.14006653898660271*x0[92] - 2.803907316873244e-315*x0[93] - 2.9658951132749937e-315*x0[94] + 0.063988361460310145*x0[95] + 9.5535691841537295e-316*x0[96] - 4.3586658526994544e-316*x0[97] - 4.0074237502112989e-315*x0[98] + 2.7355482014290473e-316*x0[99] + 0.04134431237743743*x0[100] + 2.0196673669404993e-315*x0[101] + 5.94897745121353e-315*x0[102] - 1.9159367332300016e-315*x0[103] - 0.14203659245910352*x0[104] - 0.067226219060040296*x0[105] + 1.7053521903035692e-315*x0[106] - 0.074613475229399234*x0[107] + 0.33177602657825928*x0[108] + 2.4013114580402002e-315*x0[109] - 0.031072602514243389*x0[110] + 1.1922472406154973e-315*x0[111] - 1.5611164838182524e-315*x0[112] - 0.014008329760831649*x0[113] + 0.19126426343002889*x0[114] + 0.11081166617323193*x0[115] - 0.51042540525082203*x0[116] - 1.5949361468316224e-316*x0[117] + 1.1695971083552565*x0[118] + 7.5153273994952027e-317*x0[119] + 0.32746441176367491*x0[120] - 0.15966502821487008*x0[121] + 6.3445439910703675e-317*x0[122] + 3.8976887910541136e-315*x0[123] - 3.6921473589790718e-315*x0[124] + 2.176876609822237e-315*x0[125] - 0.096825508641554647*x0[126] - 2.6589407539000036e-316*x0[127] - 2.4168456230439178e-317*x0[128] - 3.737835669503755e-315*x0[129] + 0.20865023549350073*x0[130] + 0.11650022308677545*x0[131] + 2.4569876613228293e-315*x0[132] - 0.25362928012677327*x0[133] + 0.34068684883982592*x0[134] + 5.5534042809957254e-316*x0[135] + 0.23589858035068126*x0[136] + 2.1088192400305814e-315*x0[137] - 1.6874883279160777e-316*x0[138] - 0.71751787649165522*x0[139] - 0.43069213124142985*x0[140] + 0.16256066432026786*x0[141] + 0.1375797273509165*x0[142] + 4.1289593635656168e-315*x0[143] - 0.037611003587611311*x0[144] + 3.3372456924895444e-315*x0[145] + 0.031673841352621392*x0[146] - 0.11023775602318772*x0[147] + 2.9433693067412217e-316*x0[148] + 1.8990334431524676e-315*x0[149] + 1.1960902413098572e-316*x0[150] - 1.0970590809720981e-315*x0[151] - 0.064130557015421571*x0[152] - 4.3867255205499746e-316*x0[153] - 4.3662225324053752e-315*x0[154] - 2.8533699628488281e-315*x0[155] - 0.036772921712738486*x0[156] - 0.090099526655038037*x0[157] - 3.9715739171119462e-316*x0[158] + 0.26933971465821405*x0[159] + 0.17432955784407017*x0[160] + 2.9294467295270172e-315*x0[161] + 0.25954176755722386*x0[162] + 4.0754867029447526e-315*x0[163] - 3.9418850480316386e-315*x0[164] + 0.067607215576391072*x0[165] + 0.30525540840964466*x0[166] + 0.14098452794148472*x0[167] - 0.21714058122593197*x0[168] + 2.3274414899163821e-315*x0[169] - 0.071235777550534354*x0[170] - 2.4782108983659361e-316*x0[171] + 0.056250939662495315*x0[172] + 0.1534159567636921*x0[173] - 1.452828178516029e-315*x0[174] - 3.3245017236954636e-315*x0[175] + 3.3048865962197232e-315*x0[176] + 1.0311470529091273e-315*x0[177] - 0.042782688893969086*x0[178] + 5.0284196117852169e-316*x0[179] + 4.0258646170445991e-316*x0[180] + 8.0998576508475315e-316*x0[181] - 0.11383096747551751*x0[182] + 0.014377679274348224*x0[183] - 2.6666864828846492e-315*x0[184] + 0.42706007827524761*x0[185] + 0.187149416143785*x0[186] - 5.1779540142211745e-316*x0[187] + 0.5941774462107231*x0[188] + 1.7644745854571007e-315*x0[189] - 2.3634029423264433e-315*x0[190] + 0.22977018719465958*x0[191] - 0.20934940657240156*x0[192] - 0.46417282247016528*x0[193] - 0.1188213231064944); +x1[6] = relu(-0.52961640659221032*x0[0] - 0.048160978950549174*x0[1] - 0.45227293534588536*x0[2] + 0.15003172580478993*x0[3] + 0.73303603182434052*x0[4] - 0.90475924852883549*x0[5] - 0.060751572506808051*x0[6] + 0.11543051187536128*x0[7] + 0.044434270797200554*x0[8] - 0.14324216893504368*x0[9] - 0.10085456994561662*x0[10] + 6.8435399179914638e-317*x0[11] - 0.053354489514237276*x0[12] - 0.051214243743708338*x0[13] - 4.335497074074841e-315*x0[14] + 3.5862801976710112e-315*x0[15] - 2.7807040178819557e-315*x0[16] - 3.7623426891586634e-315*x0[17] - 0.30973458384322738*x0[18] - 0.18685973343128434*x0[19] + 8.63858525006276e-316*x0[20] - 2.43516987556283e-315*x0[21] - 0.11993394885893773*x0[22] - 0.28570955299908812*x0[23] - 2.853782576832296e-315*x0[24] - 0.042271989931022887*x0[25] + 0.21161963741995701*x0[26] - 4.8037135165870304e-316*x0[27] - 0.29278317642923979*x0[28] - 2.5763546377532609e-315*x0[29] - 7.534933159486298e-316*x0[30] - 0.43948180136853371*x0[31] - 0.29170335274604992*x0[32] + 2.3834174378856865e-316*x0[33] + 0.051958043481722629*x0[34] + 4.5527801985528407e-315*x0[35] + 0.035417737841325125*x0[36] - 2.2620068231397666e-315*x0[37] + 0.041358506221841389*x0[38] + 0.053426040939789525*x0[39] - 2.4349117756694426e-316*x0[40] + 3.2613552923136231e-316*x0[41] + 3.8734613730294998e-316*x0[42] + 4.544927983599547e-315*x0[43] - 0.020133611456257611*x0[44] + 0.044316713912594043*x0[45] - 4.3648158830457571e-316*x0[46] - 7.0559873551981665e-316*x0[47] + 0.33852971883970906*x0[48] + 0.16990426327847671*x0[49] - 1.2364515162784543e-315*x0[50] + 0.91036497626006063*x0[51] - 0.27008163429894883*x0[52] - 1.0659777817414597e-315*x0[53] + 0.087683901233774161*x0[54] + 2.731512080355041e-315*x0[55] + 3.9625378319394006e-315*x0[56] - 0.014541996662172938*x0[57] - 0.070963325317466616*x0[58] + 0.046870078148176328*x0[59] - 0.14635770935574757*x0[60] + 4.2682317755046287e-315*x0[61] + 0.32408091810746353*x0[62] + 1.4422833650807781e-315*x0[63] + 0.43381579623388838*x0[64] + 0.12864977253651272*x0[65] + 7.4805153364629701e-316*x0[66] - 7.2028051870870305e-317*x0[67] + 1.6648088867290749e-316*x0[68] - 3.6006324835400296e-315*x0[69] - 0.19511254497251701*x0[70] + 2.606135640195205e-315*x0[71] - 9.4814467657445035e-316*x0[72] - 2.1752605803825678e-315*x0[73] + 0.20178067917146097*x0[74] + 0.041303736073661383*x0[75] - 1.1717310115115893e-315*x0[76] + 0.21539197317516207*x0[77] + 0.2573086592279949*x0[78] + 4.059293133226813e-315*x0[79] + 0.048565449247707573*x0[80] - 1.2797877630675763e-315*x0[81] - 9.7345068931050025e-316*x0[82] - 0.6611501724184804*x0[83] - 0.064575996883229458*x0[84] + 0.19251430414190587*x0[85] - 0.45834891419187151*x0[86] + 0.056392078596971915*x0[87] + 0.4283387498685477*x0[88] + 5.4771045869574762e-316*x0[89] - 0.29125103935310898*x0[90] + 3.0592322115103405e-315*x0[91] + 0.31636494759825218*x0[92] + 4.2424762223187407e-315*x0[93] - 3.1766895204658101e-315*x0[94] + 0.23133756408694825*x0[95] - 2.8327034834413634e-315*x0[96] - 1.6172595198483239e-315*x0[97] - 8.4342388590312225e-316*x0[98] - 1.6889531880900889e-315*x0[99] + 0.0087190692971789718*x0[100] + 8.1131920873762701e-316*x0[101] - 8.8073658809193342e-317*x0[102] - 1.0224952322332912e-315*x0[103] + 0.16455498018153311*x0[104] + 0.081402830486836414*x0[105] + 1.045831652272195e-315*x0[106] + 0.24626306214691571*x0[107] + 0.052276752784560572*x0[108] - 1.3824083449069672e-315*x0[109] + 0.047391651405295651*x0[110] - 4.1411395688731975e-316*x0[111] - 3.4823180447988723e-315*x0[112] - 0.29978006136648178*x0[113] + 0.00076377212090853169*x0[114] - 0.1769792415234642*x0[115] + 0.099162117786272763*x0[116] + 1.418629127433874e-315*x0[117] + 0.49600070421549697*x0[118] + 2.292186897225826e-315*x0[119] + 0.11668720589699488*x0[120] - 0.23778939903906635*x0[121] + 3.6101571354077782e-315*x0[122] - 9.4583050767392516e-316*x0[123] + 3.9596766681403952e-316*x0[124] - 2.5819002183071285e-315*x0[125] + 0.14710153695066577*x0[126] - 5.8592581881951074e-316*x0[127] - 1.7807903771345085e-315*x0[128] + 1.2787831349239792e-315*x0[129] + 0.27684354617308293*x0[130] - 0.014064305328575636*x0[131] + 6.4816047181457711e-316*x0[132] + 0.09142602855113259*x0[133] - 0.13672663466058155*x0[134] + 1.642997355840152e-315*x0[135] + 0.082547994871276786*x0[136] - 1.9073994764961232e-315*x0[137] + 4.0480363958991871e-315*x0[138] + 0.033541090468917255*x0[139] + 0.011580555978234123*x0[140] - 0.044520987456319841*x0[141] - 0.037164204167237869*x0[142] + 3.2005845755898101e-316*x0[143] + 0.25365320133762181*x0[144] - 4.4814408692516167e-316*x0[145] + 0.10969003284045062*x0[146] + 0.25878617471612286*x0[147] + 2.5237753120486117e-316*x0[148] + 1.775063558479777e-315*x0[149] + 2.9118959170140436e-315*x0[150] - 3.0184465934398433e-315*x0[151] - 0.23640983096990317*x0[152] - 2.5825515796326362e-315*x0[153] + 3.0185208712690391e-315*x0[154] - 3.0365076522485595e-315*x0[155] + 0.23886913163252882*x0[156] - 0.10122102720833487*x0[157] - 2.0077609579918744e-315*x0[158] - 0.035256687222849213*x0[159] - 0.18003495800939959*x0[160] + 4.2752409415431411e-317*x0[161] - 0.10146229159714817*x0[162] - 3.6402149825937129e-315*x0[163] - 3.5679906186791241e-315*x0[164] - 0.15198092851265144*x0[165] + 0.13806602257017284*x0[166] + 0.13748663222360213*x0[167] - 0.065971238484927405*x0[168] + 3.0352125085645512e-315*x0[169] + 0.47474210974475056*x0[170] - 8.7985234892425842e-316*x0[171] + 0.19428098592836965*x0[172] + 0.10951855508268227*x0[173] + 7.8071007322274967e-316*x0[174] - 3.2758540142994124e-315*x0[175] + 8.598809605926148e-316*x0[176] + 1.2591544552275733e-315*x0[177] - 0.21603411724549237*x0[178] + 3.6944933210039069e-315*x0[179] - 2.8459034550639298e-315*x0[180] - 1.4230729959447366e-315*x0[181] + 0.21803233578264242*x0[182] - 0.24660867016782678*x0[183] - 4.2992949968732858e-315*x0[184] + 0.03445561409915953*x0[185] + 0.0028214227275506153*x0[186] - 2.0260116540174338e-315*x0[187] + 0.18046074315118898*x0[188] + 3.3234102783365792e-315*x0[189] - 1.3206933007516321e-315*x0[190] - 0.16548524953530638*x0[191] + 0.0059435295114410782*x0[192] - 0.02652285208533306*x0[193] + 0.23082926795040631); +x1[7] = relu(0.30938391165620471*x0[0] - 0.3333728555633616*x0[1] - 0.025466510136994067*x0[2] + 0.011650889902767504*x0[3] + 0.38241633052508833*x0[4] - 0.079826901542893916*x0[5] + 0.16195256100390265*x0[6] - 0.22966079168903025*x0[7] - 0.21412582355055121*x0[8] - 0.11532918094806016*x0[9] + 0.076124009452366498*x0[10] - 2.1253785418428549e-315*x0[11] - 0.20754855326863678*x0[12] - 0.072194760520443102*x0[13] - 3.5104019070440694e-315*x0[14] + 1.7614800338150311e-315*x0[15] + 2.0471841356967433e-315*x0[16] + 2.1465029114095724e-315*x0[17] - 0.2060911012875607*x0[18] - 0.099821750242749349*x0[19] - 4.0321798382395888e-315*x0[20] + 3.676654621379758e-316*x0[21] + 0.24557471198621683*x0[22] + 0.27805483693082339*x0[23] + 2.0872916338463541e-315*x0[24] - 0.10248448198783068*x0[25] + 0.015910958040345605*x0[26] - 4.0376424898748019e-315*x0[27] + 0.17106973452277319*x0[28] + 3.4063240341163616e-316*x0[29] + 3.810993150500362e-315*x0[30] - 0.1623108100903301*x0[31] - 0.11591190930630899*x0[32] + 1.1269088178266917e-315*x0[33] + 0.43934545615037884*x0[34] - 3.9786557058597409e-316*x0[35] + 0.30027577069940231*x0[36] + 4.0435211546651263e-315*x0[37] - 0.32827786831877748*x0[38] + 0.41092578545480091*x0[39] + 1.0971910261434765e-315*x0[40] + 9.1813882485708393e-316*x0[41] - 1.5539985591091209e-315*x0[42] + 7.4107891858426388e-316*x0[43] - 0.47071429996190112*x0[44] - 0.050763330933048488*x0[45] - 1.9160939449185083e-315*x0[46] - 2.5229167247692688e-316*x0[47] + 0.26154907996020899*x0[48] - 0.047644439028611263*x0[49] - 1.471757933187202e-315*x0[50] - 0.26676616050772339*x0[51] + 0.10046102373464115*x0[52] - 2.772640278603708e-315*x0[53] - 0.30171061514082304*x0[54] + 4.0965303323036267e-316*x0[55] - 7.1740614359432785e-316*x0[56] + 0.50067855116843074*x0[57] + 0.490480954231932*x0[58] - 0.15662600743466751*x0[59] - 0.17651552456318556*x0[60] + 2.8384899852261125e-315*x0[61] + 0.21465629635307329*x0[62] + 5.9773136426653712e-316*x0[63] - 0.27040339237182598*x0[64] - 0.0062455143638680396*x0[65] - 3.0414090502507534e-315*x0[66] - 9.1106791049415422e-316*x0[67] + 3.812019171686424e-316*x0[68] - 4.1071961621781701e-315*x0[69] - 0.093206884461823444*x0[70] - 2.0467387256357045e-316*x0[71] + 2.4530934210803392e-315*x0[72] - 2.0799737410077248e-315*x0[73] - 0.024412450120934199*x0[74] - 0.17076431597246722*x0[75] + 1.9752735232298895e-315*x0[76] + 0.32992875321458021*x0[77] - 0.012159794503352229*x0[78] + 2.3707467340862276e-315*x0[79] - 0.10872657683715831*x0[80] + 2.4608941692153056e-315*x0[81] + 3.0738318859295446e-315*x0[82] + 0.63446532185378157*x0[83] + 0.44929857095342501*x0[84] - 0.33227882776710949*x0[85] - 0.13780867172142511*x0[86] - 0.0014423761508124662*x0[87] - 0.060351657167083378*x0[88] - 4.0942676944499628e-315*x0[89] + 0.080145921113021434*x0[90] - 5.1456210243800795e-316*x0[91] - 0.051518171352211248*x0[92] - 4.2456055896535911e-315*x0[93] - 2.5173373155406304e-315*x0[94] + 0.11596706268078506*x0[95] - 7.9420773421890482e-316*x0[96] - 1.0476042906402829e-315*x0[97] + 3.0377725047678212e-316*x0[98] - 7.6285509907622682e-316*x0[99] + 0.16019821597894043*x0[100] - 2.5097190406706426e-315*x0[101] + 1.2185084848118731e-315*x0[102] - 1.6052712096375879e-315*x0[103] - 0.1804087490065156*x0[104] + 0.40667979687612404*x0[105] - 1.9751341374298848e-317*x0[106] - 0.076593696209061937*x0[107] - 0.15367066121766462*x0[108] - 1.2067871232102417e-315*x0[109] - 0.27565497094922847*x0[110] + 1.0351143160540727e-315*x0[111] - 4.2767466065988423e-316*x0[112] - 0.15466148483771491*x0[113] - 0.21081184739521713*x0[114] - 0.15149267325508775*x0[115] - 0.21718880079568892*x0[116] + 3.0896649606489961e-316*x0[117] - 0.53512708138901144*x0[118] + 7.7690774401235544e-316*x0[119] - 0.25045784145952554*x0[120] - 0.05958573956146871*x0[121] + 8.8847554343657445e-316*x0[122] - 2.1362366126601951e-315*x0[123] + 1.0948500640629774e-316*x0[124] + 1.0758256365327483e-315*x0[125] + 0.12412434523520838*x0[126] + 1.1661231885676587e-315*x0[127] + 3.77331653931945e-316*x0[128] - 3.8695415698304939e-315*x0[129] - 0.80324978102598132*x0[130] - 0.25007909005960444*x0[131] + 4.5585790915039876e-316*x0[132] + 0.1481057194320165*x0[133] + 0.30171367579796582*x0[134] + 9.8732808916204897e-316*x0[135] - 0.28685057286812721*x0[136] - 1.4017868149383497e-316*x0[137] - 1.5292856128930259e-315*x0[138] - 0.3971814501803359*x0[139] - 0.3825058736820397*x0[140] - 0.28039790336296216*x0[141] - 0.06216309643072522*x0[142] - 2.5508040279379244e-315*x0[143] - 0.34616478081064261*x0[144] + 9.1416968426268431e-316*x0[145] - 0.15193738947916954*x0[146] + 0.20883506634598475*x0[147] - 7.6013071735127256e-316*x0[148] - 1.1426281240498753e-315*x0[149] + 4.092387344830425e-316*x0[150] - 1.6889788893849855e-315*x0[151] + 0.092509415264150144*x0[152] - 4.3617701165588395e-316*x0[153] - 3.4859513590924807e-315*x0[154] - 3.0802208513628325e-315*x0[155] - 0.13854469614413173*x0[156] - 0.032544830801252221*x0[157] + 1.4613472437528276e-315*x0[158] - 0.29018106371466573*x0[159] + 0.064979479601049467*x0[160] + 2.7298030084729469e-316*x0[161] - 0.16835262523643138*x0[162] - 1.4523334656441917e-315*x0[163] + 3.4242228911735481e-315*x0[164] - 0.081801230930238875*x0[165] - 0.13628263414738462*x0[166] - 0.11246818971575034*x0[167] - 0.16030825798392886*x0[168] + 1.1701452287707585e-315*x0[169] - 0.13551451194163772*x0[170] - 5.7729588525178544e-316*x0[171] - 0.26302204101391263*x0[172] + 0.077432871374489745*x0[173] - 1.0298883366851869e-316*x0[174] - 9.2241709738542995e-316*x0[175] - 2.7634419126291295e-315*x0[176] - 2.0865189151762583e-316*x0[177] - 0.21883822879512743*x0[178] - 8.0797627164604888e-316*x0[179] - 3.3417840955210823e-315*x0[180] + 2.1873998078854824e-316*x0[181] - 0.054270822778704993*x0[182] + 0.43483179487044654*x0[183] - 2.279977136911311e-316*x0[184] - 0.10976128879025004*x0[185] + 0.19952434612556394*x0[186] - 2.5380562350757448e-315*x0[187] - 0.11064552230655147*x0[188] - 3.047560933343228e-316*x0[189] + 2.7509407622780103e-315*x0[190] - 0.16300029305281874*x0[191] - 0.24137601317965995*x0[192] + 0.42517087149683624*x0[193] + 0.33611230103047002); +x2[0] = relu(1.0775163903762899*x1[0] + 1.2526655885767919*x1[1] + 0.84103034302233592*x1[2] - 0.24213771763017547*x1[3] - 0.78403252947602797*x1[4] - 0.25235987805872345*x1[5] + 1.7847751957290761*x1[6] - 0.17527062652259554*x1[7] - 0.20910091583093351); +x2[1] = relu(-0.66355509924248246*x1[0] + 0.0031463822876507388*x1[1] - 0.055220933579297964*x1[2] + 0.61928702341000297*x1[3] - 0.0044464852685363781*x1[4] - 0.58230594205362085*x1[5] - 0.020741684756642901*x1[6] + 0.12824345610905036*x1[7] - 1.157831519133913); +x2[2] = relu(1.725365529563553*x1[0] + 0.71711925939746302*x1[1] + 0.70333306248182104*x1[2] - 1.2528126077681954*x1[3] + 0.20569298681374204*x1[4] + 0.6189973995756074*x1[5] + 0.8851499952711479*x1[6] + 0.04436020274688271*x1[7] + 0.32419133672011513); +x2[3] = relu(-2.0168338709662303*x1[0] - 0.44446369276548414*x1[1] - 0.86534406873688952*x1[2] + 0.74829139557469804*x1[3] + 0.51733881106813007*x1[4] - 1.1231437261962736*x1[5] - 0.60532606299384129*x1[6] + 1.2365183058922629*x1[7] + 1.3287285128435076); +x3_result[0] = sigmoid(-2.1735138393910116*x2[0] - 1.28498639108018*x2[1] - 2.1290318940128778*x2[2] + 3.2084714143673381*x2[3] + 0.61074724196189267); return x3_result[0]; } diff --git a/test/dreal/util/test/pattern_matching_heuristic_test.cc b/test/dreal/util/test/pattern_matching_heuristic_test.cc index 41d47cf40..85bebb2b1 100644 --- a/test/dreal/util/test/pattern_matching_heuristic_test.cc +++ b/test/dreal/util/test/pattern_matching_heuristic_test.cc @@ -1,5 +1,5 @@ -// This file was automatically generated on 2025-04-14 01:50:25.358983 by Kunal in the `WORTH_IT_regression` python notebook. +// This file was automatically generated on 2025-04-17 00:30:24.185915 by Kunal in the `WORTH_IT_regression` python notebook. #include @@ -20,33 +20,33 @@ namespace dreal float expected_value = -1E9; float calculated_value = -1E9; -k.assertions_size = 2486; +k.assertions_size = 1842; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1142; -k.assertions_stats.conjunction_cntr = 2486; -k.assertions_stats.constant_cntr = 1881; +k.assertions_stats.addition_cntr = 1071; +k.assertions_stats.conjunction_cntr = 1842; +k.assertions_stats.constant_cntr = 1487; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1465; +k.assertions_stats.equalto_cntr = 1474; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 1021; +k.assertions_stats.inequality_cntr = 368; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 584; -k.assertions_stats.negation_cntr = 581; +k.assertions_stats.multiplication_cntr = 1022; +k.assertions_stats.negation_cntr = 2; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 58; +k.assertions_stats.pow_cntr = 54; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1301; -k.assertions_stats.variable_cntr = 4424; +k.assertions_stats.unique_variables = 1445; +k.assertions_stats.variable_cntr = 4029; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -99,36 +99,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 6784; -k.box_continuous_count = 1301; +k.box_boolean_count = 2543; +k.box_continuous_count = 1445; k.box_integer_count = 0; k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -144,10 +118,10 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.pow_cntr = 1; +k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; @@ -223,7 +197,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -233,43 +207,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.763136; -expected_value = 0.9175118461376377; +k.theory_checksat_ms = 0.107759; +expected_value = 0.6738802735922182; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 2289: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12566: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 696; +k.assertions_size = 1289; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 342; -k.assertions_stats.conjunction_cntr = 696; -k.assertions_stats.constant_cntr = 521; +k.assertions_stats.addition_cntr = 582; +k.assertions_stats.conjunction_cntr = 1289; +k.assertions_stats.constant_cntr = 985; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 465; +k.assertions_stats.equalto_cntr = 751; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 231; +k.assertions_stats.inequality_cntr = 538; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 214; -k.assertions_stats.negation_cntr = 125; +k.assertions_stats.multiplication_cntr = 304; +k.assertions_stats.negation_cntr = 299; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 18; +k.assertions_stats.pow_cntr = 30; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 421; -k.assertions_stats.variable_cntr = 1324; +k.assertions_stats.unique_variables = 671; +k.assertions_stats.variable_cntr = 2282; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -281,7 +255,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -318,36 +292,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 1334; -k.box_continuous_count = 421; +k.box_boolean_count = 3529; +k.box_continuous_count = 671; k.box_integer_count = 0; -k.lemma_size = 4; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 4; -k.lemma_stats.constant_cntr = 4; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 4; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 4; +k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -363,8 +311,8 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -372,8 +320,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.middle_assertion_stats.variable_cntr = 2; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -390,7 +338,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -452,39 +400,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0700951; -expected_value = 0.507457976074427; +k.theory_checksat_ms = 0.415049; +expected_value = 0.5839398141388688; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 17145: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16202: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 382; +k.assertions_size = 1353; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 200; -k.assertions_stats.conjunction_cntr = 382; -k.assertions_stats.constant_cntr = 260; +k.assertions_stats.addition_cntr = 582; +k.assertions_stats.conjunction_cntr = 1353; +k.assertions_stats.constant_cntr = 1033; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 298; +k.assertions_stats.equalto_cntr = 783; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 84; +k.assertions_stats.inequality_cntr = 570; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 133; -k.assertions_stats.negation_cntr = 63; +k.assertions_stats.multiplication_cntr = 352; +k.assertions_stats.negation_cntr = 342; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 18; +k.assertions_stats.pow_cntr = 30; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 253; -k.assertions_stats.variable_cntr = 799; +k.assertions_stats.unique_variables = 703; +k.assertions_stats.variable_cntr = 2426; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -537,40 +485,14 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 1541; -k.box_continuous_count = 253; +k.box_boolean_count = 3753; +k.box_continuous_count = 703; k.box_integer_count = 0; -k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; k.middle_assertion_stats.equalto_cntr = 1; @@ -582,7 +504,7 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; @@ -609,7 +531,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -671,39 +593,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 1.78806; -expected_value = 0.6806496148601098; +k.theory_checksat_ms = 0.235593; +expected_value = 0.9774965944972224; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 15726: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12440: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 816; +k.assertions_size = 1353; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 342; -k.assertions_stats.conjunction_cntr = 816; -k.assertions_stats.constant_cntr = 631; +k.assertions_stats.addition_cntr = 582; +k.assertions_stats.conjunction_cntr = 1353; +k.assertions_stats.constant_cntr = 1033; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 465; +k.assertions_stats.equalto_cntr = 783; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 351; +k.assertions_stats.inequality_cntr = 570; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 214; -k.assertions_stats.negation_cntr = 206; +k.assertions_stats.multiplication_cntr = 352; +k.assertions_stats.negation_cntr = 328; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 18; +k.assertions_stats.pow_cntr = 30; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 421; -k.assertions_stats.variable_cntr = 1454; +k.assertions_stats.unique_variables = 703; +k.assertions_stats.variable_cntr = 2426; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -736,12 +658,12 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -756,36 +678,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 2274; -k.box_continuous_count = 421; +k.box_boolean_count = 3753; +k.box_continuous_count = 703; k.box_integer_count = 0; -k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; +k.lemma_size = 4; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -828,7 +724,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -890,39 +786,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.188381; -expected_value = 0.5545806328948858; +k.theory_checksat_ms = 0.340995; +expected_value = 0.6999352113885261; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 16851: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12453: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 776; +k.assertions_size = 2144; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 342; -k.assertions_stats.conjunction_cntr = 776; -k.assertions_stats.constant_cntr = 601; +k.assertions_stats.addition_cntr = 982; +k.assertions_stats.conjunction_cntr = 2144; +k.assertions_stats.constant_cntr = 1625; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 445; +k.assertions_stats.equalto_cntr = 1261; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 331; +k.assertions_stats.inequality_cntr = 883; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 184; -k.assertions_stats.negation_cntr = 178; +k.assertions_stats.multiplication_cntr = 504; +k.assertions_stats.negation_cntr = 497; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 18; +k.assertions_stats.pow_cntr = 50; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 401; -k.assertions_stats.variable_cntr = 1364; +k.assertions_stats.unique_variables = 1121; +k.assertions_stats.variable_cntr = 3812; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -975,53 +871,27 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 2134; -k.box_continuous_count = 401; +k.box_boolean_count = 5854; +k.box_continuous_count = 1121; k.box_integer_count = 0; k.lemma_size = 2; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 2; -k.lemma_stats.constant_cntr = 2; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 2; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -1029,8 +899,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.middle_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -1109,39 +979,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0537551; -expected_value = 0.8756637580116956; +k.theory_checksat_ms = 0.264373; +expected_value = 0.9631663725396985; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 3043: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1668: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2069; +k.assertions_size = 1129; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 902; -k.assertions_stats.conjunction_cntr = 2069; -k.assertions_stats.constant_cntr = 1569; +k.assertions_stats.addition_cntr = 582; +k.assertions_stats.conjunction_cntr = 1129; +k.assertions_stats.constant_cntr = 825; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1207; +k.assertions_stats.equalto_cntr = 751; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 862; +k.assertions_stats.inequality_cntr = 378; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 536; -k.assertions_stats.negation_cntr = 536; +k.assertions_stats.multiplication_cntr = 304; +k.assertions_stats.negation_cntr = 207; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 46; +k.assertions_stats.pow_cntr = 30; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1079; -k.assertions_stats.variable_cntr = 3722; +k.assertions_stats.unique_variables = 671; +k.assertions_stats.variable_cntr = 2122; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -1194,53 +1064,27 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 5725; -k.box_continuous_count = 1079; +k.box_boolean_count = 2249; +k.box_continuous_count = 671; k.box_integer_count = 0; -k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; +k.lemma_size = 4; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -1266,7 +1110,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -1282,17 +1126,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -1318,7 +1162,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -1328,39 +1172,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.213331; -expected_value = 0.8242458129848773; +k.theory_checksat_ms = 5.58421; +expected_value = 0.9996540006950871; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 15973: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1880: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 3128; +k.assertions_size = 2606; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1346; -k.assertions_stats.conjunction_cntr = 3128; -k.assertions_stats.constant_cntr = 2737; +k.assertions_stats.addition_cntr = 1142; +k.assertions_stats.conjunction_cntr = 2606; +k.assertions_stats.constant_cntr = 1971; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 2243; +k.assertions_stats.equalto_cntr = 1525; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 885; +k.assertions_stats.inequality_cntr = 1081; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 1512; -k.assertions_stats.negation_cntr = 786; +k.assertions_stats.multiplication_cntr = 674; +k.assertions_stats.negation_cntr = 854; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 76; +k.assertions_stats.pow_cntr = 58; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1923; -k.assertions_stats.variable_cntr = 6298; +k.assertions_stats.unique_variables = 1361; +k.assertions_stats.variable_cntr = 4694; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -1393,17 +1237,17 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; k.biggest_literal_stats.multiplication_cntr = 0; -k.biggest_literal_stats.negation_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; k.biggest_literal_stats.realconstant_cntr = 0; @@ -1413,40 +1257,14 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 5240; -k.box_continuous_count = 1923; +k.box_boolean_count = 7204; +k.box_continuous_count = 1361; k.box_integer_count = 0; -k.lemma_size = 2; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 2; -k.lemma_stats.constant_cntr = 2; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 2; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 2; +k.lemma_size = 4; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; k.middle_assertion_stats.equalto_cntr = 1; @@ -1458,8 +1276,8 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -1547,39 +1365,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.457984; -expected_value = 0.9982519332098194; +k.theory_checksat_ms = 58.0898; +expected_value = 0.9999973515962518; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 16757: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 13959: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2657; +k.assertions_size = 1428; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1222; -k.assertions_stats.conjunction_cntr = 2657; -k.assertions_stats.constant_cntr = 2009; +k.assertions_stats.addition_cntr = 829; +k.assertions_stats.conjunction_cntr = 1428; +k.assertions_stats.constant_cntr = 1155; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1567; +k.assertions_stats.equalto_cntr = 1142; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 1090; +k.assertions_stats.inequality_cntr = 286; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 624; -k.assertions_stats.negation_cntr = 619; +k.assertions_stats.multiplication_cntr = 794; +k.assertions_stats.negation_cntr = 13; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 62; +k.assertions_stats.pow_cntr = 42; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1391; -k.assertions_stats.variable_cntr = 4730; +k.assertions_stats.unique_variables = 1121; +k.assertions_stats.variable_cntr = 3123; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -1632,36 +1450,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 7249; -k.box_continuous_count = 1391; +k.box_boolean_count = 1969; +k.box_continuous_count = 1121; k.box_integer_count = 0; -k.lemma_size = 2; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 2; -k.lemma_stats.constant_cntr = 2; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 2; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 2; +k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -1704,7 +1496,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -1756,7 +1548,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -1766,45 +1558,45 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 46.3854; -expected_value = 0.9999999998130396; +k.theory_checksat_ms = 0.257526; +expected_value = 0.9836522668679262; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12760: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 2741: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1802; +k.assertions_size = 92; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 822; -k.assertions_stats.conjunction_cntr = 1802; -k.assertions_stats.constant_cntr = 1369; +k.assertions_stats.addition_cntr = 48; +k.assertions_stats.conjunction_cntr = 92; +k.assertions_stats.constant_cntr = 100; k.assertions_stats.disjunction_cntr = 0; -k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1057; +k.assertions_stats.division_cntr = 10; +k.assertions_stats.equalto_cntr = 53; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 745; +k.assertions_stats.inequality_cntr = 39; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 424; -k.assertions_stats.negation_cntr = 417; +k.assertions_stats.multiplication_cntr = 67; +k.assertions_stats.negation_cntr = 23; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 42; +k.assertions_stats.pow_cntr = 2; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.trigonometry_cntr = 0; +k.assertions_stats.trigonometry_cntr = 2; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 941; -k.assertions_stats.variable_cntr = 3200; +k.assertions_stats.unique_variables = 58; +k.assertions_stats.variable_cntr = 215; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 3; k.biggest_assertion_stats.disjunction_cntr = 0; -k.biggest_assertion_stats.division_cntr = 0; +k.biggest_assertion_stats.division_cntr = 1; k.biggest_assertion_stats.equalto_cntr = 1; k.biggest_assertion_stats.exp_cntr = 0; k.biggest_assertion_stats.false_cntr = 0; @@ -1814,7 +1606,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 3; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -1823,24 +1615,24 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_assertion_stats.unique_variables = 6; +k.biggest_assertion_stats.variable_cntr = 6; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; -k.biggest_literal_stats.multiplication_cntr = 0; +k.biggest_literal_stats.multiplication_cntr = 1; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; @@ -1849,54 +1641,28 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 4924; -k.box_continuous_count = 941; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 22; +k.box_continuous_count = 58; k.box_integer_count = 0; k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; @@ -1905,8 +1671,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.middle_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -1923,7 +1689,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -1985,39 +1751,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.68239; -expected_value = 0.951935337229555; +k.theory_checksat_ms = 0.159605; +expected_value = 0.9913100651196299; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 14833: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16595: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 600; +k.assertions_size = 2486; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 345; -k.assertions_stats.conjunction_cntr = 600; -k.assertions_stats.constant_cntr = 491; +k.assertions_stats.addition_cntr = 1142; +k.assertions_stats.conjunction_cntr = 2486; +k.assertions_stats.constant_cntr = 1881; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 478; +k.assertions_stats.equalto_cntr = 1465; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 122; +k.assertions_stats.inequality_cntr = 1021; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 338; -k.assertions_stats.negation_cntr = 3; +k.assertions_stats.multiplication_cntr = 584; +k.assertions_stats.negation_cntr = 788; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 18; +k.assertions_stats.pow_cntr = 58; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 473; -k.assertions_stats.variable_cntr = 1311; +k.assertions_stats.unique_variables = 1301; +k.assertions_stats.variable_cntr = 4424; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -2050,12 +1816,12 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -2070,36 +1836,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 821; -k.box_continuous_count = 473; +k.box_boolean_count = 6784; +k.box_continuous_count = 1301; k.box_integer_count = 0; -k.lemma_size = 4; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 4; -k.lemma_stats.constant_cntr = 4; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 4; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 4; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -2115,10 +1855,10 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 0; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.pow_cntr = 1; k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; @@ -2142,7 +1882,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -2158,17 +1898,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -2194,7 +1934,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -2204,43 +1944,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.814617; -expected_value = 0.7419381786488394; +k.theory_checksat_ms = 22.8744; +expected_value = 0.9999845401760995; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 16807: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 2242: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 9; +k.assertions_size = 2170; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 5; -k.assertions_stats.conjunction_cntr = 9; -k.assertions_stats.constant_cntr = 15; +k.assertions_stats.addition_cntr = 432; +k.assertions_stats.conjunction_cntr = 2170; +k.assertions_stats.constant_cntr = 1156; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1; +k.assertions_stats.equalto_cntr = 2163; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 8; +k.assertions_stats.inequality_cntr = 7; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 4; -k.assertions_stats.negation_cntr = 4; +k.assertions_stats.multiplication_cntr = 338; +k.assertions_stats.negation_cntr = 1313; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 4; -k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.assertions_stats.realconstant_cntr = 1340; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 4; -k.assertions_stats.variable_cntr = 16; +k.assertions_stats.unique_variables = 24; +k.assertions_stats.variable_cntr = 2205; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 5; +k.biggest_assertion_stats.addition_cntr = 4; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 8; +k.biggest_assertion_stats.constant_cntr = 6; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -2252,29 +1992,29 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 4; +k.biggest_assertion_stats.multiplication_cntr = 6; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; -k.biggest_assertion_stats.pow_cntr = 4; +k.biggest_assertion_stats.pow_cntr = 0; k.biggest_assertion_stats.realconstant_cntr = 0; k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 4; -k.biggest_assertion_stats.variable_cntr = 7; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_assertion_stats.variable_cntr = 8; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -2282,63 +2022,37 @@ k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 1; -k.box_continuous_count = 4; -k.box_integer_count = 0; -k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; +k.box_boolean_count = 0; +k.box_continuous_count = 23; +k.box_integer_count = 1; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 1; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; @@ -2348,15 +2062,15 @@ k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; -k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.constant_cntr = 0; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.inequality_cntr = 0; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; @@ -2364,7 +2078,7 @@ k.middle_literal_stats.multiplication_cntr = 0; k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 1; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -2374,23 +2088,23 @@ k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; k.smallest_assertion_stats.addition_cntr = 0; k.smallest_assertion_stats.conjunction_cntr = 0; -k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.constant_cntr = 0; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.inequality_cntr = 0; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 1; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -2400,66 +2114,66 @@ k.smallest_assertion_stats.variable_cntr = 1; k.smallest_literal_stats.abs_cntr = 0; k.smallest_literal_stats.addition_cntr = 0; k.smallest_literal_stats.conjunction_cntr = 0; -k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.constant_cntr = 0; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.inequality_cntr = 0; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0142411; -expected_value = 0.0003001685338791476; +k.theory_checksat_ms = 0.0895811; +expected_value = 3.7790355240307487e-14; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 17224: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 8045: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 14; +k.assertions_size = 3389; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 2; -k.assertions_stats.conjunction_cntr = 14; -k.assertions_stats.constant_cntr = 16; +k.assertions_stats.addition_cntr = 1240; +k.assertions_stats.conjunction_cntr = 3389; +k.assertions_stats.constant_cntr = 2096; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 9; +k.assertions_stats.equalto_cntr = 3382; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 5; +k.assertions_stats.inequality_cntr = 7; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 4; -k.assertions_stats.negation_cntr = 8; +k.assertions_stats.multiplication_cntr = 429; +k.assertions_stats.negation_cntr = 150; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 3; -k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.assertions_stats.realconstant_cntr = 1710; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 6; -k.assertions_stats.variable_cntr = 21; +k.assertions_stats.unique_variables = 24; +k.assertions_stats.variable_cntr = 3424; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.constant_cntr = 6; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -2471,7 +2185,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.multiplication_cntr = 6; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -2480,12 +2194,12 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_assertion_stats.variable_cntr = 8; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 1; @@ -2500,61 +2214,35 @@ k.biggest_literal_stats.min_cntr = 0; k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.pow_cntr = 1; -k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 2; -k.biggest_literal_stats.variable_cntr = 2; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; k.box_boolean_count = 0; -k.box_continuous_count = 6; -k.box_integer_count = 0; -k.lemma_size = 8; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 2; -k.lemma_stats.conjunction_cntr = 8; -k.lemma_stats.constant_cntr = 9; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 4; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 4; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 2; -k.lemma_stats.negation_cntr = 5; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 2; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 5; -k.lemma_stats.variable_cntr = 12; +k.box_continuous_count = 23; +k.box_integer_count = 1; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -2567,23 +2255,23 @@ k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; -k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.constant_cntr = 0; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.inequality_cntr = 0; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 1; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -2591,7 +2279,7 @@ k.middle_literal_stats.uninterpretedfunction_cntr = 0; k.middle_literal_stats.unique_variables = 1; k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 1; k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; @@ -2606,7 +2294,7 @@ k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -2619,40 +2307,40 @@ k.smallest_assertion_stats.variable_cntr = 1; k.smallest_literal_stats.abs_cntr = 0; k.smallest_literal_stats.addition_cntr = 0; k.smallest_literal_stats.conjunction_cntr = 0; -k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.constant_cntr = 0; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.inequality_cntr = 0; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.478895; -expected_value = 0.003040690431174058; +k.theory_checksat_ms = 0.512749; +expected_value = 3.878640707734e-12; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12886: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 3807: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 7; +k.assertions_size = 3; k.assertions_stats.abs_cntr = 0; k.assertions_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 7; -k.assertions_stats.constant_cntr = 7; +k.assertions_stats.conjunction_cntr = 3; +k.assertions_stats.constant_cntr = 3; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; k.assertions_stats.equalto_cntr = 1; @@ -2660,25 +2348,25 @@ k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 6; +k.assertions_stats.inequality_cntr = 2; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 1; -k.assertions_stats.negation_cntr = 7; +k.assertions_stats.multiplication_cntr = 0; +k.assertions_stats.negation_cntr = 0; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 0; -k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.assertions_stats.realconstant_cntr = 1; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 3; -k.assertions_stats.variable_cntr = 8; +k.assertions_stats.unique_variables = 1; +k.assertions_stats.variable_cntr = 3; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 1; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 0; @@ -2691,7 +2379,7 @@ k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; k.biggest_assertion_stats.multiplication_cntr = 0; -k.biggest_assertion_stats.negation_cntr = 1; +k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; k.biggest_assertion_stats.realconstant_cntr = 0; @@ -2699,64 +2387,38 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 2; -k.biggest_assertion_stats.variable_cntr = 2; +k.biggest_assertion_stats.unique_variables = 1; +k.biggest_assertion_stats.variable_cntr = 1; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; k.biggest_literal_stats.multiplication_cntr = 0; -k.biggest_literal_stats.negation_cntr = 1; +k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.pow_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.pow_cntr = 1; +k.biggest_literal_stats.realconstant_cntr = 1; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 2; -k.biggest_literal_stats.variable_cntr = 2; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; k.box_boolean_count = 0; -k.box_continuous_count = 3; +k.box_continuous_count = 1; k.box_integer_count = 0; -k.lemma_size = 4; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 4; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 4; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 5; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 2; -k.lemma_stats.variable_cntr = 5; +k.lemma_size = 1; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -2773,7 +2435,7 @@ k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -2789,20 +2451,20 @@ k.middle_literal_stats.conjunction_cntr = 0; k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.inequality_cntr = 0; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; -k.middle_literal_stats.pow_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.pow_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 1; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -2812,7 +2474,7 @@ k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; k.smallest_assertion_stats.addition_cntr = 0; k.smallest_assertion_stats.conjunction_cntr = 0; -k.smallest_assertion_stats.constant_cntr = 2; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; k.smallest_assertion_stats.equalto_cntr = 1; @@ -2824,11 +2486,11 @@ k.smallest_assertion_stats.inequality_cntr = 0; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 1; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.pow_cntr = 1; +k.smallest_assertion_stats.realconstant_cntr = 1; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -2841,40 +2503,40 @@ k.smallest_literal_stats.conjunction_cntr = 0; k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.inequality_cntr = 0; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; -k.smallest_literal_stats.pow_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.pow_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 1; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.213105; -expected_value = 9.893092458825077e-05; +k.theory_checksat_ms = 0.217245; +expected_value = 5.897490034861308e-17; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 17187: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 17297: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2103; +k.assertions_size = 2102; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 378; -k.assertions_stats.conjunction_cntr = 2103; +k.assertions_stats.addition_cntr = 374; +k.assertions_stats.conjunction_cntr = 2102; k.assertions_stats.constant_cntr = 1098; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 2096; +k.assertions_stats.equalto_cntr = 2095; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; @@ -2884,16 +2546,16 @@ k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; k.assertions_stats.multiplication_cntr = 335; -k.assertions_stats.negation_cntr = 1376; +k.assertions_stats.negation_cntr = 1383; k.assertions_stats.notequalto_cntr = 0; k.assertions_stats.pow_cntr = 1; -k.assertions_stats.realconstant_cntr = 1328; +k.assertions_stats.realconstant_cntr = 1327; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; k.assertions_stats.unique_variables = 24; -k.assertions_stats.variable_cntr = 2138; +k.assertions_stats.variable_cntr = 2137; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 4; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -2923,7 +2585,7 @@ k.biggest_assertion_stats.variable_cntr = 8; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 1; @@ -2939,7 +2601,7 @@ k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 1; +k.biggest_literal_stats.realconstant_cntr = 0; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; @@ -2950,34 +2612,8 @@ k.box_boolean_count = 0; k.box_continuous_count = 23; k.box_integer_count = 1; k.lemma_size = 2; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 2; -k.lemma_stats.constant_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 2; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 2; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 2; k.middle_assertion_stats.abs_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.addition_cntr = 1; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; @@ -2992,7 +2628,7 @@ k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -3080,43 +2716,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.146826; -expected_value = 2.9583265683339373e-07; +k.theory_checksat_ms = 0.0719901; +expected_value = 5.7494126276228756e-11; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 10048: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 10688: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2202; +k.assertions_size = 458; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 446; -k.assertions_stats.conjunction_cntr = 2202; -k.assertions_stats.constant_cntr = 1175; +k.assertions_stats.addition_cntr = 182; +k.assertions_stats.conjunction_cntr = 458; +k.assertions_stats.constant_cntr = 363; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 2195; +k.assertions_stats.equalto_cntr = 253; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 7; +k.assertions_stats.inequality_cntr = 205; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 342; -k.assertions_stats.negation_cntr = 1281; +k.assertions_stats.multiplication_cntr = 122; +k.assertions_stats.negation_cntr = 113; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 1; -k.assertions_stats.realconstant_cntr = 1357; +k.assertions_stats.pow_cntr = 10; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 24; -k.assertions_stats.variable_cntr = 2237; +k.assertions_stats.unique_variables = 233; +k.assertions_stats.variable_cntr = 806; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 4; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 6; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -3128,7 +2764,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -3137,12 +2773,12 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 7; -k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 1; @@ -3158,55 +2794,29 @@ k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 1; +k.biggest_literal_stats.realconstant_cntr = 0; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 0; -k.box_continuous_count = 23; -k.box_integer_count = 1; -k.lemma_size = 2; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 2; -k.lemma_stats.constant_cntr = 0; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 2; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 0; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 2; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 2; +k.box_boolean_count = 1288; +k.box_continuous_count = 233; +k.box_integer_count = 0; +k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; @@ -3214,7 +2824,7 @@ k.middle_assertion_stats.multiplication_cntr = 0; k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 1; +k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; @@ -3224,15 +2834,15 @@ k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; -k.middle_literal_stats.constant_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.equalto_cntr = 0; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; @@ -3240,7 +2850,7 @@ k.middle_literal_stats.multiplication_cntr = 0; k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -3253,20 +2863,20 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; -k.smallest_assertion_stats.multiplication_cntr = 1; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.multiplication_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -3276,15 +2886,15 @@ k.smallest_assertion_stats.variable_cntr = 1; k.smallest_literal_stats.abs_cntr = 0; k.smallest_literal_stats.addition_cntr = 0; k.smallest_literal_stats.conjunction_cntr = 0; -k.smallest_literal_stats.constant_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; @@ -3292,50 +2902,50 @@ k.smallest_literal_stats.multiplication_cntr = 0; k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0610181; -expected_value = 4.8153790532843145e-11; +k.theory_checksat_ms = 0.0775831; +expected_value = 6.578650585805967e-05; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 7306: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 625: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 3084; +k.assertions_size = 2069; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1797; -k.assertions_stats.conjunction_cntr = 3084; -k.assertions_stats.constant_cntr = 2483; +k.assertions_stats.addition_cntr = 902; +k.assertions_stats.conjunction_cntr = 2069; +k.assertions_stats.constant_cntr = 1569; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 2470; +k.assertions_stats.equalto_cntr = 1207; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 614; +k.assertions_stats.inequality_cntr = 862; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 1706; -k.assertions_stats.negation_cntr = 3; +k.assertions_stats.multiplication_cntr = 536; +k.assertions_stats.negation_cntr = 538; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 90; +k.assertions_stats.pow_cntr = 46; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 2417; -k.assertions_stats.variable_cntr = 6747; +k.assertions_stats.unique_variables = 1079; +k.assertions_stats.variable_cntr = 3722; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.constant_cntr = 0; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -3347,7 +2957,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.multiplication_cntr = 0; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -3384,53 +2994,27 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 4265; -k.box_continuous_count = 2417; +k.box_boolean_count = 5725; +k.box_continuous_count = 1079; k.box_integer_count = 0; k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -3472,17 +3056,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.inequality_cntr = 0; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -3508,7 +3092,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -3518,43 +3102,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.178055; -expected_value = 0.414725644747226; +k.theory_checksat_ms = 0.139642; +expected_value = 0.18618322378649993; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1213: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 15965: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2069; +k.assertions_size = 1289; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 902; -k.assertions_stats.conjunction_cntr = 2069; -k.assertions_stats.constant_cntr = 1569; +k.assertions_stats.addition_cntr = 582; +k.assertions_stats.conjunction_cntr = 1289; +k.assertions_stats.constant_cntr = 985; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1207; +k.assertions_stats.equalto_cntr = 751; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 862; +k.assertions_stats.inequality_cntr = 538; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 536; -k.assertions_stats.negation_cntr = 538; +k.assertions_stats.multiplication_cntr = 304; +k.assertions_stats.negation_cntr = 303; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 46; +k.assertions_stats.pow_cntr = 30; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1079; -k.assertions_stats.variable_cntr = 3722; +k.assertions_stats.unique_variables = 671; +k.assertions_stats.variable_cntr = 2282; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -3566,7 +3150,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -3583,12 +3167,12 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -3603,48 +3187,22 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 5725; -k.box_continuous_count = 1079; +k.box_boolean_count = 3529; +k.box_continuous_count = 671; k.box_integer_count = 0; k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; @@ -3657,8 +3215,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.middle_assertion_stats.variable_cntr = 2; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -3691,17 +3249,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -3727,7 +3285,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -3737,39 +3295,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.139642; -expected_value = 0.2967137125035579; +k.theory_checksat_ms = 0.26743; +expected_value = 0.2324655459054427; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 15965: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16188: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2364; +k.assertions_size = 1973; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1227; -k.assertions_stats.conjunction_cntr = 2364; -k.assertions_stats.constant_cntr = 1943; +k.assertions_stats.addition_cntr = 902; +k.assertions_stats.conjunction_cntr = 1973; +k.assertions_stats.constant_cntr = 1497; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1870; +k.assertions_stats.equalto_cntr = 1159; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 494; +k.assertions_stats.inequality_cntr = 814; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 1286; -k.assertions_stats.negation_cntr = 14; +k.assertions_stats.multiplication_cntr = 464; +k.assertions_stats.negation_cntr = 470; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 90; +k.assertions_stats.pow_cntr = 46; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1817; -k.assertions_stats.variable_cntr = 5037; +k.assertions_stats.unique_variables = 1031; +k.assertions_stats.variable_cntr = 3506; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -3822,36 +3380,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 3320; -k.box_continuous_count = 1817; +k.box_boolean_count = 5389; +k.box_continuous_count = 1031; k.box_integer_count = 0; k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 3; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 0; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 3; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 1; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 1; -k.lemma_stats.variable_cntr = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -3867,8 +3399,8 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -3876,8 +3408,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.middle_assertion_stats.variable_cntr = 2; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -3920,7 +3452,7 @@ k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -3946,7 +3478,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -3956,39 +3488,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.238812; -expected_value = 0.3885534648265548; +k.theory_checksat_ms = 0.109711; +expected_value = 0.052861938669424464; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12641: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1356: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 905; +k.assertions_size = 2486; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 374; -k.assertions_stats.conjunction_cntr = 905; -k.assertions_stats.constant_cntr = 811; +k.assertions_stats.addition_cntr = 1142; +k.assertions_stats.conjunction_cntr = 2486; +k.assertions_stats.constant_cntr = 1881; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 641; +k.assertions_stats.equalto_cntr = 1465; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 264; +k.assertions_stats.inequality_cntr = 1021; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 450; -k.assertions_stats.negation_cntr = 272; +k.assertions_stats.multiplication_cntr = 584; +k.assertions_stats.negation_cntr = 592; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 22; +k.assertions_stats.pow_cntr = 58; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 555; -k.assertions_stats.variable_cntr = 1816; +k.assertions_stats.unique_variables = 1301; +k.assertions_stats.variable_cntr = 4424; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -4018,15 +3550,15 @@ k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.equalto_cntr = 0; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -4039,38 +3571,12 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 2; -k.biggest_literal_stats.variable_cntr = 2; -k.box_boolean_count = 1487; -k.box_continuous_count = 555; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 6784; +k.box_continuous_count = 1301; k.box_integer_count = 0; -k.lemma_size = 7; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 7; -k.lemma_stats.constant_cntr = 6; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 1; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 6; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 0; -k.lemma_stats.negation_cntr = 3; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 2; -k.lemma_stats.variable_cntr = 8; +k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -4086,10 +3592,10 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 0; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.pow_cntr = 1; k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; @@ -4129,17 +3635,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -4175,55 +3681,55 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.632496; -expected_value = 0.41555135776245433; +k.theory_checksat_ms = 0.14882; +expected_value = 0.21714960356919458; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 591: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 2247: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 514; +k.assertions_size = 1460; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 517; -k.assertions_stats.conjunction_cntr = 514; -k.assertions_stats.constant_cntr = 1324; +k.assertions_stats.addition_cntr = 662; +k.assertions_stats.conjunction_cntr = 1460; +k.assertions_stats.constant_cntr = 1113; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 190; +k.assertions_stats.equalto_cntr = 853; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 324; +k.assertions_stats.inequality_cntr = 607; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 810; -k.assertions_stats.negation_cntr = 81; +k.assertions_stats.multiplication_cntr = 344; +k.assertions_stats.negation_cntr = 341; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 0; +k.assertions_stats.pow_cntr = 34; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 212; -k.assertions_stats.variable_cntr = 1262; +k.assertions_stats.unique_variables = 761; +k.assertions_stats.variable_cntr = 2588; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 5; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 7; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; k.biggest_assertion_stats.exp_cntr = 0; k.biggest_assertion_stats.false_cntr = 0; k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -4232,12 +3738,12 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 8; -k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 3; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 0; @@ -4249,7 +3755,7 @@ k.biggest_literal_stats.inequality_cntr = 1; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; -k.biggest_literal_stats.multiplication_cntr = 2; +k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; @@ -4258,38 +3764,12 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 2; -k.biggest_literal_stats.variable_cntr = 2; -k.box_boolean_count = 0; -k.box_continuous_count = 306; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 3994; +k.box_continuous_count = 761; k.box_integer_count = 0; k.lemma_size = 3; -k.lemma_stats.abs_cntr = 0; -k.lemma_stats.addition_cntr = 0; -k.lemma_stats.conjunction_cntr = 3; -k.lemma_stats.constant_cntr = 5; -k.lemma_stats.disjunction_cntr = 0; -k.lemma_stats.division_cntr = 0; -k.lemma_stats.equalto_cntr = 1; -k.lemma_stats.exp_cntr = 0; -k.lemma_stats.false_cntr = 0; -k.lemma_stats.forall_cntr = 0; -k.lemma_stats.ifthenelse_cntr = 0; -k.lemma_stats.inequality_cntr = 2; -k.lemma_stats.log_cntr = 0; -k.lemma_stats.max_cntr = 0; -k.lemma_stats.min_cntr = 0; -k.lemma_stats.multiplication_cntr = 2; -k.lemma_stats.negation_cntr = 2; -k.lemma_stats.notequalto_cntr = 0; -k.lemma_stats.pow_cntr = 0; -k.lemma_stats.realconstant_cntr = 0; -k.lemma_stats.sqrt_cntr = 0; -k.lemma_stats.trigonometry_cntr = 0; -k.lemma_stats.true_cntr = 0; -k.lemma_stats.uninterpretedfunction_cntr = 0; -k.lemma_stats.unique_variables = 2; -k.lemma_stats.variable_cntr = 4; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -4322,12 +3802,12 @@ k.middle_literal_stats.conjunction_cntr = 0; k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.equalto_cntr = 0; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; @@ -4358,7 +3838,7 @@ k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -4394,10 +3874,10 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.560366; -expected_value = 0.19257991774231606; +k.theory_checksat_ms = 0.32306; +expected_value = 0.355702855225073; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 3469: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12988: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); From 5fd51761dbbabaccccfd3d7b2448f2737f0c2c0e Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 17 Apr 2025 02:02:21 -0700 Subject: [PATCH 30/79] Support intervals for BOOLEAN variables in boxes. --- src/dreal/solver/sat_solver.cc | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 7a0749b1a..09cd810c2 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -77,7 +77,6 @@ void SatSolver::AddLearnedClause(const vector& conflicting_conjunction, void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { for (const auto& v : base_box.variables()) { - if (v.get_type() == Variable::Type::BOOLEAN) continue; const auto condition = MakeSatIntervalVar(pn, v, base_box[v]); if (is_true(condition)) continue; for ( @@ -298,7 +297,14 @@ void SatSolver::MakeSatVar(const Variable& var) { } Formula SatSolver::MakeSatIntervalVar(PredicateNormalizer &pn, const Variable& var, const Box::Interval& intv) { - DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); + // DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); + if (var.get_type() == Variable::Type::BOOLEAN) { + if (intv.lb() == 1) return Formula{var}; + if (intv.ub() == 0) return !Formula{var}; + DREAL_ASSERT(intv.lb() == 0 && intv.ub() == 1); + return Formula::True(); + } // else { + DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVar({} ∈ {})", fmt::streamed(var), fmt::streamed(intv)); auto ub_pred = Formula::True(); if (isfinite(intv.ub())) { From b44fdbdc009e09a2bb8090b81b8c6e6975715070 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 17 Apr 2025 02:49:30 -0700 Subject: [PATCH 31/79] Separate SAT solver infrastructure code from theory-related code. --- src/dreal/solver/sat_solver.cc | 191 +--------------- src/dreal/solver/sat_solver.h | 9 +- src/dreal/solver/sat_solver_interval_logic.cc | 205 ++++++++++++++++++ 3 files changed, 210 insertions(+), 195 deletions(-) create mode 100644 src/dreal/solver/sat_solver_interval_logic.cc diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 09cd810c2..661f6f6a9 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -17,6 +17,7 @@ #include #include +#include #include #include "auditor.h" @@ -67,74 +68,6 @@ void SatSolver::AddFormula(const Formula& f) { } } -void SatSolver::AddLearnedClause(const vector& conflicting_conjunction, const Box& box) { - if (DREAL_LOG_DEBUG_ENABLED) audit(!make_conjunction(conflicting_conjunction), box); - for (const Formula& f : conflicting_conjunction) { - AddLiteral(!predicate_abstractor_.Convert(f)); - } - cadical->add(0); -} - -void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { - for (const auto& v : base_box.variables()) { - const auto condition = MakeSatIntervalVar(pn, v, base_box[v]); - if (is_true(condition)) continue; - for ( - const auto& lit : - is_conjunction(condition) ? get_operands(condition) : set{condition} - ) { - // todo: audit? currently can't because it is already predicate_abstractor-ed - AddLiteral(lit); - cadical->add(0); - } - } -} - -PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( - PredicateNormalizer& pn, - const vector& base_conflict, const Box& base_box, - const std::chrono::duration timeout -) { - // the pattern matching is kinda best-effort now. - // it breaks down when one clause pattern matches into 1000s of permutations of itself - // just make the best effort, and at the very minimum make sure the original at least gets inserted - AddLearnedClause(base_conflict, base_box); - const auto [ - all_related_conflicts, - match_statistics - ] = pn.FindSimilar(base_conflict, timeout); - if (all_related_conflicts.empty()) { - DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); - return match_statistics; - } - - for (const auto& [conflict_clause, subs] : all_related_conflicts) { - Box conflict_box = substitutions_map::apply_substitution(base_box, subs, false); - - if (DREAL_LOG_DEBUG_ENABLED) { // todo: better gate. - std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); - audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), conflict_box); - } - - // a & b & c & ... ==> ~(x & y & z & ...) - // ~(a & b & c & ...) | ~(x & y & z & ...) - // ~a | ~b | ~c | ... | ~x | ~y | ~z | ... - - for (const auto& v : conflict_box.variables()) { - // if (v.get_type() == Variable::Type::BOOLEAN) continue; // todo: commented, because maybe unsound???? - const auto condition = MakeSatIntervalVar(pn, v, conflict_box[v]); - if (is_true(condition)) continue; - else if (!is_conjunction(condition)) AddLiteral(!condition); // already predicate-converted. - else for (const auto& lit : get_operands(condition)) AddLiteral(!lit); - } - // ==> - for (const Formula& f : conflict_clause) AddLiteral(!predicate_abstractor_.Convert(f)); - - cadical->add(0); - } - return match_statistics; -} - void SatSolver::AddClause(const Formula& f) { DREAL_LOG_DEBUG("SatSolver::AddClause({})", f); // Set up Variable ⇔ Literal (in SAT) map. @@ -251,7 +184,6 @@ void SatSolver::Pop() { to_sat_var_.pop(); // picosat_pop(sat_); throw DREAL_RUNTIME_ERROR("NOT YET IMPLEMENTED SatSolver::Pop()"); - has_picosat_pop_used_ = true; } void SatSolver::Push() { @@ -296,129 +228,8 @@ void SatSolver::MakeSatVar(const Variable& var) { DREAL_LOG_DEBUG("SatSolver::MakeSatVar({} ↦ {})", fmt::streamed(var), sat_var); } -Formula SatSolver::MakeSatIntervalVar(PredicateNormalizer &pn, const Variable& var, const Box::Interval& intv) { - // DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); - if (var.get_type() == Variable::Type::BOOLEAN) { - if (intv.lb() == 1) return Formula{var}; - if (intv.ub() == 0) return !Formula{var}; - DREAL_ASSERT(intv.lb() == 0 && intv.ub() == 1); - return Formula::True(); - } // else { - - DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVar({} ∈ {})", fmt::streamed(var), fmt::streamed(intv)); - auto ub_pred = Formula::True(); - if (isfinite(intv.ub())) { - ub_pred = var <= intv.ub(); // TODO: figure out if this is inclusive or exclusive. - // an iterator pointing to the first element that is greater or equal to intv.ub() - auto& var_ub_preds = all_ub_predicates[var]; - auto ub_gte_it = var_ub_preds.lower_bound(intv.ub()); - if (!var_ub_preds.empty() && ub_gte_it->first == intv.ub()) ub_pred = ub_gte_it->second; - else { - ub_pred = predicate_abstractor_.Convert(pn.Convert(ub_pred)); - MakeSatVar(get_variable(ub_pred)); - - if (ub_gte_it != var_ub_preds.end()) { - const auto& gt = *ub_gte_it; - DREAL_ASSERT(intv.ub() < gt.first); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", ub_pred, gt.second); - // std::cout << ub_pred << " => " << gt.second << std::endl; - // (x < Ub) => (x < Ub+ε) - // = ~(x < Ub) \/ (x < Ub+ε) - // = ~((x < Ub) /\ ~(x < Ub+ε)) - AddLearnedClause({ub_pred, !gt.second}, {}); - } - if (ub_gte_it != var_ub_preds.begin()) { - --ub_gte_it; - const auto& lt = *ub_gte_it; - DREAL_ASSERT(lt.first < intv.ub()); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lt.second, ub_pred); - // std::cout << lt.second << " => " << ub_pred << std::endl; - // (x < Ub-ε) => (x < Ub) - // = ~(x < Ub-ε) \/ (x < Ub) - // = ~((x < Ub-ε) /\ ~(x < Ub)) - AddLearnedClause({lt.second, !ub_pred}, {}); - } - var_ub_preds[intv.ub()] = ub_pred; - } - } - - auto lb_pred = Formula::True(); - if (isfinite(intv.lb())) { - lb_pred = intv.lb() <= var; // TODO: figure out if this is inclusive or exclusive. - // an iterator pointing to the first element that is greater or equal to intv.lb() - auto& var_lb_preds = all_lb_predicates[var]; - auto lb_gte_it = var_lb_preds.lower_bound(intv.lb()); - if (!var_lb_preds.empty() && lb_gte_it->first == intv.lb()) lb_pred = lb_gte_it->second; - else { - lb_pred = predicate_abstractor_.Convert(pn.Convert(lb_pred)); - MakeSatVar(get_variable(lb_pred)); - - if (lb_gte_it != var_lb_preds.end()) { - const auto& gt = *lb_gte_it; - DREAL_ASSERT(intv.lb() < gt.first); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", gt.second, lb_pred); - // std::cout << gt.second << " => " << lb_pred << std::endl; - // (Lb+ε < x) => (Lb < x) - // = ~(Lb+ε < x) \/ (Lb < x) - // = ~((Lb+ε < x) /\ ~(Lb < x)) - AddLearnedClause({gt.second, !lb_pred}, {}); - } - if (lb_gte_it != var_lb_preds.begin()) { - --lb_gte_it; - const auto& lt = *lb_gte_it; - DREAL_ASSERT(lt.first < intv.lb()); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lb_pred, lt.second); - // std::cout << lb_pred << " => " << lt.second << std::endl; - // (Lb < x) => (Lb-ε < x) - // = ~(Lb < x) \/ (Lb-ε < x) - // = ~((Lb < x) /\ ~(Lb-ε < x)) - AddLearnedClause({lb_pred, !lt.second}, {}); - } - var_lb_preds[intv.lb()] = lb_pred; - } - } - - return lb_pred && ub_pred; -} - Formula SatSolver::theory_literal(const Variable& var) const { return predicate_abstractor_[var]; } -bool SatSolver::learning(const int size) { - buffer_i = 0; - expected_clause_size = size; - return size < BUFFER_SIZE; -} - -void SatSolver::learn(const int new_lit) { - if (new_lit != 0) { - DREAL_ASSERT(buffer_i < expected_clause_size); - buffer[buffer_i] = new_lit; - buffer_i++; - return; - } // else { - - DREAL_ASSERT(buffer_i == expected_clause_size); - - set neg_conjunction; - for (int i = 0; i < expected_clause_size; i++) { - const int lit = buffer[i]; - const bool lit_is_neg = lit < 0; - - const auto sym_var_it = to_sym_var_.find(lit_is_neg ? -lit : +lit); - DREAL_ASSERT(sym_var_it != to_sym_var_.end()); - const auto theory_lit_it = predicate_abstractor_.var_to_formula_map().find(sym_var_it->second); - const Formula theory_lit = - theory_lit_it == predicate_abstractor_.var_to_formula_map().end() - ? Formula{sym_var_it->second} - : theory_lit_it->second; - neg_conjunction.emplace( - !(lit_is_neg ? !theory_lit : theory_lit) - ); - } - const Formula sat_clause = !make_conjunction(neg_conjunction); - std::cout << "LEARNED: " << sat_clause << std::endl; -} - } // namespace dreal diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index b2b290e97..064e4a40c 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -68,7 +68,7 @@ class SatSolver : public CaDiCaL::Learner { /// Given a @p formulas = {f₁, ..., fₙ}, adds a clause (¬f₁ ∨ ... ∨ ¬ fₙ) to /// the solver. - void AddLearnedClause(const std::vector& conflicting_conjunction, const Box& box); + void AddLearnedClause(PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& box); PatternMatchingTrie::matching_stats_t AddLearnedClausePattern( PredicateNormalizer& pn, const std::vector& base_conflict, @@ -116,10 +116,10 @@ class SatSolver : public CaDiCaL::Learner { TseitinCnfizer cnfizer_; PredicateAbstractor predicate_abstractor_; - // Map symbolic::Variable → int (Variable type in PicoSat). + // Map symbolic::Variable → int (Variable type in CaDiCaL). ScopedUnorderedMap to_sat_var_; - // Map int (Variable type in PicoSat) → symbolic::Variable. + // Map int (Variable type in CaDiCaL) → symbolic::Variable. ScopedUnorderedMap to_sym_var_; /// Set of temporary Boolean variables introduced by Tseitin @@ -140,5 +140,4 @@ class SatSolver : public CaDiCaL::Learner { bool learning(int size) override; void learn(int new_lit) override; }; - -} // namespace dreal +} // namespace dreal diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc new file mode 100644 index 000000000..52c16fe76 --- /dev/null +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -0,0 +1,205 @@ +// +// Created by Kunal Sheth on 4/17/25. +// + +#include + +#include "auditor.h" +#include "sat_solver.h" + +namespace dreal { + +using std::cout; +using std::set; +using std::vector; + +void SatSolver::AddLearnedClause( + PredicateNormalizer& pn, + const vector& conflicting_conjunction, const Box& box +) { + if (DREAL_LOG_DEBUG_ENABLED) audit(!make_conjunction(conflicting_conjunction), box); + + // a & b & c & ... ==> ~(x & y & z & ...) + // ~(a & b & c & ...) | ~(x & y & z & ...) + // ~a | ~b | ~c | ... | ~x | ~y | ~z | ... + + for (const auto& v : box.variables()) { + const auto condition = MakeSatIntervalVar(pn, v, box[v]); + if (is_true(condition)) continue; + else if (!is_conjunction(condition)) AddLiteral(!condition); // already predicate-converted. + else for (const auto& lit : get_operands(condition)) AddLiteral(!lit); + } + // ==> + for (const Formula& f : conflicting_conjunction) AddLiteral(!predicate_abstractor_.Convert(f)); + + cadical->add(0); +} + +void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { + for (const auto& v : base_box.variables()) { + const auto condition = MakeSatIntervalVar(pn, v, base_box[v]); + if (is_true(condition)) continue; + for ( + const auto& lit : + is_conjunction(condition) ? get_operands(condition) : set{condition} + ) { + // todo: audit? currently can't because it is already predicate_abstractor-ed + AddLiteral(lit); + cadical->add(0); + } + } +} + +PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( + PredicateNormalizer& pn, + const vector& base_conflict, const Box& base_box, + const std::chrono::duration timeout +) { + // the pattern matching is kinda best-effort now. + // it breaks down when one clause pattern matches into 1000s of permutations of itself + // just make the best effort, and at the very minimum make sure the original at least gets inserted + AddLearnedClause(pn, base_conflict, base_box); + const auto [ + all_related_conflicts, + match_statistics + ] = pn.FindSimilar(base_conflict, timeout); + if (all_related_conflicts.empty()) { + DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); + return match_statistics; + } + + for (const auto& [conflict_clause, subs] : all_related_conflicts) { + const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); + + if (DREAL_LOG_INFO_ENABLED) { // todo: better gate. + std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); + audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), conflict_box); + } + + AddLearnedClause(pn, conflict_clause, conflict_box); + } + return match_statistics; +} + +Formula SatSolver::MakeSatIntervalVar(PredicateNormalizer &pn, const Variable& var, const Box::Interval& intv) { + // DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); + if (var.get_type() == Variable::Type::BOOLEAN) { + if (intv.lb() == 1) return Formula{var}; + if (intv.ub() == 0) return !Formula{var}; + DREAL_ASSERT(intv.lb() == 0 && intv.ub() == 1); + return Formula::True(); + } // else { + + DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVar({} ∈ {})", fmt::streamed(var), fmt::streamed(intv)); + auto ub_pred = Formula::True(); + if (isfinite(intv.ub())) { + ub_pred = var <= intv.ub(); // TODO: figure out if this is inclusive or exclusive. + // an iterator pointing to the first element that is greater or equal to intv.ub() + auto& var_ub_preds = all_ub_predicates[var]; + auto ub_gte_it = var_ub_preds.lower_bound(intv.ub()); + if (!var_ub_preds.empty() && ub_gte_it->first == intv.ub()) ub_pred = ub_gte_it->second; + else { + ub_pred = predicate_abstractor_.Convert(pn.Convert(ub_pred)); + MakeSatVar(get_variable(ub_pred)); + + if (ub_gte_it != var_ub_preds.end()) { + const auto& gt = *ub_gte_it; + DREAL_ASSERT(intv.ub() < gt.first); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", ub_pred, gt.second); + // std::cout << ub_pred << " => " << gt.second << std::endl; + // (x < Ub) => (x < Ub+ε) + // = ~(x < Ub) \/ (x < Ub+ε) + // = ~((x < Ub) /\ ~(x < Ub+ε)) + AddLearnedClause(pn, {ub_pred, !gt.second}, {/* empty— will overflow stack otherwise. */}); + } + if (ub_gte_it != var_ub_preds.begin()) { + --ub_gte_it; + const auto& lt = *ub_gte_it; + DREAL_ASSERT(lt.first < intv.ub()); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lt.second, ub_pred); + // std::cout << lt.second << " => " << ub_pred << std::endl; + // (x < Ub-ε) => (x < Ub) + // = ~(x < Ub-ε) \/ (x < Ub) + // = ~((x < Ub-ε) /\ ~(x < Ub)) + AddLearnedClause(pn, {lt.second, !ub_pred}, {/* empty— will overflow stack otherwise. */}); + } + var_ub_preds[intv.ub()] = ub_pred; + } + } + + auto lb_pred = Formula::True(); + if (isfinite(intv.lb())) { + lb_pred = intv.lb() <= var; // TODO: figure out if this is inclusive or exclusive. + // an iterator pointing to the first element that is greater or equal to intv.lb() + auto& var_lb_preds = all_lb_predicates[var]; + auto lb_gte_it = var_lb_preds.lower_bound(intv.lb()); + if (!var_lb_preds.empty() && lb_gte_it->first == intv.lb()) lb_pred = lb_gte_it->second; + else { + lb_pred = predicate_abstractor_.Convert(pn.Convert(lb_pred)); + MakeSatVar(get_variable(lb_pred)); + + if (lb_gte_it != var_lb_preds.end()) { + const auto& gt = *lb_gte_it; + DREAL_ASSERT(intv.lb() < gt.first); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", gt.second, lb_pred); + // std::cout << gt.second << " => " << lb_pred << std::endl; + // (Lb+ε < x) => (Lb < x) + // = ~(Lb+ε < x) \/ (Lb < x) + // = ~((Lb+ε < x) /\ ~(Lb < x)) + AddLearnedClause(pn, {gt.second, !lb_pred}, {/* empty— will overflow stack otherwise. */}); + } + if (lb_gte_it != var_lb_preds.begin()) { + --lb_gte_it; + const auto& lt = *lb_gte_it; + DREAL_ASSERT(lt.first < intv.lb()); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lb_pred, lt.second); + // std::cout << lb_pred << " => " << lt.second << std::endl; + // (Lb < x) => (Lb-ε < x) + // = ~(Lb < x) \/ (Lb-ε < x) + // = ~((Lb < x) /\ ~(Lb-ε < x)) + AddLearnedClause(pn, {lb_pred, !lt.second}, {/* empty— will overflow stack otherwise. */}); + } + var_lb_preds[intv.lb()] = lb_pred; + } + } + + return lb_pred && ub_pred; +} + +bool SatSolver::learning(const int size) { + buffer_i = 0; + expected_clause_size = size; + return size < BUFFER_SIZE; +} + +void SatSolver::learn(const int new_lit) { + if (new_lit != 0) { + DREAL_ASSERT(buffer_i < expected_clause_size); + buffer[buffer_i] = new_lit; + buffer_i++; + return; + } // else { + + DREAL_ASSERT(buffer_i == expected_clause_size); + + set neg_conjunction; + for (int i = 0; i < expected_clause_size; i++) { + const int lit = buffer[i]; + const bool lit_is_neg = lit < 0; + + const auto sym_var_it = to_sym_var_.find(lit_is_neg ? -lit : +lit); + DREAL_ASSERT(sym_var_it != to_sym_var_.end()); + const auto theory_lit_it = predicate_abstractor_.var_to_formula_map().find(sym_var_it->second); + const Formula theory_lit = + theory_lit_it == predicate_abstractor_.var_to_formula_map().end() + ? Formula{sym_var_it->second} + : theory_lit_it->second; + neg_conjunction.emplace( + !(lit_is_neg ? !theory_lit : theory_lit) + ); + } + const Formula sat_clause = !make_conjunction(neg_conjunction); + std::cout << "LEARNED: " << sat_clause << std::endl; +} + +} // namespace dreal From 3eaa18399fd01a7ea94c9e6261726794babcc1d8 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 17 Apr 2025 02:51:19 -0700 Subject: [PATCH 32/79] Add note clarifying on "forward"/"backward" mapping meaning in substitutions_map after fixing soundness bug in SAT solver. --- src/dreal/util/pattern_matching/substitutions_map.cc | 2 ++ src/dreal/util/pattern_matching/substitutions_map.h | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/dreal/util/pattern_matching/substitutions_map.cc b/src/dreal/util/pattern_matching/substitutions_map.cc index ab1928ce5..76b1c7217 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.cc +++ b/src/dreal/util/pattern_matching/substitutions_map.cc @@ -19,6 +19,8 @@ namespace dreal reserve(reserved_size); } + // "forward" takes the matched and maps it to original + // "backward" takes original and maps it to matched Box substitutions_map::apply_substitution( const Box& b, const substitutions_map& subs, bool backward ) { diff --git a/src/dreal/util/pattern_matching/substitutions_map.h b/src/dreal/util/pattern_matching/substitutions_map.h index c42d38180..b896dd0d7 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.h +++ b/src/dreal/util/pattern_matching/substitutions_map.h @@ -24,6 +24,8 @@ namespace dreal substitutions_map(); explicit substitutions_map(size_t reserve); + // "forward" takes the matched and maps it to original + // "backward" takes original and maps it to matched template [[nodiscard]] static T apply_substitution( const T& f, const substitutions_map& subs, bool backward From 171555a3298f65b32b48642133b260a736f9393e Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 17 Apr 2025 02:52:58 -0700 Subject: [PATCH 33/79] Flush out simple quantifier handling in predicate_heuristic.cc and pattern_matching_trie_form.cc. --- .../pattern_matching_trie_form.cc | 27 ++++++++++++++++--- src/dreal/util/predicate_heuristic.cc | 4 ++- 2 files changed, 27 insertions(+), 4 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index f777877cf..e95382075 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -320,16 +320,37 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } ADD_DECL(VisitForall) { - throw DREAL_RUNTIME_ERROR("Pattern matching of quantifiers is currently unsupported {}", f); + // temporary implementation... + // I haven't put much thought into this. + return parent.c(FormulaKind::Forall).emplace_back(f, is_terminal); } EST_DECL(VisitForall) { branches += parent.c(FormulaKind::Forall).size(); - throw DREAL_RUNTIME_ERROR("Pattern matching of quantifiers is currently unsupported {}", _f); + const auto f = to_forall(_f); + for (auto& node : parent.c(FormulaKind::Forall)) { + const auto& matched_f = to_forall(*node.leaf); + if (!f->EqualTo(*matched_f)) {} // recursive but whatever.. + else if (!node.terminal_expression.has_value()) + partial_matches(node); + } } VISIT_DECL(VisitForall) { - throw DREAL_RUNTIME_ERROR("Pattern matching of quantifiers is currently unsupported {}", _f); + // temporary implementation... + // I haven't put much thought into this. + const auto f = to_forall(_f); + for (auto& node : parent.c(FormulaKind::Forall)) { + const auto& matched_f = to_forall(*node.leaf); + if (!f->EqualTo(*matched_f)) + misses(substitutions); + else if (!node.terminal_expression.has_value()) + partial_matches(node, substitutions); + else if (substitutions_map::verify_substitutions(substitutions)) + matches(*node.terminal_expression, substitutions); + else + misses(substitutions); + } } #undef VISIT_DECL #undef ADD_DECL diff --git a/src/dreal/util/predicate_heuristic.cc b/src/dreal/util/predicate_heuristic.cc index 40e990078..8bf1d74a0 100644 --- a/src/dreal/util/predicate_heuristic.cc +++ b/src/dreal/util/predicate_heuristic.cc @@ -246,7 +246,9 @@ namespace dreal ADD_DECL(VisitForall) { stats.forall_cntr++; - throw DREAL_RUNTIME_ERROR("Heuristics for quantifiers are currently unsupported {}", f); + recHeurForm(get_quantified_formula(f), stats, inverted); + for (const auto & v : get_quantified_variables(f)) + recHeurExpr({v}, stats); } #undef ADD_DECL From 9ed6f0e919fb3ed4458388e50de98d4d008f0fc8 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 19 Apr 2025 00:31:17 -0700 Subject: [PATCH 34/79] Fix soundness bug in how filter_assertion handles strict upper bounds, due to incorrect fp limit passed to `nextafter()`. --- src/dreal/solver/filter_assertion.cc | 2 +- .../solver/test/filter_assertion_test.cc | 24 +++++++++++++++++++ .../symbolic/test/symbolic_expression_test.cc | 4 ++++ 3 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/dreal/solver/filter_assertion.cc b/src/dreal/solver/filter_assertion.cc index 920264cd1..abfa68d89 100644 --- a/src/dreal/solver/filter_assertion.cc +++ b/src/dreal/solver/filter_assertion.cc @@ -131,7 +131,7 @@ FilterAssertionResult UpdateStrictUpperBound(const Variable& var, const double v, Box* const box) { switch (var.get_type()) { case Variable::Type::CONTINUOUS: - return UpdateUpperBound(var, nextafter(v, numeric_limits::min()), + return UpdateUpperBound(var, nextafter(v, numeric_limits::lowest()), box); case Variable::Type::INTEGER: case Variable::Type::BINARY: diff --git a/test/dreal/solver/test/filter_assertion_test.cc b/test/dreal/solver/test/filter_assertion_test.cc index 26d800a89..e8af43d51 100644 --- a/test/dreal/solver/test/filter_assertion_test.cc +++ b/test/dreal/solver/test/filter_assertion_test.cc @@ -40,6 +40,20 @@ TEST_F(FilterAssertionTest, FilteredWithChange1) { EXPECT_EQ(box_[z_].lb(), old_box[z_].lb()); } +TEST_F(FilterAssertionTest, FilteredWithChange1_MinVersusLowest) { + // https://github.com/dreal/dreal4/blob/f93bdcc26b62abdcc30ad7de6046729bb48016b9/dreal/solver/filter_assertion.cc#L135 + // should have been ::lowest() not ::min(). + // semantics of `::min()` are different between integer and fp types. + + // (z < 0) + const Box old_box{box_}; + const auto result = FilterAssertion(z_ < 0, &box_); + EXPECT_TRUE(result.filtered); EXPECT_TRUE(result.changed); + EXPECT_LT(box_[z_].ub(), 0); + // No change on z.lb(). + EXPECT_EQ(box_[z_].lb(), old_box[z_].lb()); +} + TEST_F(FilterAssertionTest, FilteredWithChange2) { // ¬(z < 50) => (z >= 50) const Box old_box{box_}; @@ -80,6 +94,16 @@ TEST_F(FilterAssertionTest, FilteredWithChange5) { EXPECT_EQ(box_[z_].ub(), old_box[z_].ub()); } +TEST_F(FilterAssertionTest, FilteredWithChange5_MinVersusLowest) { + // (z > 0) + const Box old_box{box_}; + const auto result = FilterAssertion(z_ > 0, &box_); + EXPECT_TRUE(result.filtered); EXPECT_TRUE(result.changed); + EXPECT_GT(box_[z_].lb(), 0); + // No change on z.ub(). + EXPECT_EQ(box_[z_].ub(), old_box[z_].ub()); +} + TEST_F(FilterAssertionTest, FilteredWithChange6) { // ¬(z > 50) => (z <= 50) const Box old_box{box_}; diff --git a/test/third_party/com_github_robotlocomotion_drake/dreal/symbolic/test/symbolic_expression_test.cc b/test/third_party/com_github_robotlocomotion_drake/dreal/symbolic/test/symbolic_expression_test.cc index 8e68224a1..944d7604f 100644 --- a/test/third_party/com_github_robotlocomotion_drake/dreal/symbolic/test/symbolic_expression_test.cc +++ b/test/third_party/com_github_robotlocomotion_drake/dreal/symbolic/test/symbolic_expression_test.cc @@ -820,6 +820,10 @@ TEST_F(SymbolicExpressionTest, NumericLimits) { ASSERT_TRUE(is_constant(num_min)); EXPECT_EQ(get_constant_value(num_min), numeric_limits::min()); + const Expression num_low = Limits::lowest(); + ASSERT_TRUE(is_constant(num_low)); + EXPECT_EQ(get_constant_value(num_low), numeric_limits::lowest()); + const Expression num_infinity = Limits::infinity(); EXPECT_EQ(num_infinity.to_string(), "inf"); } From f843fdcf7a3e8493632abdc6efcf39d18fcbc4d9 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 19 Apr 2025 00:32:19 -0700 Subject: [PATCH 35/79] Lower priority of more logs from Debug to Trace. --- src/dreal/solver/relational_formula_evaluator.cc | 2 +- src/dreal/util/ibex_converter.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dreal/solver/relational_formula_evaluator.cc b/src/dreal/solver/relational_formula_evaluator.cc index 019e6cb9a..7ed67b8a7 100644 --- a/src/dreal/solver/relational_formula_evaluator.cc +++ b/src/dreal/solver/relational_formula_evaluator.cc @@ -83,7 +83,7 @@ RelationalFormulaEvaluator::RelationalFormulaEvaluator(Formula f) expression_evaluator_{ExtractExpression(formula())} {} RelationalFormulaEvaluator::~RelationalFormulaEvaluator() { - DREAL_LOG_DEBUG("RelationalFormulaEvaluator::~RelationalFormulaEvaluator()"); + DREAL_LOG_TRACE("RelationalFormulaEvaluator::~RelationalFormulaEvaluator()"); } FormulaEvaluationResult RelationalFormulaEvaluator::operator()( diff --git a/src/dreal/util/ibex_converter.cc b/src/dreal/util/ibex_converter.cc index 6c21dc9f9..acc46773d 100644 --- a/src/dreal/util/ibex_converter.cc +++ b/src/dreal/util/ibex_converter.cc @@ -88,7 +88,7 @@ IbexConverter::IbexConverter(const vector& variables) IbexConverter::IbexConverter(const Box& box) : IbexConverter{box.variables()} {} IbexConverter::~IbexConverter() { - DREAL_LOG_DEBUG("IbexConverter::~IbexConverter()"); + DREAL_LOG_TRACE("IbexConverter::~IbexConverter()"); if (need_to_delete_variables_) { for (const auto& p : symbolic_var_to_ibex_var_) { delete p.second; From 18d8b9d23319a27f89ddc578980c50831eb7f41d Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 19 Apr 2025 12:11:33 -0700 Subject: [PATCH 36/79] Re-train neural network because I accidentally said "LOG2_worth_it > 1" instead of "worth_it > 1." --- .../pattern_matching_heuristic.cc | 36 +- .../test/pattern_matching_heuristic_test.cc | 1068 ++++++++--------- 2 files changed, 552 insertions(+), 552 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc index e1fb165be..81b87f347 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc @@ -1,13 +1,13 @@ -// This file was automatically generated on 2025-04-17 00:30:08.818979 by Kunal in the `WORTH_IT_regression` python notebook. +// This file was automatically generated on 2025-04-19 11:57:36.897311 by Kunal in the `WORTH_IT_regression` python notebook. // // Notes: // len(df_overestimated) / len(df) = 0.012 -// len(df_valid_over) / len(df) = 0.191 -// len(df_valid_under) / len(df) = 0.787 -// len(df_underestimated) / len(df) = 0.010 +// len(df_valid_over) / len(df) = 0.234 +// len(df_valid_under) / len(df) = 0.750 +// len(df_underestimated) / len(df) = 0.005 // -// accuracy_score(y_test, y_pred) = 0.9698189134808853 +// accuracy_score(y_test, y_pred) = 0.9801667145731532 // len(X_train) = 13913 // len(X_test) / len(X_train) = 0.25 // model = Pipeline(steps=[('standardscaler', StandardScaler()), ('mlpclassifier', MLPClassifier(hidden_layer_sizes=(8, 4), max_iter=1000, random_state=42))]) @@ -416,19 +416,19 @@ x0[190] = 1.0*smallest_literal_stats_uninterpretedfunction_cntr; x0[191] = 1.8363223514790834*smallest_literal_stats_unique_variables - 1.9094426406129448; x0[192] = 0.15542016244619064*smallest_literal_stats_variable_cntr - 0.21487147449525459; x0[193] = 0.00032842472077025258*theory_checksat_ms - 0.040918510018383925; -x1[0] = relu(-0.010604471219204154*x0[0] + 0.027266101716757168*x0[1] - 0.037271076771114721*x0[2] + 0.064705193927656557*x0[3] - 0.14781597203471636*x0[4] - 2.6577952380339518*x0[5] - 0.11872629571988673*x0[6] - 0.22970312975575521*x0[7] - 0.16757446029045237*x0[8] - 0.30519253071338182*x0[9] + 0.10400937080078945*x0[10] - 2.8907555397204009e-315*x0[11] - 0.031177938698050425*x0[12] + 0.1698814353107499*x0[13] + 3.2078235266195469e-316*x0[14] - 7.9454434608407292e-316*x0[15] + 2.6790589439569961e-315*x0[16] - 2.2427428132965561e-315*x0[17] - 0.27174011381741225*x0[18] - 0.20660426636980991*x0[19] - 4.060998000610261e-315*x0[20] + 1.1069668115790062e-315*x0[21] + 0.3384585317724943*x0[22] - 0.037180891951755508*x0[23] + 6.2422281835059267e-316*x0[24] + 0.10726415257510583*x0[25] - 0.092034327737386082*x0[26] + 1.4336084320140295e-315*x0[27] - 0.038199344896797771*x0[28] - 1.5955856801142405e-315*x0[29] - 4.4586757224970297e-315*x0[30] + 0.11518763641979353*x0[31] + 0.094465126589046017*x0[32] - 2.7588952735232754e-316*x0[33] + 0.051998035969074319*x0[34] - 3.3410160062460881e-315*x0[35] - 0.01810989007724877*x0[36] + 2.8681410434625439e-316*x0[37] - 0.22733726855685196*x0[38] - 0.056738334335730535*x0[39] + 1.8673265332977827e-315*x0[40] + 2.7493787786793396e-316*x0[41] + 6.0787623650213606e-316*x0[42] + 1.0199772316099177e-315*x0[43] - 0.052102185899596677*x0[44] - 0.12564852143164001*x0[45] + 6.049828003351443e-316*x0[46] - 2.4391067240266175e-315*x0[47] + 0.14211035824959398*x0[48] - 0.0092550269356592631*x0[49] - 1.9036378533542899e-315*x0[50] + 0.44062410596348389*x0[51] - 0.059118784515769809*x0[52] + 2.9365397434462854e-315*x0[53] + 0.32954089211380921*x0[54] - 3.1057557498906313e-315*x0[55] + 2.6258382864594497e-315*x0[56] - 0.17364036084915935*x0[57] + 0.16771410002994902*x0[58] - 0.24045903368207214*x0[59] + 0.11001556152495123*x0[60] + 5.947857695893139e-316*x0[61] + 0.083433618994753239*x0[62] + 3.9148294302679098e-315*x0[63] + 0.17055865705869269*x0[64] + 0.17755920232087261*x0[65] + 2.9702972134761569e-315*x0[66] + 9.4946129729208331e-316*x0[67] + 7.1030706254892873e-317*x0[68] + 1.1127353392555596e-315*x0[69] - 0.074789998945546665*x0[70] - 1.8625190374122373e-316*x0[71] - 8.7482608077073458e-317*x0[72] + 3.635606545756877e-315*x0[73] - 0.091640694571276812*x0[74] - 0.0015346467034230964*x0[75] + 4.4526816489124933e-315*x0[76] + 0.056286498838058682*x0[77] + 0.077950106594501981*x0[78] - 1.5967483549172858e-315*x0[79] + 0.11036692125669507*x0[80] - 3.8148056228784653e-315*x0[81] - 1.7742441110808976e-315*x0[82] - 0.16814224709051598*x0[83] - 0.14635374818083768*x0[84] + 0.13103573985556882*x0[85] + 0.049465969972096256*x0[86] + 0.0063274215832842574*x0[87] - 0.20429488347717009*x0[88] - 3.7576017785002081e-315*x0[89] + 0.17147453466499471*x0[90] + 4.36941070837405e-315*x0[91] + 0.084097192495086986*x0[92] - 7.8281434327429567e-316*x0[93] - 1.8927611315588192e-315*x0[94] - 0.024360131964515423*x0[95] - 1.6289210995068086e-315*x0[96] - 2.7283072247301626e-316*x0[97] - 3.8862993328720454e-315*x0[98] + 3.1188031836857007e-315*x0[99] - 0.024254269088224974*x0[100] - 1.712810274269206e-315*x0[101] + 6.0884882448860039e-316*x0[102] - 3.9952889594178839e-315*x0[103] - 0.026716790992688928*x0[104] + 0.017253120347038579*x0[105] + 4.1584152856345667e-315*x0[106] - 0.011020606105697108*x0[107] - 0.099363698905047371*x0[108] - 3.0171189945835598e-315*x0[109] - 0.18200189164175046*x0[110] - 4.567685166015923e-316*x0[111] - 3.9748786728104137e-317*x0[112] - 0.040115380375649275*x0[113] + 0.072377139225336964*x0[114] + 0.034182829290026112*x0[115] + 0.074543540655131316*x0[116] - 1.4865135989527675e-315*x0[117] + 0.2211786933658508*x0[118] + 9.6762432136878818e-316*x0[119] + 0.33370705712277732*x0[120] + 0.17194692458058436*x0[121] + 5.631560426698223e-316*x0[122] - 3.7075671230824948e-315*x0[123] + 3.4629589520221197e-315*x0[124] - 3.7155303743490349e-315*x0[125] - 0.23533139072174863*x0[126] - 4.2253866052641906e-315*x0[127] - 2.6626568884178244e-315*x0[128] - 1.2078850210664607e-316*x0[129] + 0.27930827661300128*x0[130] + 0.13110947143745785*x0[131] + 9.4653685850581502e-316*x0[132] + 0.072034726970716237*x0[133] - 0.048801338977910107*x0[134] + 1.466273769933769e-315*x0[135] + 0.79263637177496837*x0[136] - 2.037720812197613e-315*x0[137] - 4.2108850720448764e-315*x0[138] + 0.17832432345053645*x0[139] + 0.26112493582174345*x0[140] - 0.13080034413340536*x0[141] + 0.018884147650994065*x0[142] + 9.4400782045591347e-316*x0[143] - 0.010182022914375*x0[144] - 7.1998780457616795e-316*x0[145] - 0.16946818608746372*x0[146] - 0.023456113839292515*x0[147] - 1.7335439811891003e-315*x0[148] - 9.1516703481931821e-316*x0[149] - 4.0084745438488435e-315*x0[150] + 3.7297396529168645e-315*x0[151] - 0.024020673460228924*x0[152] + 4.8140282732949519e-316*x0[153] - 3.6335593995753032e-316*x0[154] + 2.6849086960257258e-315*x0[155] + 0.13919898173981574*x0[156] - 0.013555132203867417*x0[157] - 2.1765002997824256e-315*x0[158] + 0.1103065489989429*x0[159] + 0.094501719337912293*x0[160] - 3.7901772014130609e-315*x0[161] - 0.12226847477492556*x0[162] + 4.2646548933890883e-316*x0[163] + 1.7521583490552506e-315*x0[164] - 0.063245371189561764*x0[165] + 0.063818714236848387*x0[166] - 0.19204719948368626*x0[167] + 0.038119739555118229*x0[168] + 1.152859032877041e-315*x0[169] + 0.28644785675094142*x0[170] - 4.5216106246132598e-315*x0[171] + 0.062298367394911729*x0[172] + 0.15179773895274531*x0[173] + 3.8130761263225722e-317*x0[174] + 7.7295827711197322e-316*x0[175] + 1.3455879346683287e-316*x0[176] + 1.6677417098093531e-316*x0[177] + 0.069908924879240511*x0[178] + 1.4852079267298464e-315*x0[179] + 1.3063738653074056e-315*x0[180] - 3.2779782100184551e-315*x0[181] + 0.18321113552533522*x0[182] - 0.077422510910335432*x0[183] - 3.2623968815081856e-316*x0[184] + 0.20299665391443966*x0[185] + 0.05711336257898162*x0[186] - 1.4675036376646487e-315*x0[187] + 0.19794979011610742*x0[188] - 1.0284381552015137e-315*x0[189] + 3.2832205627228441e-315*x0[190] + 0.19800054924888708*x0[191] - 0.063610817654348464*x0[192] + 0.0141930355424144*x0[193] + 0.20051833763403767); -x1[1] = relu(0.35595955458365103*x0[0] + 0.21849870976418062*x0[1] + 0.067010144682555478*x0[2] + 0.12823494260030222*x0[3] + 1.2917038514496597*x0[4] - 0.51822747453597884*x0[5] + 0.0089812119971229808*x0[6] - 0.35116822559537536*x0[7] + 0.14315630677246652*x0[8] + 0.22627366612950178*x0[9] + 0.13103291758869043*x0[10] - 4.0747359899585227e-315*x0[11] + 0.068026642011724731*x0[12] - 0.10419827440185407*x0[13] - 2.8301541145901355e-316*x0[14] + 7.1100988575210728e-316*x0[15] - 1.5649223999452354e-315*x0[16] + 5.3656873490981709e-316*x0[17] - 0.0010935625891157455*x0[18] - 0.24717162820414251*x0[19] + 3.9726304814362342e-315*x0[20] + 7.4359041730373806e-316*x0[21] - 0.16670304057799951*x0[22] - 0.030429018174880158*x0[23] + 4.4192149710997946e-315*x0[24] - 0.10991995643611759*x0[25] - 0.080904610088844572*x0[26] + 5.866762205443838e-316*x0[27] - 0.18151794507395252*x0[28] - 8.3207672962165093e-316*x0[29] - 3.3765053937535174e-316*x0[30] + 0.070027342362614056*x0[31] + 0.055336741948584678*x0[32] + 5.8394594461627466e-316*x0[33] - 0.12362281935667087*x0[34] + 7.7169282677328004e-316*x0[35] - 0.14472664256349044*x0[36] - 2.7400784523774288e-315*x0[37] + 0.11781354125141837*x0[38] + 0.30907512057311426*x0[39] + 7.0128448513114047e-316*x0[40] - 1.3981132095913229e-315*x0[41] + 3.8711066067548558e-316*x0[42] + 1.8117338567532395e-315*x0[43] - 0.26581557804949368*x0[44] - 0.19551779793008708*x0[45] - 3.6967750495541261e-316*x0[46] - 3.2362094408379855e-315*x0[47] - 0.037488407849211119*x0[48] - 0.095239847940959604*x0[49] + 7.8936300060563243e-317*x0[50] - 0.32934229351671684*x0[51] - 0.14290456943115476*x0[52] + 1.8404355876138128e-315*x0[53] - 0.38384930630195951*x0[54] + 2.4411568000174711e-315*x0[55] - 4.1860060802465271e-315*x0[56] - 0.12266533305053159*x0[57] - 0.21318316497122691*x0[58] - 0.11229461467432734*x0[59] + 0.12933501828345867*x0[60] - 3.7375087512065583e-315*x0[61] - 0.31465481218198599*x0[62] + 2.5306788270894175e-315*x0[63] + 0.18714272541345425*x0[64] - 0.15009999077242628*x0[65] + 4.058406221163994e-315*x0[66] - 1.1136035064677754e-315*x0[67] + 3.4353539036162768e-315*x0[68] - 1.140701910316434e-315*x0[69] + 0.010133865681169288*x0[70] - 1.6838758780146932e-315*x0[71] - 1.1245996834550976e-316*x0[72] + 2.7343863368936612e-315*x0[73] + 0.34397010262554401*x0[74] - 0.017069435803989754*x0[75] + 1.3919091630479604e-315*x0[76] - 0.63110721116486967*x0[77] + 0.034759865450227939*x0[78] - 1.2261099663905588e-316*x0[79] - 0.30905319952561228*x0[80] - 3.8462146210300209e-315*x0[81] - 4.2104227748200628e-315*x0[82] + 0.77599115846136679*x0[83] + 0.46655783329702699*x0[84] + 0.27737369858653338*x0[85] - 0.15951918463541795*x0[86] + 0.056738929761302556*x0[87] + 0.7711025054916234*x0[88] - 3.5331538078986913e-315*x0[89] + 0.36771193255369722*x0[90] + 1.8070159843758498e-315*x0[91] + 0.24298722744484058*x0[92] + 5.4658551074541877e-316*x0[93] + 1.8300568988113195e-316*x0[94] - 0.08609174518152328*x0[95] + 2.7600035072328054e-315*x0[96] - 6.3787217726264691e-316*x0[97] + 2.7740208363565693e-315*x0[98] + 1.0907798574000645e-315*x0[99] - 0.098529028830319207*x0[100] + 2.3287118611489079e-315*x0[101] + 8.6784898453329367e-316*x0[102] + 3.9471726522085302e-315*x0[103] + 0.084363624210194915*x0[104] + 0.12167924264658619*x0[105] + 7.7098464295784411e-316*x0[106] - 0.052738036403747086*x0[107] + 0.082365646736473189*x0[108] - 3.6645835107074355e-316*x0[109] + 0.030805705698796985*x0[110] + 4.3278433302321382e-315*x0[111] + 1.2639788382768935e-315*x0[112] + 0.14455176149367713*x0[113] - 0.022306931580147234*x0[114] - 0.24785041418815973*x0[115] - 0.49987769428270301*x0[116] + 3.3841667906730742e-315*x0[117] - 1.1738787440849205*x0[118] + 3.740564715208406e-315*x0[119] - 0.20900038984179647*x0[120] + 0.14145805873815104*x0[121] + 1.6358586655519258e-315*x0[122] - 4.1577041720098509e-315*x0[123] + 7.2525264220809915e-316*x0[124] - 7.82549138716921e-316*x0[125] - 0.15335613017544966*x0[126] + 1.3992438936438e-315*x0[127] - 3.9863808273662984e-315*x0[128] + 3.5820667416147431e-316*x0[129] - 0.18263171994319596*x0[130] - 0.18891601395572905*x0[131] + 1.3265058002706654e-315*x0[132] - 0.44378808143255855*x0[133] - 0.19509549026675943*x0[134] - 1.7762898195314421e-315*x0[135] - 0.15799686419746059*x0[136] - 3.7521086825398982e-315*x0[137] + 6.4191161845779327e-316*x0[138] - 0.039461670740293567*x0[139] - 0.056512943520428391*x0[140] - 0.32429827243914328*x0[141] - 0.14203445008318971*x0[142] - 3.1227067864721795e-316*x0[143] - 0.017123575555485018*x0[144] + 1.0476335245045474e-315*x0[145] - 0.31893598578317406*x0[146] - 0.084708646863697154*x0[147] - 2.9526248608143064e-315*x0[148] - 2.286877366415572e-315*x0[149] - 3.3335620279659683e-315*x0[150] - 1.1279611154000621e-314*x0[151] + 0.011470838283458514*x0[152] + 2.0388447423727114e-315*x0[153] - 2.1621940707129125e-315*x0[154] + 3.3929864405081461e-315*x0[155] - 0.034468439894934019*x0[156] - 0.02329839173520569*x0[157] + 2.2622304471323872e-316*x0[158] - 0.40589700232859077*x0[159] + 0.10081784767102071*x0[160] - 7.4711605987114828e-316*x0[161] - 0.3813702595731987*x0[162] - 9.1374562277820231e-316*x0[163] + 3.4016525248591776e-315*x0[164] - 0.36430812788300071*x0[165] - 0.24865247863859968*x0[166] - 0.18604818501531628*x0[167] - 0.26920914655018746*x0[168] - 4.3659065329589516e-315*x0[169] - 0.52953995058821468*x0[170] + 2.9339968715583003e-315*x0[171] - 0.24276519488157741*x0[172] + 0.21847197517640135*x0[173] - 6.7317088013406373e-316*x0[174] + 4.9544763638448076e-316*x0[175] + 3.281014011201296e-315*x0[176] + 1.7677181659473002e-316*x0[177] - 0.11842692925840342*x0[178] - 1.1052697603140755e-316*x0[179] - 3.7306547118995271e-316*x0[180] + 2.8758307503436075e-315*x0[181] - 0.18893292847927098*x0[182] + 0.20372791965396206*x0[183] - 2.389646024669678e-316*x0[184] - 0.3725734682795292*x0[185] - 0.046311917203790201*x0[186] + 4.1014182274917198e-315*x0[187] - 0.2827362060208492*x0[188] - 1.286496685413111e-315*x0[189] - 1.0208596279127337e-315*x0[190] - 0.11256103250379379*x0[191] - 0.16880938880406901*x0[192] + 0.072337069637963547*x0[193] + 0.38173211624652204); -x1[2] = relu(0.29194204364386095*x0[0] - 0.20823675934474145*x0[1] - 0.04785935829868216*x0[2] - 0.081434829144280671*x0[3] - 0.67762707725575522*x0[4] - 0.20211523669613735*x0[5] + 0.37015936753730894*x0[6] - 0.29343202389791789*x0[7] - 0.053966481616455175*x0[8] + 0.27982172485373574*x0[9] + 0.2506536895259846*x0[10] + 1.9891883781980495e-316*x0[11] - 0.32096461826666256*x0[12] + 0.13163556499234216*x0[13] + 3.7372309677378405e-315*x0[14] - 2.9837667028491862e-315*x0[15] + 3.4833132461699468e-316*x0[16] - 3.8861657029368147e-315*x0[17] - 0.0073924823766479426*x0[18] + 4.4254479462212236e-5*x0[19] + 3.3758066218886347e-315*x0[20] - 1.5390609833134131e-315*x0[21] + 0.36824670861726688*x0[22] + 0.28506374483984215*x0[23] - 8.5060606879015187e-316*x0[24] - 0.21890759473566568*x0[25] + 0.083407082110472874*x0[26] - 1.9337394204092251e-315*x0[27] + 0.064180170393168437*x0[28] + 1.132512100307337e-315*x0[29] + 3.4172269265690925e-315*x0[30] - 0.13914282890285229*x0[31] + 0.19216273296731928*x0[32] - 1.607143328123466e-315*x0[33] - 0.02394047422155772*x0[34] + 3.0812556372734518e-315*x0[35] - 0.24818826257336915*x0[36] - 2.2444830063736817e-315*x0[37] - 0.12226600567852904*x0[38] + 0.27008996597634899*x0[39] + 3.319987939955058e-315*x0[40] + 2.7435815062635112e-315*x0[41] - 4.4140294161820515e-315*x0[42] + 4.1716964569460271e-315*x0[43] - 0.3021055352398872*x0[44] - 0.14178638237086788*x0[45] - 1.168057420986532e-315*x0[46] + 4.0841337064805417e-315*x0[47] - 0.16479019827922697*x0[48] - 0.20166661591514004*x0[49] + 3.720824979436128e-315*x0[50] - 0.2200466391539517*x0[51] + 0.015649256194966949*x0[52] + 1.2240768072074188e-315*x0[53] - 0.2216612695694761*x0[54] + 3.5406655918593745e-315*x0[55] + 2.2326342746485524e-315*x0[56] - 0.10105838910008869*x0[57] - 0.13843669670816311*x0[58] - 0.1231140315745224*x0[59] - 0.039156397142408858*x0[60] - 2.3934137198782987e-315*x0[61] - 0.20990844674345413*x0[62] + 1.8126489651424667e-315*x0[63] - 0.2729618843688883*x0[64] + 0.33426689493537987*x0[65] + 3.1188809446776997e-315*x0[66] - 1.537835325021836e-315*x0[67] + 2.2420658988958455e-315*x0[68] - 4.3750176469404746e-316*x0[69] - 0.2977549880968699*x0[70] - 1.7893507363779865e-315*x0[71] - 1.0671275466091792e-316*x0[72] + 9.1125238472499842e-316*x0[73] + 0.10327410236506049*x0[74] - 0.328868026582124*x0[75] + 6.2021889059406937e-316*x0[76] - 0.058936274095886872*x0[77] + 0.38729608264263193*x0[78] + 4.259822382959894e-315*x0[79] - 0.18216129593805694*x0[80] - 3.8987399799441749e-315*x0[81] - 2.4716296425832867e-315*x0[82] + 0.43962701991415604*x0[83] + 0.10228340073734475*x0[84] - 0.27176830349065156*x0[85] - 0.12911630928584711*x0[86] - 0.096946494983023088*x0[87] - 0.12506854046789972*x0[88] - 7.5237006264346618e-316*x0[89] - 0.048687133002365074*x0[90] + 1.6314654140664796e-315*x0[91] - 0.43389565427809013*x0[92] - 1.1761026772689687e-315*x0[93] - 1.6929594873617122e-315*x0[94] + 0.017670803516904678*x0[95] + 4.1754649574816506e-315*x0[96] + 1.4904811881810392e-315*x0[97] - 6.1056817293612793e-316*x0[98] - 1.1119123148214044e-315*x0[99] - 0.07778284820619151*x0[100] + 2.3009333660574359e-315*x0[101] + 3.2485345704214608e-315*x0[102] - 1.0701365052054815e-315*x0[103] + 0.041041554936070951*x0[104] - 0.061562863794148888*x0[105] + 1.1755020811885712e-316*x0[106] + 0.12313724467370499*x0[107] + 0.49030460756466004*x0[108] - 2.3744098158349979e-315*x0[109] - 0.31252146881928822*x0[110] - 6.654822009095435e-316*x0[111] - 2.7582806212752537e-315*x0[112] + 0.088264417001042247*x0[113] - 0.0045235861217796658*x0[114] - 0.024457629198201679*x0[115] - 0.26330450611172579*x0[116] + 2.4222086364603341e-315*x0[117] - 0.021029180161929662*x0[118] + 1.4542644421704589e-316*x0[119] - 0.23735682974843086*x0[120] + 0.55286475576418603*x0[121] - 3.4819530488623506e-315*x0[122] + 4.3834441736818071e-315*x0[123] - 1.7546488203408377e-315*x0[124] - 1.5066733992184527e-315*x0[125] - 0.59246002077475313*x0[126] + 4.3252060572212022e-315*x0[127] + 2.4431047971052375e-315*x0[128] + 1.2932140661625026e-315*x0[129] - 0.20120044839080783*x0[130] + 0.71795686054828767*x0[131] - 3.6994598022736275e-318*x0[132] - 0.23338503932859103*x0[133] + 0.0088156123764411842*x0[134] + 7.0114868130706808e-316*x0[135] + 0.015695199977588361*x0[136] + 1.5349175017745655e-315*x0[137] + 1.478522719535312e-315*x0[138] - 0.054978806495855667*x0[139] - 0.023757816526809247*x0[140] - 0.070480796056049635*x0[141] + 0.16950688212444961*x0[142] - 2.6438124490023753e-315*x0[143] + 0.052004973184636913*x0[144] + 2.3045279011385022e-316*x0[145] - 0.11041508090885449*x0[146] + 0.1670028358702062*x0[147] + 3.6137994565181103e-315*x0[148] + 4.4243930853889113e-316*x0[149] - 8.816743839756176e-316*x0[150] - 3.4224690124780327e-316*x0[151] - 0.024096565949011484*x0[152] + 1.3980927404516157e-315*x0[153] + 1.7715912700614612e-315*x0[154] - 1.2192668607562701e-316*x0[155] + 0.12985063456993887*x0[156] - 0.29046306788409626*x0[157] - 3.1355574833270749e-317*x0[158] - 0.16115022190491157*x0[159] + 0.015419871914820117*x0[160] + 1.4108592633424291e-315*x0[161] - 0.10150753824572871*x0[162] + 9.7074318980866438e-316*x0[163] - 1.7564248084740045e-315*x0[164] - 0.035587141763902007*x0[165] - 0.14298343098193858*x0[166] - 0.28640762499134842*x0[167] - 0.21029502357147883*x0[168] + 1.6643214810881396e-315*x0[169] + 0.13052226359768129*x0[170] + 1.5966468787742865e-315*x0[171] - 0.2004122829817187*x0[172] + 0.14492248579197378*x0[173] + 2.9132320434433744e-316*x0[174] - 2.9549997997892701e-315*x0[175] + 1.1755533454399837e-315*x0[176] - 1.866051517848186e-315*x0[177] - 0.22113897197935611*x0[178] - 1.4322027263197949e-315*x0[179] - 1.6789350140487094e-316*x0[180] - 3.7036117817415835e-315*x0[181] - 0.25488032520412862*x0[182] - 0.34215634075067247*x0[183] + 3.6374313920417611e-316*x0[184] - 0.13914554599267623*x0[185] - 0.24793086128808425*x0[186] + 3.8698489181874588e-315*x0[187] - 0.1297302262010688*x0[188] + 9.4846210881124689e-316*x0[189] + 3.3413037846628213e-315*x0[190] - 0.2112723331584945*x0[191] - 0.26372430623515336*x0[192] + 0.020920978793589503*x0[193] + 0.070354441665743603); -x1[3] = relu(0.13416892103684652*x0[0] + 0.047510156729375801*x0[1] - 0.094854171226347705*x0[2] + 0.012905546275151407*x0[3] - 0.2281446184135372*x0[4] + 0.46179447950489633*x0[5] + 0.23956833181796691*x0[6] + 0.05973744950875659*x0[7] + 0.19626443709263236*x0[8] + 0.22367808286548455*x0[9] - 0.19326907620812253*x0[10] + 1.3200686584962514e-315*x0[11] - 0.2468007164855732*x0[12] + 0.37445734414648862*x0[13] - 1.502092200220672e-315*x0[14] + 3.3230231680217497e-315*x0[15] - 1.2357745919964307e-315*x0[16] + 1.5750585865067805e-315*x0[17] - 0.13221767196310852*x0[18] - 0.099056653258644059*x0[19] - 3.828349375258721e-315*x0[20] - 1.7001249757705688e-315*x0[21] - 0.12543933831463402*x0[22] + 0.47770770249719152*x0[23] - 4.8611343694189105e-316*x0[24] + 0.067544702728677547*x0[25] + 0.067531286660511877*x0[26] + 9.6483953517797337e-316*x0[27] + 0.18202992331654927*x0[28] - 6.9553177249591041e-316*x0[29] - 1.1104798604131039e-315*x0[30] + 0.10218662235616527*x0[31] + 0.0049372923665933566*x0[32] + 5.7876110115306161e-316*x0[33] - 0.26192680902476961*x0[34] - 4.7585089803207856e-316*x0[35] - 0.13105128088993784*x0[36] - 3.6561631202614244e-315*x0[37] - 0.14230006353369315*x0[38] - 0.20254268282252047*x0[39] - 1.2425833600683335e-315*x0[40] - 3.769595553076987e-315*x0[41] - 1.878287340125519e-316*x0[42] + 5.7333390366859406e-316*x0[43] + 0.31907536882364607*x0[44] + 0.00069446970936557883*x0[45] - 1.5118821356962986e-315*x0[46] - 1.563212547439421e-315*x0[47] - 0.074646473034921876*x0[48] + 0.062787952057580143*x0[49] - 1.2945806962048076e-316*x0[50] - 0.29085226082951843*x0[51] + 0.0381358596059602*x0[52] - 3.3578778442159361e-315*x0[53] - 0.21013293030579305*x0[54] - 4.2968513234856727e-316*x0[55] - 1.3103728326448447e-315*x0[56] - 0.21153855459442142*x0[57] + 0.037312436527544006*x0[58] + 0.36000613102194068*x0[59] - 0.050812737576326275*x0[60] - 3.5647860594936332e-315*x0[61] + 0.19161528780322509*x0[62] + 2.4723158552994521e-316*x0[63] - 0.26019930080352177*x0[64] - 0.25676855471928989*x0[65] - 1.9115503349291289e-314*x0[66] + 7.3908554156692695e-316*x0[67] - 9.412032963425473e-316*x0[68] - 2.2256841642766873e-316*x0[69] + 0.20737504866290105*x0[70] + 3.0130987379574414e-315*x0[71] - 7.6595193218829851e-316*x0[72] + 8.4898898205000055e-316*x0[73] - 0.068162602395390709*x0[74] + 0.22596245185089928*x0[75] - 1.2410787621944273e-315*x0[76] - 0.21577029424071759*x0[77] - 0.031873444900685922*x0[78] - 7.2917665978706408e-316*x0[79] - 0.31073090155190242*x0[80] - 4.1775606011470202e-315*x0[81] + 6.2974702068396469e-316*x0[82] - 0.89474992662359576*x0[83] + 0.034150899648201442*x0[84] - 0.48205791053867231*x0[85] + 0.10962755099489437*x0[86] + 0.0014027243945583467*x0[87] - 0.080727257803559757*x0[88] + 5.165605732721535e-316*x0[89] + 0.56090279860838754*x0[90] + 4.5341023481918564e-315*x0[91] + 0.12431891858423963*x0[92] + 8.0167077860362581e-316*x0[93] - 1.1323193850615202e-315*x0[94] + 0.096705393156629571*x0[95] + 6.0076898855161119e-316*x0[96] - 2.8795988408047449e-315*x0[97] + 4.0131171156811505e-315*x0[98] - 2.2734477283775363e-315*x0[99] + 0.02410813188866336*x0[100] - 4.1015685272018412e-315*x0[101] + 2.4012033564768902e-316*x0[102] - 1.3863778511099447e-315*x0[103] + 0.0026748885278293742*x0[104] + 0.059490405628182301*x0[105] + 2.0628969746006229e-315*x0[106] - 0.0026014331959179878*x0[107] - 0.07047302967244308*x0[108] + 3.6375937617756103e-315*x0[109] - 0.14886345292632638*x0[110] + 6.2426741765644276e-316*x0[111] - 3.6750486807605769e-315*x0[112] + 0.015715767686520853*x0[113] + 0.0080825335017057128*x0[114] + 0.29555289009468894*x0[115] + 0.22670130020161569*x0[116] - 1.2492685277376162e-315*x0[117] - 0.58262224903590565*x0[118] - 1.0917291501913274e-315*x0[119] - 0.21209079342986303*x0[120] - 0.0052721769932511115*x0[121] - 3.0321446029960436e-317*x0[122] - 4.4544126128433546e-316*x0[123] - 2.568271377941346e-315*x0[124] - 2.7638283065487725e-315*x0[125] + 0.32383779476023344*x0[126] - 3.3413517979622841e-315*x0[127] - 2.7205270247854067e-315*x0[128] - 1.8312057101323425e-315*x0[129] - 0.049989768829541883*x0[130] - 0.17967238430395124*x0[131] - 1.9951471359702211e-315*x0[132] - 0.341563886016366*x0[133] - 0.045187676745713938*x0[134] - 5.1928702019150738e-316*x0[135] - 0.22755832845958757*x0[136] + 1.6775050892565157e-315*x0[137] - 4.1843402934556652e-315*x0[138] + 0.26400976959149747*x0[139] + 0.20905229419524798*x0[140] + 0.194095075427487*x0[141] + 0.12096305775860074*x0[142] + 1.7567934357930231e-315*x0[143] - 0.013783442255454926*x0[144] + 3.7635244299549817e-315*x0[145] + 0.067473740382389652*x0[146] - 0.0011748332504337075*x0[147] - 3.527510184958063e-316*x0[148] - 2.015682925133048e-315*x0[149] + 1.6496690701018984e-315*x0[150] - 1.9502918053024569e-315*x0[151] - 0.062732666449079447*x0[152] + 4.351133599599064e-315*x0[153] - 3.4782780156656074e-315*x0[154] - 2.3952528150164088e-315*x0[155] - 0.040192180175834737*x0[156] - 0.066549074974210087*x0[157] + 2.6830112369128725e-316*x0[158] - 0.1891636510058301*x0[159] - 0.11291838284227655*x0[160] - 4.3113438647102325e-315*x0[161] - 0.014399171583824519*x0[162] - 2.4063615994457311e-316*x0[163] - 2.5558285668616878e-315*x0[164] - 0.094063356567477441*x0[165] + 0.050126597575029679*x0[166] - 0.018077743329138411*x0[167] + 0.03341105652206626*x0[168] - 1.3996575303431547e-315*x0[169] - 0.27848811905024257*x0[170] - 3.3490492666146439e-315*x0[171] - 0.14351054949058167*x0[172] - 0.19640232889270967*x0[173] + 1.1932859247040623e-316*x0[174] + 7.7885262848655305e-316*x0[175] + 3.7088828347193394e-315*x0[176] - 4.0440234069787191e-316*x0[177] + 0.22489268046626434*x0[178] - 1.8145002291174338e-315*x0[179] + 3.61630513020362e-315*x0[180] + 4.3535946146908461e-316*x0[181] + 0.0016106837869763143*x0[182] - 0.22563994957533343*x0[183] - 1.5606038709480663e-316*x0[184] - 0.49420529771196059*x0[185] - 0.061152350818013491*x0[186] + 3.1608164066664196e-315*x0[187] - 0.254898094582025*x0[188] + 1.9677824455604235e-315*x0[189] - 1.2612184490476703e-315*x0[190] - 0.052162706779991332*x0[191] + 0.032778558839055581*x0[192] - 0.13041000048315537*x0[193] - 0.085532793195484819); -x1[4] = relu(0.060993705006815932*x0[0] + 0.053969115230583092*x0[1] + 0.18209032103965594*x0[2] - 0.027874382183623831*x0[3] - 1.13506562806172*x0[4] + 0.14338624065691041*x0[5] + 0.16563484084651597*x0[6] - 0.076211525809581002*x0[7] - 0.073485643964444847*x0[8] + 0.10770903155316724*x0[9] - 0.070976767888317513*x0[10] - 2.7375845572169159e-315*x0[11] - 0.058738868527608956*x0[12] + 0.036307443519697793*x0[13] - 7.5312617082654871e-316*x0[14] - 2.7643378018647334e-317*x0[15] + 4.9742083082018507e-316*x0[16] + 1.0460199555117944e-315*x0[17] - 0.29156239365156594*x0[18] + 0.21405528100336899*x0[19] - 1.6371539376930019e-315*x0[20] - 1.6716298730443993e-315*x0[21] + 0.2582635176819244*x0[22] + 0.0026667213625620732*x0[23] - 3.7338417070513083e-315*x0[24] + 0.016498559618569164*x0[25] - 0.0076061773059896663*x0[26] + 1.41473790593248e-315*x0[27] + 0.36550420052508314*x0[28] - 2.0348531711979906e-315*x0[29] - 2.2726805679459563e-315*x0[30] + 0.31112899129052463*x0[31] + 0.17151582295692627*x0[32] + 1.3894380640763467e-315*x0[33] + 0.16962855207152697*x0[34] - 2.4705384986044463e-315*x0[35] + 0.053605302986353257*x0[36] + 1.8938985250227668e-315*x0[37] - 0.21877407603967036*x0[38] + 0.066635276421805223*x0[39] - 6.5244535988192094e-316*x0[40] - 2.5899708003945711e-315*x0[41] + 2.5638124651315675e-316*x0[42] + 3.1873781909951607e-315*x0[43] - 0.26083419538400404*x0[44] + 0.3010857324249433*x0[45] - 3.0577683789928727e-316*x0[46] + 1.0479907685510858e-315*x0[47] + 0.027474545710185063*x0[48] - 0.0029552234160596107*x0[49] + 2.4636647164342072e-316*x0[50] - 0.12049953401345563*x0[51] + 0.071493672137110442*x0[52] + 3.1433941796784327e-315*x0[53] - 0.02206014327399913*x0[54] + 2.9683840628383917e-315*x0[55] + 3.5551301837903491e-316*x0[56] - 0.068230792609540111*x0[57] - 0.10722430630503435*x0[58] - 0.073272839836553486*x0[59] - 0.037954362045998877*x0[60] + 1.2315919508144937e-315*x0[61] - 0.075889520418426726*x0[62] + 5.4322513807719891e-316*x0[63] + 0.018913287043562408*x0[64] + 0.34340322318581695*x0[65] - 9.8693016029177245e-315*x0[66] - 5.3032882414122298e-316*x0[67] + 2.4994837840657934e-316*x0[68] - 4.0770884884718522e-315*x0[69] - 0.2783271035183808*x0[70] + 1.5368160922977478e-315*x0[71] + 2.0977766603978018e-315*x0[72] + 2.3060864213369955e-315*x0[73] + 0.018983752404814782*x0[74] - 0.43193442360187473*x0[75] - 1.9125780601476035e-315*x0[76] - 0.13799670650220675*x0[77] - 0.19566167881320362*x0[78] - 8.4932861265626474e-316*x0[79] - 0.013346309729279245*x0[80] + 8.5856956214885838e-316*x0[81] + 2.6054365867129042e-315*x0[82] - 0.076603183769396746*x0[83] - 0.071055304349414108*x0[84] - 0.27977385199162547*x0[85] + 0.19333446421179093*x0[86] - 0.048459511565573786*x0[87] - 0.25558424069998859*x0[88] + 1.2907460056946108e-317*x0[89] - 0.17475486019316858*x0[90] + 1.8774958963674459e-317*x0[91] + 0.0015052131610918183*x0[92] + 1.9473596442701441e-316*x0[93] - 4.2153414700605176e-315*x0[94] - 0.039126978360831087*x0[95] + 1.7899638125565979e-315*x0[96] - 2.5694267356321764e-315*x0[97] + 3.6572081777968207e-315*x0[98] + 1.6897100917188612e-316*x0[99] - 0.14764627247712095*x0[100] + 7.5405881360554677e-316*x0[101] - 5.7537916251940078e-316*x0[102] + 8.4708665144987925e-316*x0[103] + 0.28520987698812517*x0[104] - 0.12542070500059005*x0[105] + 3.409015081232191e-315*x0[106] - 0.094762777368625858*x0[107] + 0.064653191299968771*x0[108] + 1.2805131453081439e-315*x0[109] + 0.015209825988026282*x0[110] + 2.9259502318920552e-316*x0[111] + 1.908628030012385e-315*x0[112] + 0.053647611251371359*x0[113] + 0.010808929927513897*x0[114] + 0.038948886321826352*x0[115] + 0.36430002350799179*x0[116] + 3.7820614814882142e-315*x0[117] + 0.61296850883123377*x0[118] - 1.7567039456825919e-315*x0[119] + 0.10695575937244212*x0[120] - 0.10554113556581278*x0[121] + 1.3798716933054632e-316*x0[122] - 1.802332158062115e-316*x0[123] + 3.2075051803613056e-315*x0[124] - 1.0227909700475788e-315*x0[125] + 0.33863444771783069*x0[126] - 1.6709153948326354e-315*x0[127] - 1.6143598189289429e-315*x0[128] - 3.7092587989131988e-315*x0[129] + 0.096805226339999162*x0[130] + 0.48504174806844164*x0[131] - 1.4580415246263507e-315*x0[132] + 0.0011772511625272662*x0[133] - 0.037007183409264663*x0[134] - 3.3352348700142528e-315*x0[135] + 0.1205532173469151*x0[136] + 3.0450083728279279e-315*x0[137] - 1.5014191000067473e-315*x0[138] - 0.69259834287174615*x0[139] + 0.041320449548341132*x0[140] - 0.070957616216232242*x0[141] + 0.063185075349207628*x0[142] + 4.9563393371755812e-316*x0[143] - 0.050658360039429827*x0[144] + 4.1377524919568199e-315*x0[145] + 0.098648830495825443*x0[146] + 0.13242844399131659*x0[147] + 2.5023682578819696e-315*x0[148] + 1.7000447345690278e-315*x0[149] + 1.6814783009518371e-315*x0[150] + 1.7738722130473035e-315*x0[151] + 0.18236380775781763*x0[152] + 2.21646259697938e-315*x0[153] + 4.0543462317786371e-315*x0[154] - 2.6462504851009693e-315*x0[155] - 0.14451170860920068*x0[156] - 0.11302716052166858*x0[157] - 1.3716118247877859e-315*x0[158] + 0.00066584555912307909*x0[159] - 0.11567715703788534*x0[160] + 2.2738195819452222e-315*x0[161] - 0.084196711548529229*x0[162] - 2.2167083847568731e-315*x0[163] + 3.9556990296168871e-315*x0[164] + 0.37774465022948578*x0[165] + 0.084254280687681746*x0[166] - 0.12817754182139912*x0[167] + 0.32337465577474384*x0[168] + 5.9172336791210089e-316*x0[169] + 0.36554774683102692*x0[170] + 3.2054214288560314e-316*x0[171] + 0.088448308020802072*x0[172] + 0.021965416711745293*x0[173] - 9.9632415995793785e-316*x0[174] - 4.4738236121568592e-316*x0[175] + 4.0951418349158368e-315*x0[176] - 3.3516631653798751e-315*x0[177] + 0.18779371968875808*x0[178] + 2.6738792980643773e-315*x0[179] + 3.2982673912548168e-315*x0[180] + 2.4235259192259325e-315*x0[181] + 0.067185207548842843*x0[182] + 0.23966065543676532*x0[183] - 4.0529190095255261e-316*x0[184] - 0.028358904975152147*x0[185] - 0.086523469356962007*x0[186] - 1.4715754105156589e-315*x0[187] + 0.31083280761910809*x0[188] - 2.8703240329934418e-315*x0[189] + 1.5243907414980136e-315*x0[190] + 0.25653856267672209*x0[191] + 0.26294174453199454*x0[192] - 0.43899771783012131*x0[193] - 0.070618834633514649); -x1[5] = relu(-0.16717114640072983*x0[0] - 0.007949960636605715*x0[1] - 0.064905776631083587*x0[2] - 0.031199079374833141*x0[3] + 0.68067386867708612*x0[4] + 0.32442234330631198*x0[5] - 0.0034045797250766966*x0[6] + 0.065984826317643575*x0[7] + 0.21691883969825215*x0[8] - 0.28556043583542384*x0[9] - 0.20006045069426742*x0[10] - 1.3167725785905249e-315*x0[11] - 0.20538438566650052*x0[12] - 0.0019847912161448694*x0[13] - 3.6359741058941006e-315*x0[14] - 5.9570741446703553e-316*x0[15] + 3.9973540154791195e-316*x0[16] - 1.5363701684084373e-315*x0[17] - 1.9826864811016678*x0[18] + 0.26870482252495331*x0[19] - 1.6375657068242154e-315*x0[20] - 2.0243475717530501e-316*x0[21] + 0.52784832032104889*x0[22] - 0.34429778704252201*x0[23] + 1.880569755426986e-315*x0[24] + 0.20709895071839068*x0[25] + 0.02708587741480116*x0[26] + 8.7381351299220878e-316*x0[27] - 0.32327571640141722*x0[28] - 3.7791660690586391e-315*x0[29] + 4.3753451136505382e-316*x0[30] - 0.14265651686298086*x0[31] + 0.12992469622990621*x0[32] - 2.2604606051758547e-316*x0[33] - 0.15044077939785772*x0[34] - 3.5884272587481435e-315*x0[35] - 0.059933123332877196*x0[36] + 6.7420389234901444e-316*x0[37] + 0.21034087461419274*x0[38] - 0.19087419273763842*x0[39] + 6.2115060452965325e-316*x0[40] + 1.2820803857652863e-315*x0[41] - 3.7299849318067424e-315*x0[42] - 2.8946843596174434e-315*x0[43] + 0.10811980567574854*x0[44] + 0.15478280237524811*x0[45] + 2.9771798937686776e-315*x0[46] - 1.4709226658063428e-315*x0[47] + 0.077464425731614925*x0[48] + 0.10800872892810255*x0[49] - 5.478768896492057e-316*x0[50] + 0.72517759666491499*x0[51] + 0.076384661504528467*x0[52] + 4.1010602621093385e-315*x0[53] - 0.02154912400259227*x0[54] - 4.1011467433599865e-315*x0[55] + 3.8183524509807692e-316*x0[56] + 0.21109542508873558*x0[57] + 0.14070248205262942*x0[58] + 0.24989567202116389*x0[59] + 0.52420500481868837*x0[60] - 3.6661512353489108e-315*x0[61] - 0.0021651132137535355*x0[62] - 3.3450036693615503e-315*x0[63] + 0.17386645596651459*x0[64] - 0.28403008576037014*x0[65] - 2.0247213521767548e-315*x0[66] - 6.1333864604518272e-316*x0[67] - 2.0125188496865773e-316*x0[68] - 1.1767491028786745e-315*x0[69] + 0.3041930056329098*x0[70] - 2.2158470801164781e-315*x0[71] + 5.7578183096141785e-316*x0[72] - 1.9000927989476545e-315*x0[73] - 0.18524793100626746*x0[74] - 0.23882893612279385*x0[75] - 4.1194117228233672e-315*x0[76] + 0.1139797320463917*x0[77] - 0.057203465868416903*x0[78] + 3.4882776573046113e-315*x0[79] - 0.003461601421414186*x0[80] + 2.2518040809950702e-316*x0[81] + 2.7000579048408297e-315*x0[82] + 0.49301282275764324*x0[83] + 0.010469169748950567*x0[84] + 0.77033772040323145*x0[85] - 0.14163076892936569*x0[86] - 0.029479150826341369*x0[87] + 0.21002840838771161*x0[88] + 4.0786431055517434e-315*x0[89] + 0.27815667662828503*x0[90] + 2.9780799627996453e-315*x0[91] - 0.14006653898660271*x0[92] - 2.803907316873244e-315*x0[93] - 2.9658951132749937e-315*x0[94] + 0.063988361460310145*x0[95] + 9.5535691841537295e-316*x0[96] - 4.3586658526994544e-316*x0[97] - 4.0074237502112989e-315*x0[98] + 2.7355482014290473e-316*x0[99] + 0.04134431237743743*x0[100] + 2.0196673669404993e-315*x0[101] + 5.94897745121353e-315*x0[102] - 1.9159367332300016e-315*x0[103] - 0.14203659245910352*x0[104] - 0.067226219060040296*x0[105] + 1.7053521903035692e-315*x0[106] - 0.074613475229399234*x0[107] + 0.33177602657825928*x0[108] + 2.4013114580402002e-315*x0[109] - 0.031072602514243389*x0[110] + 1.1922472406154973e-315*x0[111] - 1.5611164838182524e-315*x0[112] - 0.014008329760831649*x0[113] + 0.19126426343002889*x0[114] + 0.11081166617323193*x0[115] - 0.51042540525082203*x0[116] - 1.5949361468316224e-316*x0[117] + 1.1695971083552565*x0[118] + 7.5153273994952027e-317*x0[119] + 0.32746441176367491*x0[120] - 0.15966502821487008*x0[121] + 6.3445439910703675e-317*x0[122] + 3.8976887910541136e-315*x0[123] - 3.6921473589790718e-315*x0[124] + 2.176876609822237e-315*x0[125] - 0.096825508641554647*x0[126] - 2.6589407539000036e-316*x0[127] - 2.4168456230439178e-317*x0[128] - 3.737835669503755e-315*x0[129] + 0.20865023549350073*x0[130] + 0.11650022308677545*x0[131] + 2.4569876613228293e-315*x0[132] - 0.25362928012677327*x0[133] + 0.34068684883982592*x0[134] + 5.5534042809957254e-316*x0[135] + 0.23589858035068126*x0[136] + 2.1088192400305814e-315*x0[137] - 1.6874883279160777e-316*x0[138] - 0.71751787649165522*x0[139] - 0.43069213124142985*x0[140] + 0.16256066432026786*x0[141] + 0.1375797273509165*x0[142] + 4.1289593635656168e-315*x0[143] - 0.037611003587611311*x0[144] + 3.3372456924895444e-315*x0[145] + 0.031673841352621392*x0[146] - 0.11023775602318772*x0[147] + 2.9433693067412217e-316*x0[148] + 1.8990334431524676e-315*x0[149] + 1.1960902413098572e-316*x0[150] - 1.0970590809720981e-315*x0[151] - 0.064130557015421571*x0[152] - 4.3867255205499746e-316*x0[153] - 4.3662225324053752e-315*x0[154] - 2.8533699628488281e-315*x0[155] - 0.036772921712738486*x0[156] - 0.090099526655038037*x0[157] - 3.9715739171119462e-316*x0[158] + 0.26933971465821405*x0[159] + 0.17432955784407017*x0[160] + 2.9294467295270172e-315*x0[161] + 0.25954176755722386*x0[162] + 4.0754867029447526e-315*x0[163] - 3.9418850480316386e-315*x0[164] + 0.067607215576391072*x0[165] + 0.30525540840964466*x0[166] + 0.14098452794148472*x0[167] - 0.21714058122593197*x0[168] + 2.3274414899163821e-315*x0[169] - 0.071235777550534354*x0[170] - 2.4782108983659361e-316*x0[171] + 0.056250939662495315*x0[172] + 0.1534159567636921*x0[173] - 1.452828178516029e-315*x0[174] - 3.3245017236954636e-315*x0[175] + 3.3048865962197232e-315*x0[176] + 1.0311470529091273e-315*x0[177] - 0.042782688893969086*x0[178] + 5.0284196117852169e-316*x0[179] + 4.0258646170445991e-316*x0[180] + 8.0998576508475315e-316*x0[181] - 0.11383096747551751*x0[182] + 0.014377679274348224*x0[183] - 2.6666864828846492e-315*x0[184] + 0.42706007827524761*x0[185] + 0.187149416143785*x0[186] - 5.1779540142211745e-316*x0[187] + 0.5941774462107231*x0[188] + 1.7644745854571007e-315*x0[189] - 2.3634029423264433e-315*x0[190] + 0.22977018719465958*x0[191] - 0.20934940657240156*x0[192] - 0.46417282247016528*x0[193] - 0.1188213231064944); -x1[6] = relu(-0.52961640659221032*x0[0] - 0.048160978950549174*x0[1] - 0.45227293534588536*x0[2] + 0.15003172580478993*x0[3] + 0.73303603182434052*x0[4] - 0.90475924852883549*x0[5] - 0.060751572506808051*x0[6] + 0.11543051187536128*x0[7] + 0.044434270797200554*x0[8] - 0.14324216893504368*x0[9] - 0.10085456994561662*x0[10] + 6.8435399179914638e-317*x0[11] - 0.053354489514237276*x0[12] - 0.051214243743708338*x0[13] - 4.335497074074841e-315*x0[14] + 3.5862801976710112e-315*x0[15] - 2.7807040178819557e-315*x0[16] - 3.7623426891586634e-315*x0[17] - 0.30973458384322738*x0[18] - 0.18685973343128434*x0[19] + 8.63858525006276e-316*x0[20] - 2.43516987556283e-315*x0[21] - 0.11993394885893773*x0[22] - 0.28570955299908812*x0[23] - 2.853782576832296e-315*x0[24] - 0.042271989931022887*x0[25] + 0.21161963741995701*x0[26] - 4.8037135165870304e-316*x0[27] - 0.29278317642923979*x0[28] - 2.5763546377532609e-315*x0[29] - 7.534933159486298e-316*x0[30] - 0.43948180136853371*x0[31] - 0.29170335274604992*x0[32] + 2.3834174378856865e-316*x0[33] + 0.051958043481722629*x0[34] + 4.5527801985528407e-315*x0[35] + 0.035417737841325125*x0[36] - 2.2620068231397666e-315*x0[37] + 0.041358506221841389*x0[38] + 0.053426040939789525*x0[39] - 2.4349117756694426e-316*x0[40] + 3.2613552923136231e-316*x0[41] + 3.8734613730294998e-316*x0[42] + 4.544927983599547e-315*x0[43] - 0.020133611456257611*x0[44] + 0.044316713912594043*x0[45] - 4.3648158830457571e-316*x0[46] - 7.0559873551981665e-316*x0[47] + 0.33852971883970906*x0[48] + 0.16990426327847671*x0[49] - 1.2364515162784543e-315*x0[50] + 0.91036497626006063*x0[51] - 0.27008163429894883*x0[52] - 1.0659777817414597e-315*x0[53] + 0.087683901233774161*x0[54] + 2.731512080355041e-315*x0[55] + 3.9625378319394006e-315*x0[56] - 0.014541996662172938*x0[57] - 0.070963325317466616*x0[58] + 0.046870078148176328*x0[59] - 0.14635770935574757*x0[60] + 4.2682317755046287e-315*x0[61] + 0.32408091810746353*x0[62] + 1.4422833650807781e-315*x0[63] + 0.43381579623388838*x0[64] + 0.12864977253651272*x0[65] + 7.4805153364629701e-316*x0[66] - 7.2028051870870305e-317*x0[67] + 1.6648088867290749e-316*x0[68] - 3.6006324835400296e-315*x0[69] - 0.19511254497251701*x0[70] + 2.606135640195205e-315*x0[71] - 9.4814467657445035e-316*x0[72] - 2.1752605803825678e-315*x0[73] + 0.20178067917146097*x0[74] + 0.041303736073661383*x0[75] - 1.1717310115115893e-315*x0[76] + 0.21539197317516207*x0[77] + 0.2573086592279949*x0[78] + 4.059293133226813e-315*x0[79] + 0.048565449247707573*x0[80] - 1.2797877630675763e-315*x0[81] - 9.7345068931050025e-316*x0[82] - 0.6611501724184804*x0[83] - 0.064575996883229458*x0[84] + 0.19251430414190587*x0[85] - 0.45834891419187151*x0[86] + 0.056392078596971915*x0[87] + 0.4283387498685477*x0[88] + 5.4771045869574762e-316*x0[89] - 0.29125103935310898*x0[90] + 3.0592322115103405e-315*x0[91] + 0.31636494759825218*x0[92] + 4.2424762223187407e-315*x0[93] - 3.1766895204658101e-315*x0[94] + 0.23133756408694825*x0[95] - 2.8327034834413634e-315*x0[96] - 1.6172595198483239e-315*x0[97] - 8.4342388590312225e-316*x0[98] - 1.6889531880900889e-315*x0[99] + 0.0087190692971789718*x0[100] + 8.1131920873762701e-316*x0[101] - 8.8073658809193342e-317*x0[102] - 1.0224952322332912e-315*x0[103] + 0.16455498018153311*x0[104] + 0.081402830486836414*x0[105] + 1.045831652272195e-315*x0[106] + 0.24626306214691571*x0[107] + 0.052276752784560572*x0[108] - 1.3824083449069672e-315*x0[109] + 0.047391651405295651*x0[110] - 4.1411395688731975e-316*x0[111] - 3.4823180447988723e-315*x0[112] - 0.29978006136648178*x0[113] + 0.00076377212090853169*x0[114] - 0.1769792415234642*x0[115] + 0.099162117786272763*x0[116] + 1.418629127433874e-315*x0[117] + 0.49600070421549697*x0[118] + 2.292186897225826e-315*x0[119] + 0.11668720589699488*x0[120] - 0.23778939903906635*x0[121] + 3.6101571354077782e-315*x0[122] - 9.4583050767392516e-316*x0[123] + 3.9596766681403952e-316*x0[124] - 2.5819002183071285e-315*x0[125] + 0.14710153695066577*x0[126] - 5.8592581881951074e-316*x0[127] - 1.7807903771345085e-315*x0[128] + 1.2787831349239792e-315*x0[129] + 0.27684354617308293*x0[130] - 0.014064305328575636*x0[131] + 6.4816047181457711e-316*x0[132] + 0.09142602855113259*x0[133] - 0.13672663466058155*x0[134] + 1.642997355840152e-315*x0[135] + 0.082547994871276786*x0[136] - 1.9073994764961232e-315*x0[137] + 4.0480363958991871e-315*x0[138] + 0.033541090468917255*x0[139] + 0.011580555978234123*x0[140] - 0.044520987456319841*x0[141] - 0.037164204167237869*x0[142] + 3.2005845755898101e-316*x0[143] + 0.25365320133762181*x0[144] - 4.4814408692516167e-316*x0[145] + 0.10969003284045062*x0[146] + 0.25878617471612286*x0[147] + 2.5237753120486117e-316*x0[148] + 1.775063558479777e-315*x0[149] + 2.9118959170140436e-315*x0[150] - 3.0184465934398433e-315*x0[151] - 0.23640983096990317*x0[152] - 2.5825515796326362e-315*x0[153] + 3.0185208712690391e-315*x0[154] - 3.0365076522485595e-315*x0[155] + 0.23886913163252882*x0[156] - 0.10122102720833487*x0[157] - 2.0077609579918744e-315*x0[158] - 0.035256687222849213*x0[159] - 0.18003495800939959*x0[160] + 4.2752409415431411e-317*x0[161] - 0.10146229159714817*x0[162] - 3.6402149825937129e-315*x0[163] - 3.5679906186791241e-315*x0[164] - 0.15198092851265144*x0[165] + 0.13806602257017284*x0[166] + 0.13748663222360213*x0[167] - 0.065971238484927405*x0[168] + 3.0352125085645512e-315*x0[169] + 0.47474210974475056*x0[170] - 8.7985234892425842e-316*x0[171] + 0.19428098592836965*x0[172] + 0.10951855508268227*x0[173] + 7.8071007322274967e-316*x0[174] - 3.2758540142994124e-315*x0[175] + 8.598809605926148e-316*x0[176] + 1.2591544552275733e-315*x0[177] - 0.21603411724549237*x0[178] + 3.6944933210039069e-315*x0[179] - 2.8459034550639298e-315*x0[180] - 1.4230729959447366e-315*x0[181] + 0.21803233578264242*x0[182] - 0.24660867016782678*x0[183] - 4.2992949968732858e-315*x0[184] + 0.03445561409915953*x0[185] + 0.0028214227275506153*x0[186] - 2.0260116540174338e-315*x0[187] + 0.18046074315118898*x0[188] + 3.3234102783365792e-315*x0[189] - 1.3206933007516321e-315*x0[190] - 0.16548524953530638*x0[191] + 0.0059435295114410782*x0[192] - 0.02652285208533306*x0[193] + 0.23082926795040631); -x1[7] = relu(0.30938391165620471*x0[0] - 0.3333728555633616*x0[1] - 0.025466510136994067*x0[2] + 0.011650889902767504*x0[3] + 0.38241633052508833*x0[4] - 0.079826901542893916*x0[5] + 0.16195256100390265*x0[6] - 0.22966079168903025*x0[7] - 0.21412582355055121*x0[8] - 0.11532918094806016*x0[9] + 0.076124009452366498*x0[10] - 2.1253785418428549e-315*x0[11] - 0.20754855326863678*x0[12] - 0.072194760520443102*x0[13] - 3.5104019070440694e-315*x0[14] + 1.7614800338150311e-315*x0[15] + 2.0471841356967433e-315*x0[16] + 2.1465029114095724e-315*x0[17] - 0.2060911012875607*x0[18] - 0.099821750242749349*x0[19] - 4.0321798382395888e-315*x0[20] + 3.676654621379758e-316*x0[21] + 0.24557471198621683*x0[22] + 0.27805483693082339*x0[23] + 2.0872916338463541e-315*x0[24] - 0.10248448198783068*x0[25] + 0.015910958040345605*x0[26] - 4.0376424898748019e-315*x0[27] + 0.17106973452277319*x0[28] + 3.4063240341163616e-316*x0[29] + 3.810993150500362e-315*x0[30] - 0.1623108100903301*x0[31] - 0.11591190930630899*x0[32] + 1.1269088178266917e-315*x0[33] + 0.43934545615037884*x0[34] - 3.9786557058597409e-316*x0[35] + 0.30027577069940231*x0[36] + 4.0435211546651263e-315*x0[37] - 0.32827786831877748*x0[38] + 0.41092578545480091*x0[39] + 1.0971910261434765e-315*x0[40] + 9.1813882485708393e-316*x0[41] - 1.5539985591091209e-315*x0[42] + 7.4107891858426388e-316*x0[43] - 0.47071429996190112*x0[44] - 0.050763330933048488*x0[45] - 1.9160939449185083e-315*x0[46] - 2.5229167247692688e-316*x0[47] + 0.26154907996020899*x0[48] - 0.047644439028611263*x0[49] - 1.471757933187202e-315*x0[50] - 0.26676616050772339*x0[51] + 0.10046102373464115*x0[52] - 2.772640278603708e-315*x0[53] - 0.30171061514082304*x0[54] + 4.0965303323036267e-316*x0[55] - 7.1740614359432785e-316*x0[56] + 0.50067855116843074*x0[57] + 0.490480954231932*x0[58] - 0.15662600743466751*x0[59] - 0.17651552456318556*x0[60] + 2.8384899852261125e-315*x0[61] + 0.21465629635307329*x0[62] + 5.9773136426653712e-316*x0[63] - 0.27040339237182598*x0[64] - 0.0062455143638680396*x0[65] - 3.0414090502507534e-315*x0[66] - 9.1106791049415422e-316*x0[67] + 3.812019171686424e-316*x0[68] - 4.1071961621781701e-315*x0[69] - 0.093206884461823444*x0[70] - 2.0467387256357045e-316*x0[71] + 2.4530934210803392e-315*x0[72] - 2.0799737410077248e-315*x0[73] - 0.024412450120934199*x0[74] - 0.17076431597246722*x0[75] + 1.9752735232298895e-315*x0[76] + 0.32992875321458021*x0[77] - 0.012159794503352229*x0[78] + 2.3707467340862276e-315*x0[79] - 0.10872657683715831*x0[80] + 2.4608941692153056e-315*x0[81] + 3.0738318859295446e-315*x0[82] + 0.63446532185378157*x0[83] + 0.44929857095342501*x0[84] - 0.33227882776710949*x0[85] - 0.13780867172142511*x0[86] - 0.0014423761508124662*x0[87] - 0.060351657167083378*x0[88] - 4.0942676944499628e-315*x0[89] + 0.080145921113021434*x0[90] - 5.1456210243800795e-316*x0[91] - 0.051518171352211248*x0[92] - 4.2456055896535911e-315*x0[93] - 2.5173373155406304e-315*x0[94] + 0.11596706268078506*x0[95] - 7.9420773421890482e-316*x0[96] - 1.0476042906402829e-315*x0[97] + 3.0377725047678212e-316*x0[98] - 7.6285509907622682e-316*x0[99] + 0.16019821597894043*x0[100] - 2.5097190406706426e-315*x0[101] + 1.2185084848118731e-315*x0[102] - 1.6052712096375879e-315*x0[103] - 0.1804087490065156*x0[104] + 0.40667979687612404*x0[105] - 1.9751341374298848e-317*x0[106] - 0.076593696209061937*x0[107] - 0.15367066121766462*x0[108] - 1.2067871232102417e-315*x0[109] - 0.27565497094922847*x0[110] + 1.0351143160540727e-315*x0[111] - 4.2767466065988423e-316*x0[112] - 0.15466148483771491*x0[113] - 0.21081184739521713*x0[114] - 0.15149267325508775*x0[115] - 0.21718880079568892*x0[116] + 3.0896649606489961e-316*x0[117] - 0.53512708138901144*x0[118] + 7.7690774401235544e-316*x0[119] - 0.25045784145952554*x0[120] - 0.05958573956146871*x0[121] + 8.8847554343657445e-316*x0[122] - 2.1362366126601951e-315*x0[123] + 1.0948500640629774e-316*x0[124] + 1.0758256365327483e-315*x0[125] + 0.12412434523520838*x0[126] + 1.1661231885676587e-315*x0[127] + 3.77331653931945e-316*x0[128] - 3.8695415698304939e-315*x0[129] - 0.80324978102598132*x0[130] - 0.25007909005960444*x0[131] + 4.5585790915039876e-316*x0[132] + 0.1481057194320165*x0[133] + 0.30171367579796582*x0[134] + 9.8732808916204897e-316*x0[135] - 0.28685057286812721*x0[136] - 1.4017868149383497e-316*x0[137] - 1.5292856128930259e-315*x0[138] - 0.3971814501803359*x0[139] - 0.3825058736820397*x0[140] - 0.28039790336296216*x0[141] - 0.06216309643072522*x0[142] - 2.5508040279379244e-315*x0[143] - 0.34616478081064261*x0[144] + 9.1416968426268431e-316*x0[145] - 0.15193738947916954*x0[146] + 0.20883506634598475*x0[147] - 7.6013071735127256e-316*x0[148] - 1.1426281240498753e-315*x0[149] + 4.092387344830425e-316*x0[150] - 1.6889788893849855e-315*x0[151] + 0.092509415264150144*x0[152] - 4.3617701165588395e-316*x0[153] - 3.4859513590924807e-315*x0[154] - 3.0802208513628325e-315*x0[155] - 0.13854469614413173*x0[156] - 0.032544830801252221*x0[157] + 1.4613472437528276e-315*x0[158] - 0.29018106371466573*x0[159] + 0.064979479601049467*x0[160] + 2.7298030084729469e-316*x0[161] - 0.16835262523643138*x0[162] - 1.4523334656441917e-315*x0[163] + 3.4242228911735481e-315*x0[164] - 0.081801230930238875*x0[165] - 0.13628263414738462*x0[166] - 0.11246818971575034*x0[167] - 0.16030825798392886*x0[168] + 1.1701452287707585e-315*x0[169] - 0.13551451194163772*x0[170] - 5.7729588525178544e-316*x0[171] - 0.26302204101391263*x0[172] + 0.077432871374489745*x0[173] - 1.0298883366851869e-316*x0[174] - 9.2241709738542995e-316*x0[175] - 2.7634419126291295e-315*x0[176] - 2.0865189151762583e-316*x0[177] - 0.21883822879512743*x0[178] - 8.0797627164604888e-316*x0[179] - 3.3417840955210823e-315*x0[180] + 2.1873998078854824e-316*x0[181] - 0.054270822778704993*x0[182] + 0.43483179487044654*x0[183] - 2.279977136911311e-316*x0[184] - 0.10976128879025004*x0[185] + 0.19952434612556394*x0[186] - 2.5380562350757448e-315*x0[187] - 0.11064552230655147*x0[188] - 3.047560933343228e-316*x0[189] + 2.7509407622780103e-315*x0[190] - 0.16300029305281874*x0[191] - 0.24137601317965995*x0[192] + 0.42517087149683624*x0[193] + 0.33611230103047002); -x2[0] = relu(1.0775163903762899*x1[0] + 1.2526655885767919*x1[1] + 0.84103034302233592*x1[2] - 0.24213771763017547*x1[3] - 0.78403252947602797*x1[4] - 0.25235987805872345*x1[5] + 1.7847751957290761*x1[6] - 0.17527062652259554*x1[7] - 0.20910091583093351); -x2[1] = relu(-0.66355509924248246*x1[0] + 0.0031463822876507388*x1[1] - 0.055220933579297964*x1[2] + 0.61928702341000297*x1[3] - 0.0044464852685363781*x1[4] - 0.58230594205362085*x1[5] - 0.020741684756642901*x1[6] + 0.12824345610905036*x1[7] - 1.157831519133913); -x2[2] = relu(1.725365529563553*x1[0] + 0.71711925939746302*x1[1] + 0.70333306248182104*x1[2] - 1.2528126077681954*x1[3] + 0.20569298681374204*x1[4] + 0.6189973995756074*x1[5] + 0.8851499952711479*x1[6] + 0.04436020274688271*x1[7] + 0.32419133672011513); -x2[3] = relu(-2.0168338709662303*x1[0] - 0.44446369276548414*x1[1] - 0.86534406873688952*x1[2] + 0.74829139557469804*x1[3] + 0.51733881106813007*x1[4] - 1.1231437261962736*x1[5] - 0.60532606299384129*x1[6] + 1.2365183058922629*x1[7] + 1.3287285128435076); -x3_result[0] = sigmoid(-2.1735138393910116*x2[0] - 1.28498639108018*x2[1] - 2.1290318940128778*x2[2] + 3.2084714143673381*x2[3] + 0.61074724196189267); +x1[0] = relu(-0.16556423295607245*x0[0] + 0.082974316766689246*x0[1] - 0.070722927977365069*x0[2] + 0.1558869971408442*x0[3] - 1.4119709729810439*x0[4] - 2.1097765534499846*x0[5] - 0.12928738256404615*x0[6] + 0.097009240786868164*x0[7] - 0.22269921513249433*x0[8] - 0.31573854062714962*x0[9] - 0.10016744154350013*x0[10] - 2.8907555397204009e-315*x0[11] - 0.023407995991644236*x0[12] + 0.22046846964756034*x0[13] + 3.2078235266195469e-316*x0[14] - 7.9454434608407292e-316*x0[15] + 2.6790589439569961e-315*x0[16] - 2.2427428132965561e-315*x0[17] - 0.44812290897529489*x0[18] + 0.11780412051880074*x0[19] - 4.060998000610261e-315*x0[20] + 1.1069668115790062e-315*x0[21] + 0.21024239523690832*x0[22] - 0.31739924607606362*x0[23] + 6.2422281835059267e-316*x0[24] + 0.23561625742663317*x0[25] + 0.012574916490713841*x0[26] + 1.4336084320140295e-315*x0[27] - 0.53694554994486821*x0[28] - 1.5955856801142405e-315*x0[29] - 4.4586757224970297e-315*x0[30] + 0.13444999862326215*x0[31] + 0.056964236807352471*x0[32] - 2.7588952735232754e-316*x0[33] - 0.20816041132504173*x0[34] - 3.3410160062460881e-315*x0[35] - 0.093964201887369855*x0[36] + 2.8681410434625439e-316*x0[37] + 0.052600160234754292*x0[38] - 0.1073453660436731*x0[39] + 1.8673265332977827e-315*x0[40] + 2.7493787786793396e-316*x0[41] + 6.0787623650213606e-316*x0[42] + 1.0199772316099177e-315*x0[43] - 0.0014764594504569108*x0[44] + 0.19762800078142215*x0[45] + 6.049828003351443e-316*x0[46] - 2.4391067240266175e-315*x0[47] + 0.24645373946604948*x0[48] + 0.043879414938393591*x0[49] - 1.9036378533542899e-315*x0[50] - 0.24127064975314907*x0[51] - 0.086858580206087541*x0[52] + 2.9365397434462854e-315*x0[53] + 0.052405352987023028*x0[54] - 3.1057557498906313e-315*x0[55] + 2.6258382864594497e-315*x0[56] - 0.17945404514179875*x0[57] + 0.12500035512455551*x0[58] + 0.084418609359942456*x0[59] - 0.029797038425556095*x0[60] + 5.947857695893139e-316*x0[61] - 0.016631529166626847*x0[62] + 3.9148294302679098e-315*x0[63] + 0.10447658962629225*x0[64] + 0.19580220380787028*x0[65] + 2.9702972134761569e-315*x0[66] + 9.4946129729208331e-316*x0[67] + 7.1030706254892873e-317*x0[68] + 1.1127353392555596e-315*x0[69] - 0.093047630265211109*x0[70] - 1.8625190374122373e-316*x0[71] - 8.7482608077073458e-317*x0[72] + 3.635606545756877e-315*x0[73] - 0.052147909363746914*x0[74] - 0.26018220107046747*x0[75] + 4.4526816489124933e-315*x0[76] - 0.21338391457092676*x0[77] + 0.22593490384148873*x0[78] - 1.5967483549172858e-315*x0[79] - 0.16969265324655797*x0[80] - 3.8148056228784653e-315*x0[81] - 1.7742441110808976e-315*x0[82] - 0.38544407657664892*x0[83] - 0.21240420573551816*x0[84] + 0.29902522689253713*x0[85] + 0.068522370854487993*x0[86] + 0.098638805740658295*x0[87] + 0.016425467095267016*x0[88] - 3.7576017785002081e-315*x0[89] - 0.030431523054088468*x0[90] + 4.36941070837405e-315*x0[91] + 0.063172325950318645*x0[92] - 7.8281434327429567e-316*x0[93] - 1.8927611315588192e-315*x0[94] - 0.025294287664367303*x0[95] - 1.6289210995068086e-315*x0[96] - 2.7283072247301626e-316*x0[97] - 3.8862993328720454e-315*x0[98] + 3.1188031836857007e-315*x0[99] - 0.023314246802055742*x0[100] - 1.712810274269206e-315*x0[101] + 6.0884882448860039e-316*x0[102] - 3.9952889594178839e-315*x0[103] - 0.12978525852773426*x0[104] + 0.03777613750954173*x0[105] + 4.1584152856345667e-315*x0[106] - 0.024900803629977802*x0[107] - 0.038676464429491922*x0[108] - 3.0171189945835598e-315*x0[109] - 0.0097436836477277876*x0[110] - 4.567685166015923e-316*x0[111] - 3.9748786728104137e-317*x0[112] - 0.1315147586125838*x0[113] + 0.036584245967938571*x0[114] + 0.35522027089812058*x0[115] + 0.088688347650989749*x0[116] - 1.4865135989527675e-315*x0[117] + 0.038989267952152136*x0[118] + 9.6762432136878818e-316*x0[119] - 0.20602109968973448*x0[120] + 0.060814263937814847*x0[121] + 5.631560426698223e-316*x0[122] - 3.7075671230824948e-315*x0[123] + 3.4629589520221197e-315*x0[124] - 3.7155303743490349e-315*x0[125] - 0.12419192997888814*x0[126] - 4.2253866052641906e-315*x0[127] - 2.6626568884178244e-315*x0[128] - 1.2078850210664607e-316*x0[129] + 0.3148480242647948*x0[130] + 0.14690383097096657*x0[131] + 9.4653685850581502e-316*x0[132] - 0.11143746018007494*x0[133] - 0.25766352104691681*x0[134] + 1.466273769933769e-315*x0[135] + 0.17357021951233403*x0[136] - 2.037720812197613e-315*x0[137] - 1.7442481307951351e-315*x0[138] + 0.010272590793254302*x0[139] + 0.24597142284889759*x0[140] + 0.19254417214120217*x0[141] + 0.077370851329911935*x0[142] + 9.4400782045591347e-316*x0[143] - 0.046131622465092281*x0[144] - 7.1998780457616795e-316*x0[145] + 0.12737566053610352*x0[146] + 0.013932518885668365*x0[147] - 1.7335439811891003e-315*x0[148] - 9.1516703481931821e-316*x0[149] - 4.0084745438488435e-315*x0[150] + 3.7297396529168645e-315*x0[151] - 0.061403949296831718*x0[152] + 4.8140282732949519e-316*x0[153] - 3.6335593995753032e-316*x0[154] + 2.6849086960257258e-315*x0[155] + 0.0056548893410976299*x0[156] - 0.0037009159116067119*x0[157] - 2.1765002997824256e-315*x0[158] + 0.40284176535921951*x0[159] + 0.11919998592763914*x0[160] - 3.7901772014130609e-315*x0[161] + 0.14495943558718627*x0[162] + 4.2646548933890883e-316*x0[163] + 1.7521583490552506e-315*x0[164] + 0.25014622509862233*x0[165] + 0.58430270629998138*x0[166] + 0.13454630996969805*x0[167] + 0.10472780005713632*x0[168] + 1.152859032877041e-315*x0[169] + 0.25625650253016041*x0[170] - 4.5216106246132598e-315*x0[171] - 0.081496953684469173*x0[172] + 0.22182386372701268*x0[173] + 3.8130761263225722e-317*x0[174] + 7.7295827711197322e-316*x0[175] + 1.3455879346683287e-316*x0[176] + 1.6677417098093531e-316*x0[177] - 0.0001436789837231135*x0[178] + 1.4852079267298464e-315*x0[179] + 1.3063738653074056e-315*x0[180] - 3.2779782100184551e-315*x0[181] + 0.29474819142155179*x0[182] - 0.065379164746487903*x0[183] - 3.2623968815081856e-316*x0[184] + 0.015522429424791295*x0[185] - 0.1357282802625184*x0[186] - 1.4675036376646487e-315*x0[187] - 0.047104945698932921*x0[188] - 1.0284381552015137e-315*x0[189] + 3.2832205627228441e-315*x0[190] - 0.075819496789809149*x0[191] - 0.036774903539201917*x0[192] + 0.11746425877049586*x0[193] - 0.12740327785667965); +x1[1] = relu(0.16361118768631158*x0[0] + 0.18640325164741592*x0[1] + 0.089326361227807127*x0[2] + 0.09315222543841091*x0[3] + 0.92606428143778707*x0[4] - 0.59460062459548635*x0[5] - 0.10736709967806669*x0[6] - 0.28151680344792246*x0[7] + 0.051314994622633038*x0[8] + 0.10992110123039787*x0[9] - 0.029724198811366401*x0[10] - 4.0747359899585227e-315*x0[11] - 0.017169961468298165*x0[12] - 0.089564218370592932*x0[13] - 2.8301541145901355e-316*x0[14] + 7.1100988575210728e-316*x0[15] - 1.5649223999452354e-315*x0[16] + 5.3656873490981709e-316*x0[17] - 0.17498866186628784*x0[18] - 0.17741104905752436*x0[19] + 3.9726304814362342e-315*x0[20] + 7.4359041730373806e-316*x0[21] - 0.046091790140453191*x0[22] - 0.03532176407184702*x0[23] + 4.4192149710997946e-315*x0[24] + 0.033759238134656679*x0[25] - 0.11895463464203426*x0[26] + 5.866762205443838e-316*x0[27] - 0.50206519920556714*x0[28] - 8.3207672962165093e-316*x0[29] - 3.3765053937535174e-316*x0[30] + 0.17069318379287285*x0[31] + 0.057540604542752005*x0[32] + 5.8394594461627466e-316*x0[33] - 0.19399815200435874*x0[34] + 7.7169282677328004e-316*x0[35] - 0.1719059201329918*x0[36] - 2.7400784523774288e-315*x0[37] + 0.14606011598730514*x0[38] + 0.20192050860406899*x0[39] + 7.0128448513114047e-316*x0[40] - 1.3981132095913229e-315*x0[41] + 3.8711066067548558e-316*x0[42] + 1.8117338567532395e-315*x0[43] - 0.15865988636337147*x0[44] - 0.12607955633754214*x0[45] - 3.6967750495541261e-316*x0[46] - 3.2362094408379855e-315*x0[47] - 0.10385140116373275*x0[48] + 0.012262380603050025*x0[49] + 7.8936300060563243e-317*x0[50] + 0.12126916008995091*x0[51] - 0.08510299216812689*x0[52] + 1.8404355876138128e-315*x0[53] - 0.31426611137793953*x0[54] + 2.4411568000174711e-315*x0[55] - 4.1860060802465271e-315*x0[56] - 0.29850559250132974*x0[57] - 0.33614211469613636*x0[58] - 0.043375721380811479*x0[59] + 0.2447690842859509*x0[60] - 3.7375087512065583e-315*x0[61] - 0.63510862602688989*x0[62] + 2.5306788270894175e-315*x0[63] + 0.38772750698875297*x0[64] + 0.18579495468370216*x0[65] + 4.058406221163994e-315*x0[66] - 1.1136035064677754e-315*x0[67] + 3.4353539036162768e-315*x0[68] - 1.140701910316434e-315*x0[69] - 0.32574450850590603*x0[70] - 1.6838758780146932e-315*x0[71] - 1.1245996834550976e-316*x0[72] + 2.7343863368936612e-315*x0[73] + 0.046836272835482619*x0[74] - 0.19800836202633987*x0[75] + 1.3919091630479604e-315*x0[76] - 0.3273240714600244*x0[77] + 0.19463003262041778*x0[78] - 1.2261099663905588e-316*x0[79] - 0.23972839599390333*x0[80] - 3.8462146210300209e-315*x0[81] - 4.2104227748200628e-315*x0[82] + 0.94346665821912401*x0[83] + 0.38663913597753879*x0[84] + 0.26909833266696026*x0[85] - 0.058527157104441452*x0[86] + 0.022193226199336381*x0[87] + 0.8706854839799093*x0[88] - 3.5331538078986913e-315*x0[89] + 0.26866762273720068*x0[90] + 1.8070159843758498e-315*x0[91] + 0.16207370779724597*x0[92] + 5.4658551074541877e-316*x0[93] + 1.8300568988113195e-316*x0[94] - 0.14038844887667828*x0[95] + 2.7600035072328054e-315*x0[96] - 6.3787217726264691e-316*x0[97] + 2.7740208363565693e-315*x0[98] + 1.0907798574000645e-315*x0[99] - 0.044223703515797859*x0[100] + 2.3287118611489079e-315*x0[101] + 8.6784898453329367e-316*x0[102] + 3.9471726522085302e-315*x0[103] - 0.057912663211742918*x0[104] - 0.032483348315396898*x0[105] + 7.7098464295784411e-316*x0[106] + 0.0078606104723038424*x0[107] + 0.11394468726553499*x0[108] - 3.6645835107074355e-316*x0[109] - 0.0031695404658739074*x0[110] + 4.3278433302321382e-315*x0[111] + 1.2639788382768935e-315*x0[112] + 0.044057293916553858*x0[113] - 0.11521152329592375*x0[114] - 0.17808559920788253*x0[115] - 1.0695630147830548*x0[116] + 3.3841667906730742e-315*x0[117] - 1.1148388166842469*x0[118] + 3.740564715208406e-315*x0[119] - 0.067580796405067894*x0[120] + 0.23499537440750751*x0[121] + 1.6358586655519258e-315*x0[122] - 4.1577041720098509e-315*x0[123] + 7.2525264220809915e-316*x0[124] - 7.82549138716921e-316*x0[125] - 0.24689280523397716*x0[126] + 1.3992438936438e-315*x0[127] - 3.9863808273662984e-315*x0[128] + 3.5820667416147431e-316*x0[129] - 0.56143721177062678*x0[130] - 0.037260082718270388*x0[131] + 1.3265058002706654e-315*x0[132] + 0.063295970300649484*x0[133] - 0.29477661936020239*x0[134] - 1.7762898195314421e-315*x0[135] + 0.061931509897609156*x0[136] - 3.7521086825398982e-315*x0[137] + 6.4191161845779327e-316*x0[138] - 0.20844032023211309*x0[139] - 0.09031889422662627*x0[140] - 0.25405640308172794*x0[141] - 0.097788321284511884*x0[142] - 3.1227067864721795e-316*x0[143] + 0.053554967211260067*x0[144] + 1.0476335245045474e-315*x0[145] - 0.24928774225906722*x0[146] - 0.084001586648459359*x0[147] - 2.9526248608143064e-315*x0[148] - 2.286877366415572e-315*x0[149] - 3.3335620279659683e-315*x0[150] - 9.1976489371067664e-316*x0[151] + 0.010767059663905489*x0[152] + 2.0388447423727114e-315*x0[153] - 2.1621940707129125e-315*x0[154] + 3.3929864405081461e-315*x0[155] - 0.040148469281403122*x0[156] - 0.062987418837505985*x0[157] + 2.2622304471323872e-316*x0[158] - 0.33605101746293781*x0[159] + 0.057919809031597831*x0[160] - 7.4711605987114828e-316*x0[161] - 0.31158569462227287*x0[162] - 9.1374562277820231e-316*x0[163] + 3.4016525248591776e-315*x0[164] - 0.29483692099962533*x0[165] - 0.17599519019407897*x0[166] - 0.11676235657248291*x0[167] - 0.17535198504878158*x0[168] - 4.3659065329589516e-315*x0[169] + 0.025890054667003323*x0[170] + 2.9339968715583003e-315*x0[171] - 0.17350392130791334*x0[172] + 0.17707821716648792*x0[173] - 6.7317088013406373e-316*x0[174] + 4.9544763638448076e-316*x0[175] + 3.281014011201296e-315*x0[176] + 1.7677181659473002e-316*x0[177] - 0.077037704363882145*x0[178] - 1.1052697603140755e-316*x0[179] - 3.7306547118995271e-316*x0[180] + 2.8758307503436075e-315*x0[181] - 0.095777881030916334*x0[182] + 0.062021258441814393*x0[183] - 2.389646024669678e-316*x0[184] - 0.29123479765125376*x0[185] - 0.14502628343229398*x0[186] + 4.1014182274917198e-315*x0[187] - 0.21344508402332721*x0[188] - 1.286496685413111e-315*x0[189] - 1.0208596279127337e-315*x0[190] + 0.077135398003818897*x0[191] - 0.079724677391178445*x0[192] - 0.01628231845105324*x0[193] + 0.31263168925764606); +x1[2] = relu(0.1702442664303645*x0[0] - 0.26048644724726788*x0[1] - 0.016119224474414478*x0[2] - 0.024551490525421556*x0[3] - 0.29708121036055696*x0[4] - 2.1343571618773134*x0[5] + 0.19306413191708457*x0[6] - 0.081035067948088443*x0[7] - 0.35896811695686148*x0[8] + 0.10262840485110895*x0[9] - 0.22257917339561636*x0[10] + 1.9891883781980495e-316*x0[11] - 0.027332287166827007*x0[12] - 0.023486382115482558*x0[13] + 3.7372309677378405e-315*x0[14] - 2.9837667028491862e-315*x0[15] + 3.4833132461699468e-316*x0[16] - 3.8861657029368147e-315*x0[17] + 0.11890972952789311*x0[18] + 0.21561583753604688*x0[19] + 3.3758066218886347e-315*x0[20] - 1.5390609833134131e-315*x0[21] + 0.089575806757818163*x0[22] + 0.34683038863864585*x0[23] - 8.5060606879015187e-316*x0[24] - 0.078054822431138773*x0[25] + 0.15509036973783183*x0[26] - 1.9337394204092251e-315*x0[27] + 0.27927482755981109*x0[28] + 1.132512100307337e-315*x0[29] + 3.4172269265690925e-315*x0[30] - 0.062271606627618888*x0[31] - 0.055872752897774394*x0[32] - 1.607143328123466e-315*x0[33] - 0.12180310771838465*x0[34] + 3.0812556372734518e-315*x0[35] - 0.15740516969547586*x0[36] - 2.2444830063736817e-315*x0[37] + 0.3516636676348443*x0[38] + 0.078289205826371847*x0[39] + 3.319987939955058e-315*x0[40] + 2.7435815062635112e-315*x0[41] - 4.4140294161820515e-315*x0[42] + 4.1716964569460271e-315*x0[43] - 0.11039377081343789*x0[44] + 0.057047405180536088*x0[45] - 1.168057420986532e-315*x0[46] + 4.0841337064805417e-315*x0[47] - 0.046449574010417542*x0[48] - 0.027692190541673749*x0[49] + 3.720824979436128e-315*x0[50] - 0.05878776257656728*x0[51] + 0.0081906332354465417*x0[52] + 1.2240768072074188e-315*x0[53] + 0.069177837226000793*x0[54] + 3.5406655918593745e-315*x0[55] + 2.2326342746485524e-315*x0[56] - 0.071879830951788959*x0[57] - 0.09484964178180838*x0[58] + 0.078251622504937154*x0[59] - 0.03461975870266016*x0[60] - 2.3934137198782987e-315*x0[61] + 0.18637185584916813*x0[62] + 1.8126489651424667e-315*x0[63] - 0.15510536155890858*x0[64] + 0.2038500587489131*x0[65] + 3.1188809446776997e-315*x0[66] - 1.537835325021836e-315*x0[67] + 2.2420658988958455e-315*x0[68] - 4.3750176469404746e-316*x0[69] - 0.16728269974657661*x0[70] - 1.7893507363779865e-315*x0[71] - 1.0671275466091792e-316*x0[72] + 9.1125238472499842e-316*x0[73] + 0.30095491373817801*x0[74] - 0.081725596397782846*x0[75] + 6.2021889059406937e-316*x0[76] + 0.10321979796662095*x0[77] + 0.17947564240857669*x0[78] + 4.259822382959894e-315*x0[79] + 0.067382040596557724*x0[80] - 3.8987399799441749e-315*x0[81] - 2.4716296425832867e-315*x0[82] - 0.18793020115456327*x0[83] - 0.097030175716786946*x0[84] + 0.032456210946033813*x0[85] - 0.052591550087735153*x0[86] - 0.039707970508244692*x0[87] + 0.081670312413103227*x0[88] - 7.5237006264346618e-316*x0[89] - 0.047188514090880478*x0[90] + 1.6314654140664796e-315*x0[91] - 0.08446715600917902*x0[92] - 1.1761026772689687e-315*x0[93] - 1.6929594873617122e-315*x0[94] + 0.010561952765896679*x0[95] + 4.1754649574816506e-315*x0[96] + 1.4904811881810392e-315*x0[97] - 6.1056817293612793e-316*x0[98] - 1.1119123148214044e-315*x0[99] - 0.070798766680634964*x0[100] + 2.3009333660574359e-315*x0[101] + 3.2485345704214608e-315*x0[102] - 1.0701365052054815e-315*x0[103] + 0.24522320067527253*x0[104] - 0.22404247307810843*x0[105] + 1.1755020811885712e-316*x0[106] + 0.041368677308169406*x0[107] + 0.074052632141589678*x0[108] - 2.3744098158349979e-315*x0[109] - 0.093187761394946778*x0[110] - 6.654822009095435e-316*x0[111] - 2.7582806212752537e-315*x0[112] + 0.22206739176268181*x0[113] + 0.1593163719201672*x0[114] + 0.18855107642269348*x0[115] - 0.058175960776775067*x0[116] + 2.4222086364603341e-315*x0[117] + 0.19497169597187061*x0[118] + 1.4542644421704589e-316*x0[119] - 0.038166235609970636*x0[120] + 0.20434121183384715*x0[121] - 3.4819530488623506e-315*x0[122] + 4.3834441736818071e-315*x0[123] - 1.7546488203408377e-315*x0[124] - 1.5066733992184527e-315*x0[125] - 0.24397434879534341*x0[126] + 4.3252060572212022e-315*x0[127] + 2.4431047971052375e-315*x0[128] + 1.2932140661625026e-315*x0[129] - 0.0042881163245358468*x0[130] - 0.24491871064343373*x0[131] - 3.6994598022736275e-318*x0[132] - 0.10565097495292988*x0[133] - 0.53110591652716233*x0[134] + 7.0114868130706808e-316*x0[135] + 0.44890199677702969*x0[136] + 1.5349175017745655e-315*x0[137] + 1.478522719535312e-315*x0[138] + 0.193697587607224*x0[139] + 0.16146487854973576*x0[140] + 0.1370972373853144*x0[141] + 0.013592369411314675*x0[142] - 2.6438124490023753e-315*x0[143] - 0.22195326088078218*x0[144] + 2.3045279011385022e-316*x0[145] + 0.1068951749839316*x0[146] + 0.11647947748584336*x0[147] + 3.6137994565181103e-315*x0[148] + 4.4243930853889113e-316*x0[149] - 8.816743839756176e-316*x0[150] - 3.4224690124780327e-316*x0[151] + 0.026579254564368351*x0[152] + 1.3980927404516157e-315*x0[153] + 1.7715912700614612e-315*x0[154] - 1.2192668607562701e-316*x0[155] - 0.20012344898197773*x0[156] + 0.095018549002521074*x0[157] - 3.1355574833270749e-317*x0[158] + 0.077308074006573579*x0[159] + 0.10181457654714247*x0[160] + 1.4108592633424291e-315*x0[161] + 0.11748505264423285*x0[162] + 9.7074318980866438e-316*x0[163] - 1.7564248084740045e-315*x0[164] + 0.19045202641689443*x0[165] + 0.084485143892374409*x0[166] - 0.072662900441799488*x0[167] - 0.070545923636236144*x0[168] + 1.6643214810881396e-315*x0[169] + 0.30526580046031149*x0[170] + 1.5966468787742865e-315*x0[171] - 0.07329947254245249*x0[172] + 0.20751568481465996*x0[173] + 2.9132320434433744e-316*x0[174] - 2.9549997997892701e-315*x0[175] + 1.1755533454399837e-315*x0[176] - 1.866051517848186e-315*x0[177] - 0.28380431736558287*x0[178] - 1.4322027263197949e-315*x0[179] - 1.6789350140487094e-316*x0[180] - 3.7036117817415835e-315*x0[181] - 0.11605188817725882*x0[182] + 0.046591980266523843*x0[183] + 3.6374313920417611e-316*x0[184] - 0.0077477214572164296*x0[185] - 0.8350520750252971*x0[186] + 3.8698489181874588e-315*x0[187] + 0.078684707090775977*x0[188] + 9.4846210881124689e-316*x0[189] + 3.3413037846628213e-315*x0[190] + 0.045447156532637589*x0[191] - 0.11645568405663147*x0[192] + 0.08144328173929237*x0[193] - 0.16036145298517582); +x1[3] = relu(0.33915185155107158*x0[0] + 0.20127567676435479*x0[1] + 0.028385822762779383*x0[2] - 0.071140332437234249*x0[3] - 0.43531423889196735*x0[4] + 0.18294571946940258*x0[5] - 0.01812576054660546*x0[6] - 0.11088089835294598*x0[7] + 0.16329261666600275*x0[8] - 0.034012300830118046*x0[9] - 0.40392466072711852*x0[10] + 1.3200686584962514e-315*x0[11] - 0.17434210615497747*x0[12] + 0.012132417124453346*x0[13] - 1.502092200220672e-315*x0[14] + 3.3230231680217497e-315*x0[15] - 1.2357745919964307e-315*x0[16] + 1.5750585865067805e-315*x0[17] - 0.088700150253639184*x0[18] - 0.13639410480438152*x0[19] - 3.828349375258721e-315*x0[20] - 1.7001249757705688e-315*x0[21] - 0.61473686784263271*x0[22] - 0.094130648706502965*x0[23] - 4.8611343694189105e-316*x0[24] + 0.10926679463213283*x0[25] + 0.0061005540147055157*x0[26] + 9.6483953517797337e-316*x0[27] + 0.29830735245991896*x0[28] - 6.9553177249591041e-316*x0[29] - 1.1104798604131039e-315*x0[30] - 0.10526589511822355*x0[31] - 0.25720102900866326*x0[32] + 5.7876110115306161e-316*x0[33] - 0.22075152474643092*x0[34] - 4.7585089803207856e-316*x0[35] - 0.37317656167665558*x0[36] - 3.6561631202614244e-315*x0[37] - 0.21045075660321749*x0[38] - 0.20598850669616267*x0[39] - 1.2425833600683335e-315*x0[40] - 3.769595553076987e-315*x0[41] - 1.878287340125519e-316*x0[42] + 5.7333390366859406e-316*x0[43] + 0.32253591560365918*x0[44] - 0.039988660521900241*x0[45] - 1.5118821356962986e-315*x0[46] - 1.563212547439421e-315*x0[47] - 0.35489245296328553*x0[48] + 0.19942176300190384*x0[49] - 1.2945806962048076e-316*x0[50] - 0.80427107585573587*x0[51] - 0.035992795297983132*x0[52] - 3.3578778442159361e-315*x0[53] - 0.1209989185384366*x0[54] - 4.2968513234856727e-316*x0[55] - 1.3103728326448447e-315*x0[56] - 0.33112094397905445*x0[57] - 0.14267270972985222*x0[58] + 0.13923971693707587*x0[59] - 0.33876155124556961*x0[60] - 3.5647860594936332e-315*x0[61] - 0.23126401734288798*x0[62] + 2.4723158552994521e-316*x0[63] - 0.23089042386845746*x0[64] + 0.19817801047137332*x0[65] - 3.6918762404559164e-316*x0[66] + 7.3908554156692695e-316*x0[67] - 9.412032963425473e-316*x0[68] - 2.2256841642766873e-316*x0[69] - 0.24755611461342633*x0[70] + 3.0130987379574414e-315*x0[71] - 7.6595193218829851e-316*x0[72] + 8.4898898205000055e-316*x0[73] - 0.27278959605780706*x0[74] - 0.65436848593727948*x0[75] - 1.2410787621944273e-315*x0[76] - 0.40296067913993183*x0[77] + 0.042809081843081125*x0[78] - 7.2917665978706408e-316*x0[79] - 0.15665737037534228*x0[80] - 4.1775606011470202e-315*x0[81] + 6.2974702068396469e-316*x0[82] - 0.62669165872472099*x0[83] + 0.035245624602095647*x0[84] - 0.064307383667904769*x0[85] - 0.087451592647154824*x0[86] - 0.082468250398803386*x0[87] - 0.32196801001453718*x0[88] + 5.165605732721535e-316*x0[89] + 0.23617093169630377*x0[90] + 4.5341023481918564e-315*x0[91] - 0.27159970728591126*x0[92] + 8.0167077860362581e-316*x0[93] - 1.1323193850615202e-315*x0[94] + 0.061260492853105551*x0[95] + 6.0076898855161119e-316*x0[96] - 2.8795988408047449e-315*x0[97] + 4.0131171156811505e-315*x0[98] - 2.2734477283775363e-315*x0[99] + 0.059537835319846424*x0[100] - 4.1015685272018412e-315*x0[101] + 2.4012033564768902e-316*x0[102] - 1.3863778511099447e-315*x0[103] - 0.31266861636622989*x0[104] - 0.259525117201236*x0[105] + 2.0628969746006229e-315*x0[106] + 0.004176732499957818*x0[107] + 0.031758891343788932*x0[108] + 3.6375937617756103e-315*x0[109] - 0.19064100693084352*x0[110] + 6.2426741765644276e-316*x0[111] - 3.6750486807605769e-315*x0[112] - 0.062741019996422731*x0[113] - 0.10551195688514121*x0[114] + 0.077856823999104235*x0[115] + 0.61914699497350478*x0[116] - 1.2492685277376162e-315*x0[117] + 0.59552395056104568*x0[118] - 1.0917291501913274e-315*x0[119] - 0.099654791416629973*x0[120] + 0.36537578309459295*x0[121] - 3.0321446029960436e-317*x0[122] - 4.4544126128433546e-316*x0[123] - 2.568271377941346e-315*x0[124] - 2.7638283065487725e-315*x0[125] - 0.046890140564114648*x0[126] - 3.3413517979622841e-315*x0[127] - 2.7205270247854067e-315*x0[128] - 1.8312057101323425e-315*x0[129] - 0.32727396715027957*x0[130] + 0.41130019586238686*x0[131] - 1.9951471359702211e-315*x0[132] - 0.3816644797820723*x0[133] + 0.014517365125678342*x0[134] - 5.1928702019150738e-316*x0[135] - 0.39626392462722282*x0[136] + 1.6775050892565157e-315*x0[137] - 4.1843402934556652e-315*x0[138] - 0.7088175719769868*x0[139] - 0.31995124270197839*x0[140] - 0.018767804954102244*x0[141] + 0.26661647695564994*x0[142] + 1.7567934357930231e-315*x0[143] - 0.19938201681865309*x0[144] + 3.7635244299549817e-315*x0[145] + 0.013612546018600631*x0[146] + 0.13250299007722682*x0[147] - 3.527510184958063e-316*x0[148] - 2.015682925133048e-315*x0[149] + 1.6496690701018984e-315*x0[150] - 1.9502918053024569e-315*x0[151] - 0.19639380715523888*x0[152] + 4.351133599599064e-315*x0[153] - 3.4782780156656074e-315*x0[154] - 2.3952528150164088e-315*x0[155] - 0.35610387542581318*x0[156] - 0.26697275999278991*x0[157] + 2.6830112369128725e-316*x0[158] - 0.30948208269455951*x0[159] - 0.073079969845820131*x0[160] - 4.3113438647102325e-315*x0[161] - 0.01412482789112162*x0[162] - 2.4063615994457311e-316*x0[163] - 2.5558285668616878e-315*x0[164] - 0.14763564603522489*x0[165] - 0.057598151543755055*x0[166] - 0.20831936416719468*x0[167] + 0.046004371144909163*x0[168] - 1.3996575303431547e-315*x0[169] - 0.65881611669478424*x0[170] - 3.3490492666146439e-315*x0[171] - 0.030290108681582099*x0[172] - 0.29449380944713699*x0[173] + 1.1932859247040623e-316*x0[174] + 7.7885262848655305e-316*x0[175] + 3.7088828347193394e-315*x0[176] - 4.0440234069787191e-316*x0[177] + 0.32297650796664101*x0[178] - 1.8145002291174338e-315*x0[179] + 3.61630513020362e-315*x0[180] + 4.3535946146908461e-316*x0[181] - 0.28136731091890738*x0[182] - 0.066863770388969415*x0[183] - 1.5606038709480663e-316*x0[184] + 0.064562245425370562*x0[185] - 0.0049144724996739286*x0[186] + 3.1608164066664196e-315*x0[187] - 0.50320303876117711*x0[188] + 1.9677824455604235e-315*x0[189] - 1.2612184490476703e-315*x0[190] + 0.35894088621069026*x0[191] - 0.023912911886548784*x0[192] - 0.91619798401419517*x0[193] - 0.041954501357514822); +x1[4] = relu(0.12420968635455001*x0[0] + 0.11664330339354495*x0[1] + 0.27146842030875257*x0[2] - 0.19470012758209881*x0[3] - 0.79731290394514076*x0[4] + 0.18453664437093423*x0[5] + 0.4022809529840583*x0[6] - 0.18413761279680566*x0[7] + 0.13752518152169482*x0[8] + 0.34435732919026052*x0[9] + 0.32395017540132359*x0[10] - 2.7375845572169159e-315*x0[11] - 0.050311007279280562*x0[12] - 0.097013541037693773*x0[13] - 7.5312617082654871e-316*x0[14] - 2.7643378018647334e-317*x0[15] + 4.9742083082018507e-316*x0[16] + 1.0460199555117944e-315*x0[17] + 0.34645832509821367*x0[18] + 0.075003046537570131*x0[19] - 1.6371539376930019e-315*x0[20] - 1.6716298730443993e-315*x0[21] + 0.087553792943819583*x0[22] + 0.22172572475230182*x0[23] - 3.7338417070513083e-315*x0[24] - 0.054046300801450772*x0[25] - 0.17788163856804096*x0[26] + 1.41473790593248e-315*x0[27] + 0.44816135197917284*x0[28] - 2.0348531711979906e-315*x0[29] - 2.2726805679459563e-315*x0[30] + 0.42206657635878236*x0[31] + 0.34038666497954334*x0[32] + 1.3894380640763467e-315*x0[33] - 0.046649621245460862*x0[34] - 2.4705384986044463e-315*x0[35] + 0.062847465463980554*x0[36] + 1.8938985250227668e-315*x0[37] + 0.1854103216395514*x0[38] + 0.024958251850476652*x0[39] - 6.5244535988192094e-316*x0[40] - 2.5899708003945711e-315*x0[41] + 2.5638124651315675e-316*x0[42] + 3.1873781909951607e-315*x0[43] - 0.21909771670335002*x0[44] + 0.1640364853601527*x0[45] - 3.0577683789928727e-316*x0[46] + 1.0479907685510858e-315*x0[47] + 0.059132963931732799*x0[48] + 0.025792768682489801*x0[49] + 2.4636647164342072e-316*x0[50] - 0.0023792575144762902*x0[51] - 0.11467141083796029*x0[52] + 3.1433941796784327e-315*x0[53] - 0.22894941786636358*x0[54] + 2.9683840628383917e-315*x0[55] + 3.5551301837903491e-316*x0[56] - 0.039278388123051712*x0[57] - 0.1192077374569076*x0[58] - 0.21566529705278639*x0[59] - 0.18760385161896909*x0[60] + 1.2315919508144937e-315*x0[61] + 0.0098136357857593285*x0[62] + 5.4322513807719891e-316*x0[63] - 0.088849442973327447*x0[64] + 0.31354340398379626*x0[65] - 9.8942623279958654e-316*x0[66] - 5.3032882414122298e-316*x0[67] + 2.4994837840657934e-316*x0[68] - 4.0770884884718522e-315*x0[69] - 0.24847763185345503*x0[70] + 1.5368160922977478e-315*x0[71] + 2.0977766603978018e-315*x0[72] + 2.3060864213369955e-315*x0[73] - 0.03482735142413642*x0[74] - 0.13744222600623765*x0[75] - 1.9125780601476035e-315*x0[76] - 0.23935880133469156*x0[77] - 0.31412521315307512*x0[78] - 8.4932861265626474e-316*x0[79] - 0.1167608891998881*x0[80] + 8.5856956214885838e-316*x0[81] + 2.6054365867129042e-315*x0[82] - 0.5674870493606442*x0[83] - 0.21938035267101266*x0[84] - 0.18500447797463956*x0[85] + 0.30571708722819529*x0[86] - 0.21539032888707799*x0[87] - 0.79215146920148427*x0[88] + 1.2907460056946108e-317*x0[89] - 0.14228200450896508*x0[90] + 1.8774958963674459e-317*x0[91] + 0.50425368874134624*x0[92] + 1.9473596442701441e-316*x0[93] - 4.2153414700605176e-315*x0[94] + 0.013557523679765569*x0[95] + 1.7899638125565979e-315*x0[96] - 2.5694267356321764e-315*x0[97] + 3.6572081777968207e-315*x0[98] + 1.6897100917188612e-316*x0[99] - 0.20033250326032864*x0[100] + 7.5405881360554677e-316*x0[101] - 5.7537916251940078e-316*x0[102] + 8.4708665144987925e-316*x0[103] + 0.72113415986736062*x0[104] - 0.22903541055531634*x0[105] + 3.409015081232191e-315*x0[106] - 0.21512508310448547*x0[107] - 0.084423611625770154*x0[108] + 1.2805131453081439e-315*x0[109] + 0.1191128642574624*x0[110] + 2.9259502318920552e-316*x0[111] + 1.908628030012385e-315*x0[112] + 0.0022050041676339215*x0[113] + 0.028936531126440613*x0[114] - 0.1058694986068052*x0[115] + 0.23102839579494738*x0[116] + 3.7820614814882142e-315*x0[117] + 0.51834427398734395*x0[118] - 1.7567039456825919e-315*x0[119] - 0.079313044165757657*x0[120] - 0.11642983320224007*x0[121] + 1.3798716933054632e-316*x0[122] - 1.802332158062115e-316*x0[123] + 3.2075051803613056e-315*x0[124] - 1.0227909700475788e-315*x0[125] + 0.34949975048674914*x0[126] - 1.6709153948326354e-315*x0[127] - 1.6143598189289429e-315*x0[128] - 3.7092587989131988e-315*x0[129] + 0.20716902395434555*x0[130] + 0.22993728692385099*x0[131] - 1.4580415246263507e-315*x0[132] + 0.065867746136622593*x0[133] - 0.19811516568108758*x0[134] - 3.3352348700142528e-315*x0[135] - 0.14187534749871805*x0[136] + 3.0450083728279279e-315*x0[137] - 1.5014191000067473e-315*x0[138] - 0.30352988952895976*x0[139] + 0.011492722124083145*x0[140] - 0.2134001968633312*x0[141] - 0.27994318133375062*x0[142] + 4.9563393371755812e-316*x0[143] - 0.065369508324624917*x0[144] + 4.1377524919568199e-315*x0[145] - 0.037696139346391662*x0[146] + 0.15740374108357064*x0[147] + 2.5023682578819696e-315*x0[148] + 1.7000447345690278e-315*x0[149] + 1.6814783009518371e-315*x0[150] + 1.7738722130473035e-315*x0[151] + 0.15735777795638545*x0[152] + 2.21646259697938e-315*x0[153] + 4.0543462317786371e-315*x0[154] - 2.6462504851009693e-315*x0[155] - 0.489013049320346*x0[156] + 0.2311293525976145*x0[157] - 1.3716118247877859e-315*x0[158] - 0.16918984913697727*x0[159] - 0.22274668915734003*x0[160] + 2.2738195819452222e-315*x0[161] - 0.23385865846973136*x0[162] - 2.2167083847568731e-315*x0[163] + 3.9556990296168871e-315*x0[164] + 0.16171541920275642*x0[165] - 0.18012193584456632*x0[166] - 0.2321617903455867*x0[167] + 0.10123551535028749*x0[168] + 5.9172336791210089e-316*x0[169] + 0.19536852004218458*x0[170] + 3.2054214288560314e-316*x0[171] - 0.12183308416794221*x0[172] - 0.15577583585886201*x0[173] - 9.9632415995793785e-316*x0[174] - 4.4738236121568592e-316*x0[175] + 4.0951418349158368e-315*x0[176] - 3.3516631653798751e-315*x0[177] + 0.36551491747990977*x0[178] + 2.6738792980643773e-315*x0[179] + 3.2982673912548168e-315*x0[180] + 2.4235259192259325e-315*x0[181] - 0.12025252746487113*x0[182] + 0.33894432613510356*x0[183] - 4.0529190095255261e-316*x0[184] + 0.01639222247935802*x0[185] - 0.24598298765030827*x0[186] - 1.4715754105156589e-315*x0[187] - 0.12223001395542825*x0[188] - 2.8703240329934418e-315*x0[189] + 1.5243907414980136e-315*x0[190] + 0.01433084919481753*x0[191] + 0.0073343633701947542*x0[192] - 0.82874666578745404*x0[193] + 0.12065217193972148); +x1[5] = relu(0.08859568538211185*x0[0] - 0.03918679314478371*x0[1] - 0.084969093479156516*x0[2] - 0.22574996916701623*x0[3] - 0.2118931230697704*x0[4] - 1.265372549869382*x0[5] + 0.21861481482906095*x0[6] - 0.16937693426893538*x0[7] + 0.26622955818475547*x0[8] - 0.063802089132739923*x0[9] + 0.35903571332203305*x0[10] - 1.3167725785905249e-315*x0[11] + 0.093644447408266454*x0[12] - 0.49521366934201527*x0[13] - 3.6359741058941006e-315*x0[14] - 5.9570741446703553e-316*x0[15] + 3.9973540154791195e-316*x0[16] - 1.5363701684084373e-315*x0[17] + 0.42806509209410509*x0[18] + 0.27174422324534864*x0[19] - 1.6375657068242154e-315*x0[20] - 2.0243475717530501e-316*x0[21] + 0.27502970579434977*x0[22] + 0.042627795462223207*x0[23] + 1.880569755426986e-315*x0[24] - 0.23705469148267286*x0[25] - 0.1663554740547491*x0[26] + 8.7381351299220878e-316*x0[27] + 0.012398013243231181*x0[28] - 3.7791660690586391e-315*x0[29] + 4.3753451136505382e-316*x0[30] - 0.11080979352977816*x0[31] + 0.30674564893539358*x0[32] - 2.2604606051758547e-316*x0[33] - 0.0056898700805643968*x0[34] - 3.5884272587481435e-315*x0[35] - 0.1063974386563801*x0[36] + 6.7420389234901444e-316*x0[37] - 0.078221565327795423*x0[38] - 0.67429460999177226*x0[39] + 6.2115060452965325e-316*x0[40] + 1.2820803857652863e-315*x0[41] - 3.7299849318067424e-315*x0[42] - 2.8946843596174434e-315*x0[43] + 0.59141585613362146*x0[44] + 0.15105238915326896*x0[45] + 2.9771798937686776e-315*x0[46] - 1.4709226658063428e-315*x0[47] - 0.03949679936297007*x0[48] + 0.25498383043998385*x0[49] - 5.478768896492057e-316*x0[50] + 0.027761158948993538*x0[51] + 0.098642770546164354*x0[52] + 4.1010602621093385e-315*x0[53] + 0.0062043150737285911*x0[54] - 4.1011467433599865e-315*x0[55] + 3.8183524509807692e-316*x0[56] + 0.086448330471316434*x0[57] + 0.039040285683839229*x0[58] - 0.077176801000532619*x0[59] + 0.12568468308104883*x0[60] - 3.6661512353489108e-315*x0[61] + 0.020329709354629116*x0[62] - 3.3450036693615503e-315*x0[63] + 0.18426821909145974*x0[64] - 0.09518873776160687*x0[65] - 2.0247213521767548e-315*x0[66] - 6.1333864604518272e-316*x0[67] - 2.0125188496865773e-316*x0[68] - 1.1767491028786745e-315*x0[69] + 0.11536570325542334*x0[70] - 2.2158470801164781e-315*x0[71] + 5.7578183096141785e-316*x0[72] - 1.9000927989476545e-315*x0[73] - 0.17640953431752299*x0[74] - 0.077326596600618955*x0[75] - 4.1194117228233672e-315*x0[76] - 0.013475232336032201*x0[77] - 0.013885012103943722*x0[78] + 3.4882776573046113e-315*x0[79] + 0.10669475040322819*x0[80] + 2.2518040809950702e-316*x0[81] + 2.7000579048408297e-315*x0[82] + 0.36259897682225978*x0[83] - 0.070186694051158224*x0[84] + 0.43085517340892221*x0[85] - 0.12879409389786206*x0[86] - 0.22404371025820771*x0[87] + 0.11278392895374265*x0[88] + 4.0786431055517434e-315*x0[89] + 0.17785862145556311*x0[90] + 2.9780799627996453e-315*x0[91] + 0.18973011200169881*x0[92] - 2.803907316873244e-315*x0[93] - 2.9658951132749937e-315*x0[94] + 0.090482254093401535*x0[95] + 9.5535691841537295e-316*x0[96] - 4.3586658526994544e-316*x0[97] - 4.0074237502112989e-315*x0[98] + 2.7355482014290473e-316*x0[99] + 0.014946871141338719*x0[100] + 2.0196673669404993e-315*x0[101] + 1.5090324144576509e-315*x0[102] - 1.9159367332300016e-315*x0[103] + 0.17770790283188101*x0[104] - 0.093899963626526403*x0[105] + 1.7053521903035692e-315*x0[106] - 0.17370526580490911*x0[107] - 0.0039232232320796654*x0[108] + 2.4013114580402002e-315*x0[109] - 0.20296773720537511*x0[110] + 1.1922472406154973e-315*x0[111] - 1.5611164838182524e-315*x0[112] + 0.0051030558813535548*x0[113] + 0.17576669236658979*x0[114] - 0.22917328971330742*x0[115] + 0.0072858029152470024*x0[116] - 1.5949361468316224e-316*x0[117] + 0.048205649832637816*x0[118] + 7.5153273994952027e-317*x0[119] + 0.0074300599327998089*x0[120] + 0.29527218062340294*x0[121] + 6.3445439910703675e-317*x0[122] + 3.8976887910541136e-315*x0[123] - 3.6921473589790718e-315*x0[124] + 2.176876609822237e-315*x0[125] - 0.5519602619273859*x0[126] - 2.6589407539000036e-316*x0[127] - 2.4168456230439178e-317*x0[128] - 3.737835669503755e-315*x0[129] + 0.042670105040652967*x0[130] - 0.11887648760688804*x0[131] + 2.4569876613228293e-315*x0[132] - 0.048578005868632146*x0[133] + 0.2046167680674974*x0[134] + 5.5534042809957254e-316*x0[135] + 0.070555077679985229*x0[136] + 2.1088192400305814e-315*x0[137] - 1.6874883279160777e-316*x0[138] - 0.11182855948965204*x0[139] - 0.010834655593437978*x0[140] - 0.17261915565832711*x0[141] - 0.38007312303778623*x0[142] + 4.1289593635656168e-315*x0[143] + 0.30990689439168634*x0[144] + 3.3372456924895444e-315*x0[145] - 0.047622732547011298*x0[146] + 0.037748122250799099*x0[147] + 2.9433693067412217e-316*x0[148] + 1.8990334431524676e-315*x0[149] + 1.1960902413098572e-316*x0[150] - 1.0970590809720981e-315*x0[151] - 0.21227286560148192*x0[152] - 4.3867255205499746e-316*x0[153] - 4.3662225324053752e-315*x0[154] - 2.8533699628488281e-315*x0[155] - 0.139689887315012*x0[156] + 0.24928967471914382*x0[157] - 3.9715739171119462e-316*x0[158] + 0.10271783710393385*x0[159] - 0.12798220301575117*x0[160] + 2.9294467295270172e-315*x0[161] + 0.18292854259894004*x0[162] + 4.0754867029447526e-315*x0[163] - 3.9418850480316386e-315*x0[164] + 0.0097562324126187674*x0[165] + 0.26124154234855351*x0[166] - 0.10806024363723658*x0[167] - 0.14775713285754935*x0[168] + 2.3274414899163821e-315*x0[169] - 0.10419925170479385*x0[170] - 2.4782108983659361e-316*x0[171] - 0.0016247021412578639*x0[172] - 0.04069783515590867*x0[173] - 1.452828178516029e-315*x0[174] - 3.3245017236954636e-315*x0[175] + 3.3048865962197232e-315*x0[176] + 1.0311470529091273e-315*x0[177] + 0.15142720907647783*x0[178] + 5.0284196117852169e-316*x0[179] + 4.0258646170445991e-316*x0[180] + 8.0998576508475315e-316*x0[181] + 0.067046858125205486*x0[182] + 0.67433439672221807*x0[183] - 2.6666864828846492e-315*x0[184] - 0.019346852951154545*x0[185] + 0.011523947005243644*x0[186] - 5.1779540142211745e-316*x0[187] + 0.15990890652421441*x0[188] + 1.7644745854571007e-315*x0[189] - 2.3634029423264433e-315*x0[190] + 0.095516370817599658*x0[191] - 0.14735791085853969*x0[192] - 0.21372811218762608*x0[193] + 0.067213102988710013); +x1[6] = relu(-0.68765528137869592*x0[0] - 0.07157033255913875*x0[1] - 0.42516412645224011*x0[2] + 0.18987661107165704*x0[3] + 0.732267780481902*x0[4] - 0.56793527729584681*x0[5] - 0.053538435557701373*x0[6] + 0.17458214156323829*x0[7] - 0.10185148378021833*x0[8] - 0.13603229583604379*x0[9] - 0.13115596133819427*x0[10] + 6.8435399179914638e-317*x0[11] - 0.17024549847721052*x0[12] - 0.036623292421400964*x0[13] - 4.335497074074841e-315*x0[14] + 3.5862801976710112e-315*x0[15] - 2.7807040178819557e-315*x0[16] - 3.7623426891586634e-315*x0[17] - 0.36767116011552109*x0[18] - 0.11288541370238732*x0[19] + 8.63858525006276e-316*x0[20] - 2.43516987556283e-315*x0[21] + 0.012039174976280249*x0[22] - 0.093807734071303953*x0[23] - 2.853782576832296e-315*x0[24] - 0.072593333812481925*x0[25] + 0.27269082346867113*x0[26] - 4.8037135165870304e-316*x0[27] - 0.5419953599648224*x0[28] - 2.5763546377532609e-315*x0[29] - 7.534933159486298e-316*x0[30] - 0.42819505919330436*x0[31] - 0.29668152880803872*x0[32] + 2.3834174378856865e-316*x0[33] - 0.038189801360211502*x0[34] + 4.5527801985528407e-315*x0[35] + 0.035661360020231979*x0[36] - 2.2620068231397666e-315*x0[37] - 0.043013280621736753*x0[38] + 0.20982046957965228*x0[39] - 2.4349117756694426e-316*x0[40] + 3.2613552923136231e-316*x0[41] + 3.8734613730294998e-316*x0[42] + 4.544927983599547e-315*x0[43] - 0.1765169928846381*x0[44] + 0.11892874504341883*x0[45] - 4.3648158830457571e-316*x0[46] - 7.0559873551981665e-316*x0[47] + 0.53464337431636266*x0[48] + 0.10476760920052069*x0[49] - 1.2364515162784543e-315*x0[50] + 0.042784823605017668*x0[51] - 0.36288957441009295*x0[52] - 1.0659777817414597e-315*x0[53] - 0.02805557302704129*x0[54] + 2.731512080355041e-315*x0[55] + 3.9625378319394006e-315*x0[56] + 0.15555455275801117*x0[57] - 0.04860436168463831*x0[58] + 0.12143237566597079*x0[59] - 0.09253879448542443*x0[60] + 4.2682317755046287e-315*x0[61] + 0.060028352204519353*x0[62] + 1.4422833650807781e-315*x0[63] + 0.19183966925789675*x0[64] - 0.032415279103084574*x0[65] + 7.4805153364629701e-316*x0[66] - 7.2028051870870305e-317*x0[67] + 1.6648088867290749e-316*x0[68] - 3.6006324835400296e-315*x0[69] - 0.034052299112486174*x0[70] + 2.606135640195205e-315*x0[71] - 9.4814467657445035e-316*x0[72] - 2.1752605803825678e-315*x0[73] + 0.099393442660463099*x0[74] + 0.068389077651714744*x0[75] - 1.1717310115115893e-315*x0[76] + 0.086215039440826244*x0[77] + 0.049070218513637895*x0[78] + 4.059293133226813e-315*x0[79] - 0.084448133234861389*x0[80] - 1.2797877630675763e-315*x0[81] - 9.7345068931050025e-316*x0[82] - 0.23870286156778853*x0[83] + 0.14945616767229489*x0[84] + 0.34799383405645995*x0[85] - 0.44282355423021758*x0[86] + 0.096565307483040055*x0[87] + 0.16505337000358605*x0[88] + 5.4771045869574762e-316*x0[89] - 0.30357752473616778*x0[90] + 3.0592322115103405e-315*x0[91] - 0.48048031526450008*x0[92] + 4.2424762223187407e-315*x0[93] - 3.1766895204658101e-315*x0[94] + 0.094464049401117064*x0[95] - 2.8327034834413634e-315*x0[96] - 1.6172595198483239e-315*x0[97] - 8.4342388590312225e-316*x0[98] - 1.6889531880900889e-315*x0[99] + 0.14560258778794613*x0[100] + 8.1131920873762701e-316*x0[101] - 8.8073658809193342e-317*x0[102] - 1.0224952322332912e-315*x0[103] - 0.14740057766171707*x0[104] - 0.010143237475377809*x0[105] + 1.045831652272195e-315*x0[106] + 0.15222096330328166*x0[107] - 0.039108673351762623*x0[108] - 1.3824083449069672e-315*x0[109] - 0.048337201978920635*x0[110] - 4.1411395688731975e-316*x0[111] - 3.4823180447988723e-315*x0[112] + 0.17789908724839598*x0[113] + 0.30961179776035924*x0[114] - 0.10303486796921003*x0[115] - 0.28699488426270126*x0[116] + 1.418629127433874e-315*x0[117] + 0.08163717552777261*x0[118] + 2.292186897225826e-315*x0[119] + 0.025526493068027178*x0[120] + 0.0092500510632690901*x0[121] + 3.6101571354077782e-315*x0[122] - 9.4583050767392516e-316*x0[123] + 3.9596766681403952e-316*x0[124] - 2.5819002183071285e-315*x0[125] - 0.099938408337685788*x0[126] - 5.8592581881951074e-316*x0[127] - 1.7807903771345085e-315*x0[128] + 1.2787831349239792e-315*x0[129] + 0.089019179457013903*x0[130] + 0.23054239946781216*x0[131] + 6.4816047181457711e-316*x0[132] - 0.045574258231632844*x0[133] - 0.33439803582446309*x0[134] + 1.642997355840152e-315*x0[135] - 0.14286148414891608*x0[136] - 1.9073994764961232e-315*x0[137] + 4.0480363958991871e-315*x0[138] - 0.23560110659208811*x0[139] - 0.12235921568538696*x0[140] + 0.029789115703997317*x0[141] - 0.07936467093171827*x0[142] + 3.2005845755898101e-316*x0[143] - 0.074360793519897952*x0[144] - 4.4814408692516167e-316*x0[145] + 0.31062919304336339*x0[146] + 0.09163507754836181*x0[147] + 2.5237753120486117e-316*x0[148] + 1.775063558479777e-315*x0[149] + 2.9118959170140436e-315*x0[150] - 3.0184465934398433e-315*x0[151] - 0.069258103613290323*x0[152] - 2.5825515796326362e-315*x0[153] + 3.0185208712690391e-315*x0[154] - 3.0365076522485595e-315*x0[155] - 0.19055738370321307*x0[156] - 0.28965413976548543*x0[157] - 2.0077609579918744e-315*x0[158] + 0.043142502932978798*x0[159] - 0.092320828984663886*x0[160] + 4.2752409415431411e-317*x0[161] + 0.044384381543965366*x0[162] - 3.6402149825937129e-315*x0[163] - 3.5679906186791241e-315*x0[164] - 0.049134734908700184*x0[165] + 0.41630085339554201*x0[166] + 0.19983527053911548*x0[167] + 0.089265362367128509*x0[168] + 3.0352125085645512e-315*x0[169] + 0.13962997165119223*x0[170] - 8.7985234892425842e-316*x0[171] + 0.1117874596825385*x0[172] + 0.15445122033291286*x0[173] + 7.8071007322274967e-316*x0[174] - 3.2758540142994124e-315*x0[175] + 8.598809605926148e-316*x0[176] + 1.2591544552275733e-315*x0[177] - 0.26096948968135975*x0[178] + 3.6944933210039069e-315*x0[179] - 2.8459034550639298e-315*x0[180] - 1.4230729959447366e-315*x0[181] + 0.066025667256867898*x0[182] + 0.085294796054346741*x0[183] - 4.2992949968732858e-315*x0[184] - 0.073745014740705273*x0[185] - 0.19727709893953566*x0[186] - 2.0260116540174338e-315*x0[187] + 0.036259335274381084*x0[188] + 3.3234102783365792e-315*x0[189] - 1.3206933007516321e-315*x0[190] + 0.02015153026860696*x0[191] + 0.04522197804188953*x0[192] - 0.019659580057185058*x0[193] + 0.15350273151627605); +x1[7] = relu(0.28489520986920119*x0[0] - 0.053481838325104163*x0[1] - 0.084677404457370695*x0[2] - 0.095887872684440351*x0[3] - 0.80768384388586045*x0[4] - 0.11810074084250968*x0[5] + 0.091116547967756298*x0[6] - 0.55285578004899416*x0[7] - 0.27544016691124124*x0[8] - 0.18642623055488977*x0[9] - 0.15380091311407693*x0[10] - 2.1253785418428549e-315*x0[11] - 0.082049671153709314*x0[12] - 0.13859425954164781*x0[13] - 3.5104019070440694e-315*x0[14] + 1.7614800338150311e-315*x0[15] + 2.0471841356967433e-315*x0[16] + 2.1465029114095724e-315*x0[17] - 0.074449386368483916*x0[18] - 0.41076022675399437*x0[19] - 4.0321798382395888e-315*x0[20] + 3.676654621379758e-316*x0[21] - 0.28739714477629058*x0[22] + 0.090016233406349455*x0[23] + 2.0872916338463541e-315*x0[24] - 0.34750766799203675*x0[25] - 0.08759468584014804*x0[26] - 4.0376424898748019e-315*x0[27] + 0.015224704272591478*x0[28] + 3.4063240341163616e-316*x0[29] + 3.810993150500362e-315*x0[30] - 0.14464689371538605*x0[31] - 0.24845992950226226*x0[32] + 1.1269088178266917e-315*x0[33] + 0.61851662143563424*x0[34] - 3.9786557058597409e-316*x0[35] - 0.07145902639400728*x0[36] + 4.0435211546651263e-315*x0[37] - 0.19603392095643485*x0[38] + 0.46174507162342743*x0[39] + 1.0971910261434765e-315*x0[40] + 9.1813882485708393e-316*x0[41] - 1.5539985591091209e-315*x0[42] + 7.4107891858426388e-316*x0[43] - 0.52169868623590898*x0[44] - 0.35686967710975132*x0[45] - 1.9160939449185083e-315*x0[46] - 2.5229167247692688e-316*x0[47] - 0.15559925857024695*x0[48] - 0.11634830875216962*x0[49] - 1.471757933187202e-315*x0[50] + 0.26761520547190143*x0[51] + 0.14984517163518668*x0[52] - 2.772640278603708e-315*x0[53] - 0.55989381009084438*x0[54] + 4.0965303323036267e-316*x0[55] - 7.1740614359432785e-316*x0[56] + 0.35115957971910711*x0[57] + 0.36336209104500572*x0[58] - 0.47307395150716919*x0[59] - 0.44646782502356208*x0[60] + 2.8384899852261125e-315*x0[61] - 0.16639894462108459*x0[62] + 5.9773136426653712e-316*x0[63] - 0.52866108357028052*x0[64] + 0.17014527999871118*x0[65] - 3.0414090502507534e-315*x0[66] - 9.1106791049415422e-316*x0[67] + 3.812019171686424e-316*x0[68] - 4.1071961621781701e-315*x0[69] - 0.26969930864222474*x0[70] - 2.0467387256357045e-316*x0[71] + 2.4530934210803392e-315*x0[72] - 2.0799737410077248e-315*x0[73] - 0.25667029110283968*x0[74] + 0.2359379938122296*x0[75] + 1.9752735232298895e-315*x0[76] - 1.0773022751397858*x0[77] + 0.16659368459656163*x0[78] + 2.3707467340862276e-315*x0[79] - 0.38183238483426618*x0[80] + 2.4608941692153056e-315*x0[81] + 3.0738318859295446e-315*x0[82] + 0.74094211044246994*x0[83] + 0.24114198376806159*x0[84] - 0.47721124823615718*x0[85] - 0.14209697150704428*x0[86] - 0.11013014459582912*x0[87] - 0.51811253230855814*x0[88] - 4.0942676944499628e-315*x0[89] - 0.065526186731175162*x0[90] - 5.1456210243800795e-316*x0[91] - 0.21371158176041888*x0[92] - 4.2456055896535911e-315*x0[93] - 2.5173373155406304e-315*x0[94] + 0.11215651893744115*x0[95] - 7.9420773421890482e-316*x0[96] - 1.0476042906402829e-315*x0[97] + 3.0377725047678212e-316*x0[98] - 7.6285509907622682e-316*x0[99] + 0.1641604444849358*x0[100] - 2.5097190406706426e-315*x0[101] + 1.2185084848118731e-315*x0[102] - 1.6052712096375879e-315*x0[103] - 0.27144213289451241*x0[104] + 0.050036848483263216*x0[105] - 1.9751341374298848e-317*x0[106] + 0.1215395876336295*x0[107] + 0.038460259488975836*x0[108] - 1.2067871232102417e-315*x0[109] - 0.5999353741750546*x0[110] + 1.0351143160540727e-315*x0[111] - 4.2767466065988423e-316*x0[112] - 0.2323958913639104*x0[113] - 0.31019114940280124*x0[114] - 0.4674348178200754*x0[115] + 0.062853441253287609*x0[116] + 3.0896649606489961e-316*x0[117] - 0.57556454062175677*x0[118] + 7.7690774401235544e-316*x0[119] - 0.54181305509779587*x0[120] + 0.23813409372037353*x0[121] + 8.8847554343657445e-316*x0[122] - 2.1362366126601951e-315*x0[123] + 1.0948500640629774e-316*x0[124] + 1.0758256365327483e-315*x0[125] - 0.17355492916484466*x0[126] + 1.1661231885676587e-315*x0[127] + 3.77331653931945e-316*x0[128] - 3.8695415698304939e-315*x0[129] - 0.14028655094992507*x0[130] + 0.17420400140617601*x0[131] + 4.5585790915039876e-316*x0[132] - 0.70512998363163459*x0[133] + 0.40383836622877384*x0[134] + 9.8732808916204897e-316*x0[135] - 0.52432203025258461*x0[136] - 1.4017868149383497e-316*x0[137] - 1.5292856128930259e-315*x0[138] - 0.23772580373815183*x0[139] - 0.2439803111629166*x0[140] - 0.609045147093489*x0[141] - 0.027347111868986935*x0[142] - 2.5508040279379244e-315*x0[143] - 0.12753183768260412*x0[144] + 9.1416968426268431e-316*x0[145] - 0.46918384398114737*x0[146] - 0.075246857374183615*x0[147] - 7.6013071735127256e-316*x0[148] - 1.1426281240498753e-315*x0[149] + 4.092387344830425e-316*x0[150] - 1.6889788893849855e-315*x0[151] + 0.37680125045881818*x0[152] - 4.3617701165588395e-316*x0[153] - 3.4859513590924807e-315*x0[154] - 3.0802208513628325e-315*x0[155] + 0.022245223951219344*x0[156] - 0.063527821570863202*x0[157] + 1.4613472437528276e-315*x0[158] - 0.29556943581355483*x0[159] - 0.0062454171396883326*x0[160] + 2.7298030084729469e-316*x0[161] - 0.48883326751197681*x0[162] - 1.4523334656441917e-315*x0[163] + 3.4242228911735481e-315*x0[164] - 0.32368841991856251*x0[165] - 0.4032444849270902*x0[166] - 0.43171499450479278*x0[167] - 0.35500711616288605*x0[168] + 1.1701452287707585e-315*x0[169] - 0.90582787613342053*x0[170] - 5.7729588525178544e-316*x0[171] - 0.55437504355512957*x0[172] - 0.17479901329145778*x0[173] - 1.0298883366851869e-316*x0[174] - 9.2241709738542995e-316*x0[175] - 2.7634419126291295e-315*x0[176] - 2.0865189151762583e-316*x0[177] + 0.033292917834291412*x0[178] - 8.0797627164604888e-316*x0[179] - 3.3417840955210823e-315*x0[180] + 2.1873998078854824e-316*x0[181] - 0.47901782325402714*x0[182] - 0.041625147207387962*x0[183] - 2.279977136911311e-316*x0[184] - 0.33085941494965382*x0[185] + 0.29844039102976755*x0[186] - 2.5380562350757448e-315*x0[187] - 0.3594719292115342*x0[188] - 3.047560933343228e-316*x0[189] + 2.7509407622780103e-315*x0[190] - 0.39018668914496751*x0[191] - 0.49969062127546648*x0[192] + 0.6854000591020496*x0[193] + 0.65973192306452422); +x2[0] = relu(1.0286548433015636*x1[0] + 1.1407276551979413*x1[1] + 1.0023508028437138*x1[2] - 0.42003137662840634*x1[3] - 0.075173685326270001*x1[4] - 0.30121707956461558*x1[5] + 1.219163584682279*x1[6] - 0.33927265879156082*x1[7] - 0.41488067699898373); +x2[1] = relu(-0.95316275515418236*x1[0] - 0.10164607709323226*x1[1] - 0.12364178493903279*x1[2] + 1.0149583533406084*x1[3] - 0.12280523025089821*x1[4] - 1.3224989412261423*x1[5] - 0.42235657145318883*x1[6] + 0.23402732006237065*x1[7] - 0.42725583234972531); +x2[2] = relu(1.6280486014958921*x1[0] + 0.85699684997521264*x1[1] + 0.88789814406815781*x1[2] - 1.1675389312349578*x1[3] + 0.0080942762406626696*x1[4] + 0.48761851493601083*x1[5] + 0.91845932988324142*x1[6] - 0.047734609184752898*x1[7] + 0.17251628667016805); +x2[3] = relu(-1.3801804542631915*x1[0] - 0.77209990347519986*x1[1] - 0.9633139808107426*x1[2] + 0.066723855089116019*x1[3] + 0.70857436032679366*x1[4] - 0.9023753772958043*x1[5] - 0.64560789943933328*x1[6] + 1.2960763688306787*x1[7] + 0.78275710544714194); +x3_result[0] = sigmoid(-1.6767804886380782*x2[0] - 2.3739096588154478*x2[1] - 2.1644623224652353*x2[2] + 2.5121316236545326*x2[3] + 0.55794744288557929); return x3_result[0]; } diff --git a/test/dreal/util/test/pattern_matching_heuristic_test.cc b/test/dreal/util/test/pattern_matching_heuristic_test.cc index 85bebb2b1..61cc0091e 100644 --- a/test/dreal/util/test/pattern_matching_heuristic_test.cc +++ b/test/dreal/util/test/pattern_matching_heuristic_test.cc @@ -1,5 +1,5 @@ -// This file was automatically generated on 2025-04-17 00:30:24.185915 by Kunal in the `WORTH_IT_regression` python notebook. +// This file was automatically generated on 2025-04-19 11:57:52.077108 by Kunal in the `WORTH_IT_regression` python notebook. #include @@ -20,33 +20,33 @@ namespace dreal float expected_value = -1E9; float calculated_value = -1E9; -k.assertions_size = 1842; +k.assertions_size = 2144; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1071; -k.assertions_stats.conjunction_cntr = 1842; -k.assertions_stats.constant_cntr = 1487; +k.assertions_stats.addition_cntr = 982; +k.assertions_stats.conjunction_cntr = 2144; +k.assertions_stats.constant_cntr = 1625; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1474; +k.assertions_stats.equalto_cntr = 1261; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 368; +k.assertions_stats.inequality_cntr = 883; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 1022; -k.assertions_stats.negation_cntr = 2; +k.assertions_stats.multiplication_cntr = 504; +k.assertions_stats.negation_cntr = 507; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 54; +k.assertions_stats.pow_cntr = 50; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1445; -k.assertions_stats.variable_cntr = 4029; +k.assertions_stats.unique_variables = 1121; +k.assertions_stats.variable_cntr = 3812; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -99,8 +99,8 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 2543; -k.box_continuous_count = 1445; +k.box_boolean_count = 5854; +k.box_continuous_count = 1121; k.box_integer_count = 0; k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; @@ -197,7 +197,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -207,10 +207,10 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.107759; -expected_value = 0.6738802735922182; +k.theory_checksat_ms = 0.0847941; +expected_value = 0.583019044053358; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12566: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1593: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); k.assertions_size = 1289; @@ -230,7 +230,7 @@ k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; k.assertions_stats.multiplication_cntr = 304; -k.assertions_stats.negation_cntr = 299; +k.assertions_stats.negation_cntr = 296; k.assertions_stats.notequalto_cntr = 0; k.assertions_stats.pow_cntr = 30; k.assertions_stats.realconstant_cntr = 0; @@ -400,39 +400,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.415049; -expected_value = 0.5839398141388688; +k.theory_checksat_ms = 0.213477; +expected_value = 0.7505997556622402; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 16202: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16215: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1353; +k.assertions_size = 2144; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 582; -k.assertions_stats.conjunction_cntr = 1353; -k.assertions_stats.constant_cntr = 1033; +k.assertions_stats.addition_cntr = 982; +k.assertions_stats.conjunction_cntr = 2144; +k.assertions_stats.constant_cntr = 1625; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 783; +k.assertions_stats.equalto_cntr = 1261; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 570; +k.assertions_stats.inequality_cntr = 883; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 352; -k.assertions_stats.negation_cntr = 342; +k.assertions_stats.multiplication_cntr = 504; +k.assertions_stats.negation_cntr = 496; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 30; +k.assertions_stats.pow_cntr = 50; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 703; -k.assertions_stats.variable_cntr = 2426; +k.assertions_stats.unique_variables = 1121; +k.assertions_stats.variable_cntr = 3812; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -462,15 +462,15 @@ k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -483,12 +483,12 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 3753; -k.box_continuous_count = 703; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 5854; +k.box_continuous_count = 1121; k.box_integer_count = 0; -k.lemma_size = 2; +k.lemma_size = 8; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -531,7 +531,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -593,39 +593,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.235593; -expected_value = 0.9774965944972224; +k.theory_checksat_ms = 6.83229; +expected_value = 0.578838237320077; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12440: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1704: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1353; +k.assertions_size = 776; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 582; -k.assertions_stats.conjunction_cntr = 1353; -k.assertions_stats.constant_cntr = 1033; +k.assertions_stats.addition_cntr = 342; +k.assertions_stats.conjunction_cntr = 776; +k.assertions_stats.constant_cntr = 601; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 783; +k.assertions_stats.equalto_cntr = 445; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 570; +k.assertions_stats.inequality_cntr = 331; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 352; -k.assertions_stats.negation_cntr = 328; +k.assertions_stats.multiplication_cntr = 184; +k.assertions_stats.negation_cntr = 172; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 30; +k.assertions_stats.pow_cntr = 18; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 703; -k.assertions_stats.variable_cntr = 2426; +k.assertions_stats.unique_variables = 401; +k.assertions_stats.variable_cntr = 1364; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -678,27 +678,27 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 3753; -k.box_continuous_count = 703; +k.box_boolean_count = 2134; +k.box_continuous_count = 401; k.box_integer_count = 0; -k.lemma_size = 4; +k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -706,8 +706,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.middle_assertion_stats.variable_cntr = 2; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -724,7 +724,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -776,7 +776,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -786,39 +786,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.340995; -expected_value = 0.6999352113885261; +k.theory_checksat_ms = 2.67265; +expected_value = 0.9977925501127247; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12453: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 3075: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2144; +k.assertions_size = 1973; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 982; -k.assertions_stats.conjunction_cntr = 2144; -k.assertions_stats.constant_cntr = 1625; +k.assertions_stats.addition_cntr = 902; +k.assertions_stats.conjunction_cntr = 1973; +k.assertions_stats.constant_cntr = 1497; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1261; +k.assertions_stats.equalto_cntr = 1159; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 883; +k.assertions_stats.inequality_cntr = 814; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 504; -k.assertions_stats.negation_cntr = 497; +k.assertions_stats.multiplication_cntr = 464; +k.assertions_stats.negation_cntr = 458; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 50; +k.assertions_stats.pow_cntr = 46; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1121; -k.assertions_stats.variable_cntr = 3812; +k.assertions_stats.unique_variables = 1031; +k.assertions_stats.variable_cntr = 3506; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -871,10 +871,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 5854; -k.box_continuous_count = 1121; +k.box_boolean_count = 5389; +k.box_continuous_count = 1031; k.box_integer_count = 0; -k.lemma_size = 2; +k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -890,8 +890,8 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -899,8 +899,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.middle_assertion_stats.variable_cntr = 2; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -917,7 +917,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -979,39 +979,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.264373; -expected_value = 0.9631663725396985; +k.theory_checksat_ms = 0.275559; +expected_value = 0.7479350195180026; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1668: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1425: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1129; +k.assertions_size = 1890; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 582; -k.assertions_stats.conjunction_cntr = 1129; -k.assertions_stats.constant_cntr = 825; +k.assertions_stats.addition_cntr = 822; +k.assertions_stats.conjunction_cntr = 1890; +k.assertions_stats.constant_cntr = 1435; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 751; +k.assertions_stats.equalto_cntr = 1101; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 378; +k.assertions_stats.inequality_cntr = 789; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 304; -k.assertions_stats.negation_cntr = 207; +k.assertions_stats.multiplication_cntr = 490; +k.assertions_stats.negation_cntr = 624; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 30; +k.assertions_stats.pow_cntr = 42; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 671; -k.assertions_stats.variable_cntr = 2122; +k.assertions_stats.unique_variables = 985; +k.assertions_stats.variable_cntr = 3398; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -1044,12 +1044,12 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -1064,10 +1064,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 2249; -k.box_continuous_count = 671; +k.box_boolean_count = 5232; +k.box_continuous_count = 985; k.box_integer_count = 0; -k.lemma_size = 4; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -1083,10 +1083,10 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 0; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.pow_cntr = 0; +k.middle_assertion_stats.pow_cntr = 1; k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; @@ -1172,43 +1172,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 5.58421; -expected_value = 0.9996540006950871; +k.theory_checksat_ms = 0.230767; +expected_value = 0.9433754178507163; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1880: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 188: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2606; +k.assertions_size = 816; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1142; -k.assertions_stats.conjunction_cntr = 2606; -k.assertions_stats.constant_cntr = 1971; +k.assertions_stats.addition_cntr = 342; +k.assertions_stats.conjunction_cntr = 816; +k.assertions_stats.constant_cntr = 631; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1525; +k.assertions_stats.equalto_cntr = 465; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 1081; +k.assertions_stats.inequality_cntr = 351; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 674; -k.assertions_stats.negation_cntr = 854; +k.assertions_stats.multiplication_cntr = 214; +k.assertions_stats.negation_cntr = 207; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 58; +k.assertions_stats.pow_cntr = 18; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1361; -k.assertions_stats.variable_cntr = 4694; +k.assertions_stats.unique_variables = 421; +k.assertions_stats.variable_cntr = 1454; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.constant_cntr = 0; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -1220,7 +1220,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.multiplication_cntr = 0; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -1257,10 +1257,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 7204; -k.box_continuous_count = 1361; +k.box_boolean_count = 2274; +k.box_continuous_count = 421; k.box_integer_count = 0; -k.lemma_size = 4; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -1303,7 +1303,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -1355,7 +1355,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -1365,43 +1365,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 58.0898; -expected_value = 0.9999973515962518; +k.theory_checksat_ms = 1.70081; +expected_value = 0.9997769258614276; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 13959: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16848: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1428; +k.assertions_size = 2606; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 829; -k.assertions_stats.conjunction_cntr = 1428; -k.assertions_stats.constant_cntr = 1155; +k.assertions_stats.addition_cntr = 1142; +k.assertions_stats.conjunction_cntr = 2606; +k.assertions_stats.constant_cntr = 1971; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1142; +k.assertions_stats.equalto_cntr = 1525; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 286; +k.assertions_stats.inequality_cntr = 1081; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 794; -k.assertions_stats.negation_cntr = 13; +k.assertions_stats.multiplication_cntr = 674; +k.assertions_stats.negation_cntr = 646; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 42; +k.assertions_stats.pow_cntr = 58; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1121; -k.assertions_stats.variable_cntr = 3123; +k.assertions_stats.unique_variables = 1361; +k.assertions_stats.variable_cntr = 4694; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -1413,7 +1413,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -1430,12 +1430,12 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -1450,8 +1450,8 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 1969; -k.box_continuous_count = 1121; +k.box_boolean_count = 7204; +k.box_continuous_count = 1361; k.box_integer_count = 0; k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; @@ -1558,45 +1558,45 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.257526; -expected_value = 0.9836522668679262; +k.theory_checksat_ms = 0.87857; +expected_value = 0.9968641251090132; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 2741: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 14024: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 92; +k.assertions_size = 1460; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 48; -k.assertions_stats.conjunction_cntr = 92; -k.assertions_stats.constant_cntr = 100; +k.assertions_stats.addition_cntr = 662; +k.assertions_stats.conjunction_cntr = 1460; +k.assertions_stats.constant_cntr = 1113; k.assertions_stats.disjunction_cntr = 0; -k.assertions_stats.division_cntr = 10; -k.assertions_stats.equalto_cntr = 53; +k.assertions_stats.division_cntr = 0; +k.assertions_stats.equalto_cntr = 853; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 39; +k.assertions_stats.inequality_cntr = 607; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 67; -k.assertions_stats.negation_cntr = 23; +k.assertions_stats.multiplication_cntr = 344; +k.assertions_stats.negation_cntr = 341; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 2; +k.assertions_stats.pow_cntr = 34; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; -k.assertions_stats.trigonometry_cntr = 2; +k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 58; -k.assertions_stats.variable_cntr = 215; +k.assertions_stats.unique_variables = 761; +k.assertions_stats.variable_cntr = 2588; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 2; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 3; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; -k.biggest_assertion_stats.division_cntr = 1; +k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; k.biggest_assertion_stats.exp_cntr = 0; k.biggest_assertion_stats.false_cntr = 0; @@ -1606,7 +1606,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 3; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -1615,24 +1615,24 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 6; -k.biggest_assertion_stats.variable_cntr = 6; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.equalto_cntr = 0; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; -k.biggest_literal_stats.multiplication_cntr = 1; +k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; @@ -1641,10 +1641,10 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 2; -k.biggest_literal_stats.variable_cntr = 2; -k.box_boolean_count = 22; -k.box_continuous_count = 58; +k.biggest_literal_stats.unique_variables = 1; +k.biggest_literal_stats.variable_cntr = 1; +k.box_boolean_count = 3994; +k.box_continuous_count = 761; k.box_integer_count = 0; k.lemma_size = 3; k.middle_assertion_stats.abs_cntr = 0; @@ -1653,16 +1653,16 @@ k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 0; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; @@ -1671,8 +1671,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 2; -k.middle_assertion_stats.variable_cntr = 2; +k.middle_assertion_stats.unique_variables = 1; +k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -1689,7 +1689,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -1741,7 +1741,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -1751,39 +1751,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.159605; -expected_value = 0.9913100651196299; +k.theory_checksat_ms = 0.120065; +expected_value = 0.9508706440668288; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 16595: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 12967: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2486; +k.assertions_size = 1626; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1142; -k.assertions_stats.conjunction_cntr = 2486; -k.assertions_stats.constant_cntr = 1881; +k.assertions_stats.addition_cntr = 822; +k.assertions_stats.conjunction_cntr = 1626; +k.assertions_stats.constant_cntr = 1193; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1465; +k.assertions_stats.equalto_cntr = 1101; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 1021; +k.assertions_stats.inequality_cntr = 525; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 584; -k.assertions_stats.negation_cntr = 788; +k.assertions_stats.multiplication_cntr = 490; +k.assertions_stats.negation_cntr = 285; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 58; +k.assertions_stats.pow_cntr = 42; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1301; -k.assertions_stats.variable_cntr = 4424; +k.assertions_stats.unique_variables = 985; +k.assertions_stats.variable_cntr = 3112; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -1816,12 +1816,12 @@ k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 1; +k.biggest_literal_stats.equalto_cntr = 0; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 0; +k.biggest_literal_stats.inequality_cntr = 1; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -1836,10 +1836,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 6784; -k.box_continuous_count = 1301; +k.box_boolean_count = 3164; +k.box_continuous_count = 985; k.box_integer_count = 0; -k.lemma_size = 2; +k.lemma_size = 4; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -1855,10 +1855,10 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; +k.middle_assertion_stats.multiplication_cntr = 1; k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.pow_cntr = 1; +k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; @@ -1882,7 +1882,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 1; +k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -1944,20 +1944,20 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 22.8744; -expected_value = 0.9999845401760995; +k.theory_checksat_ms = 0.400362; +expected_value = 0.9802891068888676; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 2242: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 2984: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2170; +k.assertions_size = 2578; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 432; -k.assertions_stats.conjunction_cntr = 2170; -k.assertions_stats.constant_cntr = 1156; +k.assertions_stats.addition_cntr = 660; +k.assertions_stats.conjunction_cntr = 2578; +k.assertions_stats.constant_cntr = 1434; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 2163; +k.assertions_stats.equalto_cntr = 2571; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; @@ -1966,17 +1966,17 @@ k.assertions_stats.inequality_cntr = 7; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 338; -k.assertions_stats.negation_cntr = 1313; +k.assertions_stats.multiplication_cntr = 379; +k.assertions_stats.negation_cntr = 947; k.assertions_stats.notequalto_cntr = 0; k.assertions_stats.pow_cntr = 1; -k.assertions_stats.realconstant_cntr = 1340; +k.assertions_stats.realconstant_cntr = 1511; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; k.assertions_stats.unique_variables = 24; -k.assertions_stats.variable_cntr = 2205; +k.assertions_stats.variable_cntr = 2613; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 4; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -2034,9 +2034,9 @@ k.box_continuous_count = 23; k.box_integer_count = 1; k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.addition_cntr = 1; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; k.middle_assertion_stats.equalto_cntr = 1; @@ -2049,10 +2049,10 @@ k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 1; +k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; @@ -2086,9 +2086,9 @@ k.middle_literal_stats.uninterpretedfunction_cntr = 0; k.middle_literal_stats.unique_variables = 1; k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 1; k.smallest_assertion_stats.conjunction_cntr = 0; -k.smallest_assertion_stats.constant_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; k.smallest_assertion_stats.equalto_cntr = 1; @@ -2101,10 +2101,10 @@ k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -2137,55 +2137,55 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0895811; -expected_value = 3.7790355240307487e-14; +k.theory_checksat_ms = 0.0341241; +expected_value = 4.984553724196303e-06; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 8045: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 5173: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 3389; +k.assertions_size = 9; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1240; -k.assertions_stats.conjunction_cntr = 3389; -k.assertions_stats.constant_cntr = 2096; +k.assertions_stats.addition_cntr = 2; +k.assertions_stats.conjunction_cntr = 9; +k.assertions_stats.constant_cntr = 11; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 3382; +k.assertions_stats.equalto_cntr = 3; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 7; +k.assertions_stats.inequality_cntr = 6; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 429; -k.assertions_stats.negation_cntr = 150; +k.assertions_stats.multiplication_cntr = 2; +k.assertions_stats.negation_cntr = 5; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 1; -k.assertions_stats.realconstant_cntr = 1710; +k.assertions_stats.pow_cntr = 3; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 24; -k.assertions_stats.variable_cntr = 3424; +k.assertions_stats.unique_variables = 4; +k.assertions_stats.variable_cntr = 13; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 4; +k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 6; +k.biggest_assertion_stats.constant_cntr = 3; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.equalto_cntr = 0; k.biggest_assertion_stats.exp_cntr = 0; k.biggest_assertion_stats.false_cntr = 0; k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 1; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 6; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -2194,12 +2194,12 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 7; -k.biggest_assertion_stats.variable_cntr = 8; +k.biggest_assertion_stats.unique_variables = 2; +k.biggest_assertion_stats.variable_cntr = 2; k.biggest_literal_stats.abs_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.addition_cntr = 1; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 0; +k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 1; @@ -2214,35 +2214,35 @@ k.biggest_literal_stats.min_cntr = 0; k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.pow_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 1; +k.biggest_literal_stats.pow_cntr = 1; +k.biggest_literal_stats.realconstant_cntr = 0; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; k.box_boolean_count = 0; -k.box_continuous_count = 23; -k.box_integer_count = 1; -k.lemma_size = 2; +k.box_continuous_count = 4; +k.box_integer_count = 0; +k.lemma_size = 9; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -2255,23 +2255,23 @@ k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; -k.middle_literal_stats.constant_cntr = 0; +k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.equalto_cntr = 0; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 1; +k.middle_literal_stats.realconstant_cntr = 0; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -2279,22 +2279,22 @@ k.middle_literal_stats.uninterpretedfunction_cntr = 0; k.middle_literal_stats.unique_variables = 1; k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 1; +k.smallest_assertion_stats.addition_cntr = 0; k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -2307,78 +2307,78 @@ k.smallest_assertion_stats.variable_cntr = 1; k.smallest_literal_stats.abs_cntr = 0; k.smallest_literal_stats.addition_cntr = 0; k.smallest_literal_stats.conjunction_cntr = 0; -k.smallest_literal_stats.constant_cntr = 0; +k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.512749; -expected_value = 3.878640707734e-12; +k.theory_checksat_ms = 0.478957; +expected_value = 0.014762318503545334; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 3807: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 3009: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 3; +k.assertions_size = 1193; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 0; -k.assertions_stats.conjunction_cntr = 3; -k.assertions_stats.constant_cntr = 3; +k.assertions_stats.addition_cntr = 582; +k.assertions_stats.conjunction_cntr = 1193; +k.assertions_stats.constant_cntr = 919; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1; +k.assertions_stats.equalto_cntr = 845; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 2; +k.assertions_stats.inequality_cntr = 348; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 0; -k.assertions_stats.negation_cntr = 0; +k.assertions_stats.multiplication_cntr = 442; +k.assertions_stats.negation_cntr = 285; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 1; -k.assertions_stats.realconstant_cntr = 1; +k.assertions_stats.pow_cntr = 32; +k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1; -k.assertions_stats.variable_cntr = 3; +k.assertions_stats.unique_variables = 765; +k.assertions_stats.variable_cntr = 2342; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 1; +k.biggest_assertion_stats.constant_cntr = 2; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 0; +k.biggest_assertion_stats.equalto_cntr = 1; k.biggest_assertion_stats.exp_cntr = 0; k.biggest_assertion_stats.false_cntr = 0; k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.inequality_cntr = 1; +k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 0; +k.biggest_assertion_stats.multiplication_cntr = 2; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -2387,12 +2387,12 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 1; -k.biggest_assertion_stats.variable_cntr = 1; +k.biggest_assertion_stats.unique_variables = 3; +k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 1; @@ -2407,35 +2407,35 @@ k.biggest_literal_stats.min_cntr = 0; k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; -k.biggest_literal_stats.pow_cntr = 1; -k.biggest_literal_stats.realconstant_cntr = 1; +k.biggest_literal_stats.pow_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 0; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 0; -k.box_continuous_count = 1; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 2277; +k.box_continuous_count = 765; k.box_integer_count = 0; -k.lemma_size = 1; +k.lemma_size = 8; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -2443,28 +2443,28 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.middle_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 1; +k.middle_literal_stats.equalto_cntr = 0; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 0; +k.middle_literal_stats.inequality_cntr = 1; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; -k.middle_literal_stats.pow_cntr = 1; -k.middle_literal_stats.realconstant_cntr = 1; +k.middle_literal_stats.pow_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 0; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -2477,20 +2477,20 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; -k.smallest_assertion_stats.pow_cntr = 1; -k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.pow_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -2503,40 +2503,40 @@ k.smallest_literal_stats.conjunction_cntr = 0; k.smallest_literal_stats.constant_cntr = 1; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 1; +k.smallest_literal_stats.equalto_cntr = 0; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 0; +k.smallest_literal_stats.inequality_cntr = 1; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; -k.smallest_literal_stats.pow_cntr = 1; -k.smallest_literal_stats.realconstant_cntr = 1; +k.smallest_literal_stats.pow_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 0; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.217245; -expected_value = 5.897490034861308e-17; +k.theory_checksat_ms = 1.30679; +expected_value = 0.02644266276326945; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 17297: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 17002: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2102; +k.assertions_size = 2094; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 374; -k.assertions_stats.conjunction_cntr = 2102; -k.assertions_stats.constant_cntr = 1098; +k.assertions_stats.addition_cntr = 366; +k.assertions_stats.conjunction_cntr = 2094; +k.assertions_stats.constant_cntr = 1090; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 2095; +k.assertions_stats.equalto_cntr = 2087; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; @@ -2546,7 +2546,7 @@ k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; k.assertions_stats.multiplication_cntr = 335; -k.assertions_stats.negation_cntr = 1383; +k.assertions_stats.negation_cntr = 1391; k.assertions_stats.notequalto_cntr = 0; k.assertions_stats.pow_cntr = 1; k.assertions_stats.realconstant_cntr = 1327; @@ -2555,7 +2555,7 @@ k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; k.assertions_stats.unique_variables = 24; -k.assertions_stats.variable_cntr = 2137; +k.assertions_stats.variable_cntr = 2129; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 4; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -2613,9 +2613,9 @@ k.box_continuous_count = 23; k.box_integer_count = 1; k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; -k.middle_assertion_stats.addition_cntr = 1; +k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; k.middle_assertion_stats.equalto_cntr = 1; @@ -2628,10 +2628,10 @@ k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; -k.middle_assertion_stats.realconstant_cntr = 0; +k.middle_assertion_stats.realconstant_cntr = 1; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; @@ -2665,9 +2665,9 @@ k.middle_literal_stats.uninterpretedfunction_cntr = 0; k.middle_literal_stats.unique_variables = 1; k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; -k.smallest_assertion_stats.addition_cntr = 0; +k.smallest_assertion_stats.addition_cntr = 1; k.smallest_assertion_stats.conjunction_cntr = 0; -k.smallest_assertion_stats.constant_cntr = 0; +k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; k.smallest_assertion_stats.equalto_cntr = 1; @@ -2680,10 +2680,10 @@ k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 1; +k.smallest_assertion_stats.realconstant_cntr = 0; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -2716,43 +2716,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0719901; -expected_value = 5.7494126276228756e-11; +k.theory_checksat_ms = 0.276103; +expected_value = 0.00021564863787240456; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 10688: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 10736: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 458; +k.assertions_size = 2104; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 182; -k.assertions_stats.conjunction_cntr = 458; -k.assertions_stats.constant_cntr = 363; +k.assertions_stats.addition_cntr = 379; +k.assertions_stats.conjunction_cntr = 2104; +k.assertions_stats.constant_cntr = 1099; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 253; +k.assertions_stats.equalto_cntr = 2097; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 205; +k.assertions_stats.inequality_cntr = 7; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 122; -k.assertions_stats.negation_cntr = 113; +k.assertions_stats.multiplication_cntr = 335; +k.assertions_stats.negation_cntr = 1375; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 10; -k.assertions_stats.realconstant_cntr = 0; +k.assertions_stats.pow_cntr = 1; +k.assertions_stats.realconstant_cntr = 1328; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 233; -k.assertions_stats.variable_cntr = 806; +k.assertions_stats.unique_variables = 24; +k.assertions_stats.variable_cntr = 2139; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 4; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.constant_cntr = 6; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -2764,7 +2764,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.multiplication_cntr = 6; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -2773,12 +2773,12 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_assertion_stats.unique_variables = 7; +k.biggest_assertion_stats.variable_cntr = 8; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; k.biggest_literal_stats.equalto_cntr = 1; @@ -2794,34 +2794,34 @@ k.biggest_literal_stats.multiplication_cntr = 0; k.biggest_literal_stats.negation_cntr = 0; k.biggest_literal_stats.notequalto_cntr = 0; k.biggest_literal_stats.pow_cntr = 0; -k.biggest_literal_stats.realconstant_cntr = 0; +k.biggest_literal_stats.realconstant_cntr = 1; k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 1288; -k.box_continuous_count = 233; -k.box_integer_count = 0; -k.lemma_size = 3; +k.box_boolean_count = 0; +k.box_continuous_count = 23; +k.box_integer_count = 1; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.addition_cntr = 1; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -2834,15 +2834,15 @@ k.middle_assertion_stats.variable_cntr = 1; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; -k.middle_literal_stats.constant_cntr = 1; +k.middle_literal_stats.constant_cntr = 0; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.inequality_cntr = 0; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; @@ -2850,7 +2850,7 @@ k.middle_literal_stats.multiplication_cntr = 0; k.middle_literal_stats.negation_cntr = 0; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; -k.middle_literal_stats.realconstant_cntr = 0; +k.middle_literal_stats.realconstant_cntr = 1; k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; @@ -2860,15 +2860,15 @@ k.middle_literal_stats.variable_cntr = 1; k.smallest_assertion_stats.abs_cntr = 0; k.smallest_assertion_stats.addition_cntr = 0; k.smallest_assertion_stats.conjunction_cntr = 0; -k.smallest_assertion_stats.constant_cntr = 1; +k.smallest_assertion_stats.constant_cntr = 0; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.inequality_cntr = 0; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; @@ -2876,7 +2876,7 @@ k.smallest_assertion_stats.multiplication_cntr = 0; k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; -k.smallest_assertion_stats.realconstant_cntr = 0; +k.smallest_assertion_stats.realconstant_cntr = 1; k.smallest_assertion_stats.sqrt_cntr = 0; k.smallest_assertion_stats.trigonometry_cntr = 0; k.smallest_assertion_stats.true_cntr = 0; @@ -2886,15 +2886,15 @@ k.smallest_assertion_stats.variable_cntr = 1; k.smallest_literal_stats.abs_cntr = 0; k.smallest_literal_stats.addition_cntr = 0; k.smallest_literal_stats.conjunction_cntr = 0; -k.smallest_literal_stats.constant_cntr = 1; +k.smallest_literal_stats.constant_cntr = 0; k.smallest_literal_stats.disjunction_cntr = 0; k.smallest_literal_stats.division_cntr = 0; -k.smallest_literal_stats.equalto_cntr = 0; +k.smallest_literal_stats.equalto_cntr = 1; k.smallest_literal_stats.exp_cntr = 0; k.smallest_literal_stats.false_cntr = 0; k.smallest_literal_stats.forall_cntr = 0; k.smallest_literal_stats.ifthenelse_cntr = 0; -k.smallest_literal_stats.inequality_cntr = 1; +k.smallest_literal_stats.inequality_cntr = 0; k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; @@ -2902,46 +2902,46 @@ k.smallest_literal_stats.multiplication_cntr = 0; k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; -k.smallest_literal_stats.realconstant_cntr = 0; +k.smallest_literal_stats.realconstant_cntr = 1; k.smallest_literal_stats.sqrt_cntr = 0; k.smallest_literal_stats.trigonometry_cntr = 0; k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.0775831; -expected_value = 6.578650585805967e-05; +k.theory_checksat_ms = 0.16993; +expected_value = 6.504819201251068e-07; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 625: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 10372: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2069; +k.assertions_size = 2634; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 902; -k.assertions_stats.conjunction_cntr = 2069; -k.assertions_stats.constant_cntr = 1569; +k.assertions_stats.addition_cntr = 1130; +k.assertions_stats.conjunction_cntr = 2634; +k.assertions_stats.constant_cntr = 2309; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1207; +k.assertions_stats.equalto_cntr = 1887; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 862; +k.assertions_stats.inequality_cntr = 747; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 536; -k.assertions_stats.negation_cntr = 538; +k.assertions_stats.multiplication_cntr = 1276; +k.assertions_stats.negation_cntr = 662; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 46; +k.assertions_stats.pow_cntr = 64; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1079; -k.assertions_stats.variable_cntr = 3722; +k.assertions_stats.unique_variables = 1619; +k.assertions_stats.variable_cntr = 5302; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -2971,15 +2971,15 @@ k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -2992,29 +2992,29 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 5725; -k.box_continuous_count = 1079; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 4406; +k.box_continuous_count = 1619; k.box_integer_count = 0; -k.lemma_size = 3; +k.lemma_size = 6; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 0; +k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -3030,12 +3030,12 @@ k.middle_literal_stats.conjunction_cntr = 0; k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; k.middle_literal_stats.division_cntr = 0; -k.middle_literal_stats.equalto_cntr = 0; +k.middle_literal_stats.equalto_cntr = 1; k.middle_literal_stats.exp_cntr = 0; k.middle_literal_stats.false_cntr = 0; k.middle_literal_stats.forall_cntr = 0; k.middle_literal_stats.ifthenelse_cntr = 0; -k.middle_literal_stats.inequality_cntr = 1; +k.middle_literal_stats.inequality_cntr = 0; k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; @@ -3056,17 +3056,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 1; +k.smallest_assertion_stats.equalto_cntr = 0; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 0; +k.smallest_assertion_stats.inequality_cntr = 1; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 0; +k.smallest_assertion_stats.negation_cntr = 1; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -3092,7 +3092,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -3102,39 +3102,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.139642; -expected_value = 0.18618322378649993; +k.theory_checksat_ms = 11.4709; +expected_value = 0.3956353498959523; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 15965: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16696: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1289; +k.assertions_size = 2785; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 582; -k.assertions_stats.conjunction_cntr = 1289; -k.assertions_stats.constant_cntr = 985; +k.assertions_stats.addition_cntr = 1222; +k.assertions_stats.conjunction_cntr = 2785; +k.assertions_stats.constant_cntr = 2105; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 751; +k.assertions_stats.equalto_cntr = 1631; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 538; +k.assertions_stats.inequality_cntr = 1154; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 304; -k.assertions_stats.negation_cntr = 303; +k.assertions_stats.multiplication_cntr = 720; +k.assertions_stats.negation_cntr = 929; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 30; +k.assertions_stats.pow_cntr = 62; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 671; -k.assertions_stats.variable_cntr = 2282; +k.assertions_stats.unique_variables = 1455; +k.assertions_stats.variable_cntr = 5018; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 0; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -3187,10 +3187,10 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 3529; -k.box_continuous_count = 671; +k.box_boolean_count = 7697; +k.box_continuous_count = 1455; k.box_integer_count = 0; -k.lemma_size = 3; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; @@ -3206,8 +3206,8 @@ k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; -k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 1; +k.middle_assertion_stats.multiplication_cntr = 1; +k.middle_assertion_stats.negation_cntr = 0; k.middle_assertion_stats.notequalto_cntr = 0; k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; @@ -3215,8 +3215,8 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.middle_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; k.middle_literal_stats.addition_cntr = 0; k.middle_literal_stats.conjunction_cntr = 0; @@ -3233,7 +3233,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -3285,7 +3285,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 0; +k.smallest_literal_stats.negation_cntr = 1; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -3295,51 +3295,51 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.26743; -expected_value = 0.2324655459054427; +k.theory_checksat_ms = 0.226032; +expected_value = 0.3314437657064444; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 16188: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 15562: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1973; +k.assertions_size = 91; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 902; -k.assertions_stats.conjunction_cntr = 1973; -k.assertions_stats.constant_cntr = 1497; +k.assertions_stats.addition_cntr = 118; +k.assertions_stats.conjunction_cntr = 91; +k.assertions_stats.constant_cntr = 91; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1159; +k.assertions_stats.equalto_cntr = 0; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 814; +k.assertions_stats.inequality_cntr = 91; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 464; -k.assertions_stats.negation_cntr = 470; +k.assertions_stats.multiplication_cntr = 0; +k.assertions_stats.negation_cntr = 31; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 46; +k.assertions_stats.pow_cntr = 0; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1031; -k.assertions_stats.variable_cntr = 3506; +k.assertions_stats.unique_variables = 16; +k.assertions_stats.variable_cntr = 150; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 0; +k.biggest_assertion_stats.constant_cntr = 1; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; -k.biggest_assertion_stats.equalto_cntr = 1; +k.biggest_assertion_stats.equalto_cntr = 0; k.biggest_assertion_stats.exp_cntr = 0; k.biggest_assertion_stats.false_cntr = 0; k.biggest_assertion_stats.forall_cntr = 0; k.biggest_assertion_stats.ifthenelse_cntr = 0; -k.biggest_assertion_stats.inequality_cntr = 0; +k.biggest_assertion_stats.inequality_cntr = 1; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; @@ -3352,10 +3352,10 @@ k.biggest_assertion_stats.sqrt_cntr = 0; k.biggest_assertion_stats.trigonometry_cntr = 0; k.biggest_assertion_stats.true_cntr = 0; k.biggest_assertion_stats.uninterpretedfunction_cntr = 0; -k.biggest_assertion_stats.unique_variables = 3; -k.biggest_assertion_stats.variable_cntr = 3; +k.biggest_assertion_stats.unique_variables = 2; +k.biggest_assertion_stats.variable_cntr = 2; k.biggest_literal_stats.abs_cntr = 0; -k.biggest_literal_stats.addition_cntr = 0; +k.biggest_literal_stats.addition_cntr = 2; k.biggest_literal_stats.conjunction_cntr = 0; k.biggest_literal_stats.constant_cntr = 1; k.biggest_literal_stats.disjunction_cntr = 0; @@ -3378,24 +3378,24 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 5389; -k.box_continuous_count = 1031; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 0; +k.box_continuous_count = 16; k.box_integer_count = 0; -k.lemma_size = 3; +k.lemma_size = 33; k.middle_assertion_stats.abs_cntr = 0; -k.middle_assertion_stats.addition_cntr = 0; +k.middle_assertion_stats.addition_cntr = 2; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; @@ -3408,10 +3408,10 @@ k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; k.middle_assertion_stats.true_cntr = 0; k.middle_assertion_stats.uninterpretedfunction_cntr = 0; -k.middle_assertion_stats.unique_variables = 1; -k.middle_assertion_stats.variable_cntr = 1; +k.middle_assertion_stats.unique_variables = 2; +k.middle_assertion_stats.variable_cntr = 2; k.middle_literal_stats.abs_cntr = 0; -k.middle_literal_stats.addition_cntr = 0; +k.middle_literal_stats.addition_cntr = 2; k.middle_literal_stats.conjunction_cntr = 0; k.middle_literal_stats.constant_cntr = 1; k.middle_literal_stats.disjunction_cntr = 0; @@ -3434,8 +3434,8 @@ k.middle_literal_stats.sqrt_cntr = 0; k.middle_literal_stats.trigonometry_cntr = 0; k.middle_literal_stats.true_cntr = 0; k.middle_literal_stats.uninterpretedfunction_cntr = 0; -k.middle_literal_stats.unique_variables = 1; -k.middle_literal_stats.variable_cntr = 1; +k.middle_literal_stats.unique_variables = 2; +k.middle_literal_stats.variable_cntr = 2; k.smallest_assertion_stats.abs_cntr = 0; k.smallest_assertion_stats.addition_cntr = 0; k.smallest_assertion_stats.conjunction_cntr = 0; @@ -3452,7 +3452,7 @@ k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -3478,7 +3478,7 @@ k.smallest_literal_stats.log_cntr = 0; k.smallest_literal_stats.max_cntr = 0; k.smallest_literal_stats.min_cntr = 0; k.smallest_literal_stats.multiplication_cntr = 0; -k.smallest_literal_stats.negation_cntr = 1; +k.smallest_literal_stats.negation_cntr = 0; k.smallest_literal_stats.notequalto_cntr = 0; k.smallest_literal_stats.pow_cntr = 0; k.smallest_literal_stats.realconstant_cntr = 0; @@ -3488,39 +3488,39 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.109711; -expected_value = 0.052861938669424464; +k.theory_checksat_ms = 1.27253; +expected_value = 0.1014047539809046; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 1356: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 1788: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 2486; +k.assertions_size = 2069; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 1142; -k.assertions_stats.conjunction_cntr = 2486; -k.assertions_stats.constant_cntr = 1881; +k.assertions_stats.addition_cntr = 902; +k.assertions_stats.conjunction_cntr = 2069; +k.assertions_stats.constant_cntr = 1569; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 1465; +k.assertions_stats.equalto_cntr = 1207; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 1021; +k.assertions_stats.inequality_cntr = 862; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 584; -k.assertions_stats.negation_cntr = 592; +k.assertions_stats.multiplication_cntr = 536; +k.assertions_stats.negation_cntr = 505; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 58; +k.assertions_stats.pow_cntr = 46; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 1301; -k.assertions_stats.variable_cntr = 4424; +k.assertions_stats.unique_variables = 1079; +k.assertions_stats.variable_cntr = 3722; k.biggest_assertion_stats.abs_cntr = 0; k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; @@ -3550,15 +3550,15 @@ k.biggest_assertion_stats.variable_cntr = 3; k.biggest_literal_stats.abs_cntr = 0; k.biggest_literal_stats.addition_cntr = 0; k.biggest_literal_stats.conjunction_cntr = 0; -k.biggest_literal_stats.constant_cntr = 1; +k.biggest_literal_stats.constant_cntr = 0; k.biggest_literal_stats.disjunction_cntr = 0; k.biggest_literal_stats.division_cntr = 0; -k.biggest_literal_stats.equalto_cntr = 0; +k.biggest_literal_stats.equalto_cntr = 1; k.biggest_literal_stats.exp_cntr = 0; k.biggest_literal_stats.false_cntr = 0; k.biggest_literal_stats.forall_cntr = 0; k.biggest_literal_stats.ifthenelse_cntr = 0; -k.biggest_literal_stats.inequality_cntr = 1; +k.biggest_literal_stats.inequality_cntr = 0; k.biggest_literal_stats.log_cntr = 0; k.biggest_literal_stats.max_cntr = 0; k.biggest_literal_stats.min_cntr = 0; @@ -3571,31 +3571,31 @@ k.biggest_literal_stats.sqrt_cntr = 0; k.biggest_literal_stats.trigonometry_cntr = 0; k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; -k.biggest_literal_stats.unique_variables = 1; -k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 6784; -k.box_continuous_count = 1301; +k.biggest_literal_stats.unique_variables = 2; +k.biggest_literal_stats.variable_cntr = 2; +k.box_boolean_count = 5725; +k.box_continuous_count = 1079; k.box_integer_count = 0; -k.lemma_size = 3; +k.lemma_size = 11; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; -k.middle_assertion_stats.constant_cntr = 1; +k.middle_assertion_stats.constant_cntr = 0; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 1; +k.middle_assertion_stats.equalto_cntr = 0; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 0; +k.middle_assertion_stats.inequality_cntr = 1; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; k.middle_assertion_stats.multiplication_cntr = 0; -k.middle_assertion_stats.negation_cntr = 0; +k.middle_assertion_stats.negation_cntr = 1; k.middle_assertion_stats.notequalto_cntr = 0; -k.middle_assertion_stats.pow_cntr = 1; +k.middle_assertion_stats.pow_cntr = 0; k.middle_assertion_stats.realconstant_cntr = 0; k.middle_assertion_stats.sqrt_cntr = 0; k.middle_assertion_stats.trigonometry_cntr = 0; @@ -3635,17 +3635,17 @@ k.smallest_assertion_stats.conjunction_cntr = 0; k.smallest_assertion_stats.constant_cntr = 1; k.smallest_assertion_stats.disjunction_cntr = 0; k.smallest_assertion_stats.division_cntr = 0; -k.smallest_assertion_stats.equalto_cntr = 0; +k.smallest_assertion_stats.equalto_cntr = 1; k.smallest_assertion_stats.exp_cntr = 0; k.smallest_assertion_stats.false_cntr = 0; k.smallest_assertion_stats.forall_cntr = 0; k.smallest_assertion_stats.ifthenelse_cntr = 0; -k.smallest_assertion_stats.inequality_cntr = 1; +k.smallest_assertion_stats.inequality_cntr = 0; k.smallest_assertion_stats.log_cntr = 0; k.smallest_assertion_stats.max_cntr = 0; k.smallest_assertion_stats.min_cntr = 0; k.smallest_assertion_stats.multiplication_cntr = 0; -k.smallest_assertion_stats.negation_cntr = 1; +k.smallest_assertion_stats.negation_cntr = 0; k.smallest_assertion_stats.notequalto_cntr = 0; k.smallest_assertion_stats.pow_cntr = 0; k.smallest_assertion_stats.realconstant_cntr = 0; @@ -3681,43 +3681,43 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.14882; -expected_value = 0.21714960356919458; +k.theory_checksat_ms = 6.71753; +expected_value = 0.14082359371285263; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 2247: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 16066: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); -k.assertions_size = 1460; +k.assertions_size = 89; k.assertions_stats.abs_cntr = 0; -k.assertions_stats.addition_cntr = 662; -k.assertions_stats.conjunction_cntr = 1460; -k.assertions_stats.constant_cntr = 1113; +k.assertions_stats.addition_cntr = 22; +k.assertions_stats.conjunction_cntr = 89; +k.assertions_stats.constant_cntr = 86; k.assertions_stats.disjunction_cntr = 0; k.assertions_stats.division_cntr = 0; -k.assertions_stats.equalto_cntr = 853; +k.assertions_stats.equalto_cntr = 34; k.assertions_stats.exp_cntr = 0; k.assertions_stats.false_cntr = 0; k.assertions_stats.forall_cntr = 0; k.assertions_stats.ifthenelse_cntr = 0; -k.assertions_stats.inequality_cntr = 607; +k.assertions_stats.inequality_cntr = 55; k.assertions_stats.log_cntr = 0; k.assertions_stats.max_cntr = 0; k.assertions_stats.min_cntr = 0; -k.assertions_stats.multiplication_cntr = 344; -k.assertions_stats.negation_cntr = 341; +k.assertions_stats.multiplication_cntr = 21; +k.assertions_stats.negation_cntr = 16; k.assertions_stats.notequalto_cntr = 0; -k.assertions_stats.pow_cntr = 34; +k.assertions_stats.pow_cntr = 2; k.assertions_stats.realconstant_cntr = 0; k.assertions_stats.sqrt_cntr = 0; k.assertions_stats.trigonometry_cntr = 0; k.assertions_stats.true_cntr = 0; k.assertions_stats.uninterpretedfunction_cntr = 0; -k.assertions_stats.unique_variables = 761; -k.assertions_stats.variable_cntr = 2588; +k.assertions_stats.unique_variables = 38; +k.assertions_stats.variable_cntr = 134; k.biggest_assertion_stats.abs_cntr = 0; -k.biggest_assertion_stats.addition_cntr = 0; +k.biggest_assertion_stats.addition_cntr = 2; k.biggest_assertion_stats.conjunction_cntr = 0; -k.biggest_assertion_stats.constant_cntr = 2; +k.biggest_assertion_stats.constant_cntr = 0; k.biggest_assertion_stats.disjunction_cntr = 0; k.biggest_assertion_stats.division_cntr = 0; k.biggest_assertion_stats.equalto_cntr = 1; @@ -3729,7 +3729,7 @@ k.biggest_assertion_stats.inequality_cntr = 0; k.biggest_assertion_stats.log_cntr = 0; k.biggest_assertion_stats.max_cntr = 0; k.biggest_assertion_stats.min_cntr = 0; -k.biggest_assertion_stats.multiplication_cntr = 2; +k.biggest_assertion_stats.multiplication_cntr = 0; k.biggest_assertion_stats.negation_cntr = 0; k.biggest_assertion_stats.notequalto_cntr = 0; k.biggest_assertion_stats.pow_cntr = 0; @@ -3766,22 +3766,22 @@ k.biggest_literal_stats.true_cntr = 0; k.biggest_literal_stats.uninterpretedfunction_cntr = 0; k.biggest_literal_stats.unique_variables = 1; k.biggest_literal_stats.variable_cntr = 1; -k.box_boolean_count = 3994; -k.box_continuous_count = 761; +k.box_boolean_count = 274; +k.box_continuous_count = 38; k.box_integer_count = 0; -k.lemma_size = 3; +k.lemma_size = 2; k.middle_assertion_stats.abs_cntr = 0; k.middle_assertion_stats.addition_cntr = 0; k.middle_assertion_stats.conjunction_cntr = 0; k.middle_assertion_stats.constant_cntr = 1; k.middle_assertion_stats.disjunction_cntr = 0; k.middle_assertion_stats.division_cntr = 0; -k.middle_assertion_stats.equalto_cntr = 0; +k.middle_assertion_stats.equalto_cntr = 1; k.middle_assertion_stats.exp_cntr = 0; k.middle_assertion_stats.false_cntr = 0; k.middle_assertion_stats.forall_cntr = 0; k.middle_assertion_stats.ifthenelse_cntr = 0; -k.middle_assertion_stats.inequality_cntr = 1; +k.middle_assertion_stats.inequality_cntr = 0; k.middle_assertion_stats.log_cntr = 0; k.middle_assertion_stats.max_cntr = 0; k.middle_assertion_stats.min_cntr = 0; @@ -3812,7 +3812,7 @@ k.middle_literal_stats.log_cntr = 0; k.middle_literal_stats.max_cntr = 0; k.middle_literal_stats.min_cntr = 0; k.middle_literal_stats.multiplication_cntr = 0; -k.middle_literal_stats.negation_cntr = 0; +k.middle_literal_stats.negation_cntr = 1; k.middle_literal_stats.notequalto_cntr = 0; k.middle_literal_stats.pow_cntr = 0; k.middle_literal_stats.realconstant_cntr = 0; @@ -3874,10 +3874,10 @@ k.smallest_literal_stats.true_cntr = 0; k.smallest_literal_stats.uninterpretedfunction_cntr = 0; k.smallest_literal_stats.unique_variables = 1; k.smallest_literal_stats.variable_cntr = 1; -k.theory_checksat_ms = 0.32306; -expected_value = 0.355702855225073; +k.theory_checksat_ms = 0.0367441; +expected_value = 0.23488732402191095; calculated_value = PatternMatchingHeuristic::calculate(k); -std::cout << "Trial 12988: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; +std::cout << "Trial 15765: C++/Python neural inference delta = " << expected_value - calculated_value << std::endl; EXPECT_NEAR(calculated_value, expected_value, 0.001); From e8585c9196ec65c58f36b5ea1ea129f7b1192d91 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 19 Apr 2025 12:15:53 -0700 Subject: [PATCH 37/79] Fix many bugs in SAT-level interval logic. --- src/dreal/solver/sat_solver.h | 10 +- src/dreal/solver/sat_solver_interval_logic.cc | 565 ++++++++++++------ .../solver/test/sat_solver_inteveral_test.cc | 34 +- 3 files changed, 399 insertions(+), 210 deletions(-) diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 064e4a40c..c049f16f2 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -73,9 +73,11 @@ class SatSolver : public CaDiCaL::Learner { PredicateNormalizer& pn, const std::vector& base_conflict, const Box& base_box, std::chrono::duration timeout); + std::pair MakeSatUbVar(PredicateNormalizer& pn, const Variable& var, double ub, bool inclusive); + std::pair MakeSatLbVar(PredicateNormalizer& pn, const Variable& var, double lb, bool inclusive); void AddBox(PredicateNormalizer& pn, const Box& base_box); - Formula MakeSatIntervalVar(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv); + Formula MakeSatIntervalVarWithClauses(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv); /// Checks the satisfiability of the current configuration. /// @@ -126,8 +128,10 @@ class SatSolver : public CaDiCaL::Learner { /// transformations. ScopedUnorderedSet tseitin_variables_; - std::unordered_map> all_lb_predicates; - std::unordered_map> all_ub_predicates; + std::unordered_map> all_excl_lb_predicates; + std::unordered_map> all_incl_lb_predicates; + std::unordered_map> all_excl_ub_predicates; + std::unordered_map> all_incl_ub_predicates; // learner stuff. private: diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 52c16fe76..256c0a9cc 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -2,204 +2,389 @@ // Created by Kunal Sheth on 4/17/25. // +#include #include #include "auditor.h" +#include "filter_assertion.h" #include "sat_solver.h" -namespace dreal { - -using std::cout; -using std::set; -using std::vector; - -void SatSolver::AddLearnedClause( - PredicateNormalizer& pn, - const vector& conflicting_conjunction, const Box& box -) { - if (DREAL_LOG_DEBUG_ENABLED) audit(!make_conjunction(conflicting_conjunction), box); - - // a & b & c & ... ==> ~(x & y & z & ...) - // ~(a & b & c & ...) | ~(x & y & z & ...) - // ~a | ~b | ~c | ... | ~x | ~y | ~z | ... - - for (const auto& v : box.variables()) { - const auto condition = MakeSatIntervalVar(pn, v, box[v]); - if (is_true(condition)) continue; - else if (!is_conjunction(condition)) AddLiteral(!condition); // already predicate-converted. - else for (const auto& lit : get_operands(condition)) AddLiteral(!lit); - } - // ==> - for (const Formula& f : conflicting_conjunction) AddLiteral(!predicate_abstractor_.Convert(f)); - - cadical->add(0); -} - -void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { - for (const auto& v : base_box.variables()) { - const auto condition = MakeSatIntervalVar(pn, v, base_box[v]); - if (is_true(condition)) continue; - for ( - const auto& lit : - is_conjunction(condition) ? get_operands(condition) : set{condition} +namespace dreal +{ + void audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, + const std::optional& box) { + for (auto& l : lits) { + if (is_variable(l)) { + // f = b + const auto& var = get_variable(l); + const auto iter = pa.var_to_formula_map().find(get_variable(l)); + if (iter != pa.var_to_formula_map().end()) l = iter->second; + // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` + } + else { + // f = ¬b + DREAL_ASSERT(is_negation(l) && is_variable(get_operand(l))); + const auto iter = pa.var_to_formula_map().find(get_variable(get_operand(l))); + if (iter != pa.var_to_formula_map().end()) l = !iter->second; + // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` + } + } + audit(make_disjunction(lits), box); + } + + void SatSolver::AddLearnedClauseUnboxed( + const std::vector& conflicting_conjunction ) { - // todo: audit? currently can't because it is already predicate_abstractor-ed - AddLiteral(lit); - cadical->add(0); + label_literal_log("AddLearnedClauseUnboxed"); + for (const Formula& f : conflicting_conjunction) { + AddLiteral(!predicate_abstractor_.Convert(f)); + } + cadical->add(0); + flush_clause(); + + if (DREAL_LOG_INFO_ENABLED) { + std::vector a; + for (const Formula& f : conflicting_conjunction) { + a.emplace_back(!predicate_abstractor_.Convert(f)); + } + audit_literals(predicate_abstractor_, a, {}); + } } - } -} - -PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( - PredicateNormalizer& pn, - const vector& base_conflict, const Box& base_box, - const std::chrono::duration timeout -) { - // the pattern matching is kinda best-effort now. - // it breaks down when one clause pattern matches into 1000s of permutations of itself - // just make the best effort, and at the very minimum make sure the original at least gets inserted - AddLearnedClause(pn, base_conflict, base_box); - const auto [ - all_related_conflicts, - match_statistics - ] = pn.FindSimilar(base_conflict, timeout); - if (all_related_conflicts.empty()) { - DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); - return match_statistics; - } - - for (const auto& [conflict_clause, subs] : all_related_conflicts) { - const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); - - if (DREAL_LOG_INFO_ENABLED) { // todo: better gate. - std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); - audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), conflict_box); + + void FlattenIntervalClause(const Formula& intv, const std::function& f) { + if (is_true(intv)) { /* no-op */ } + else if (is_conjunction(intv)) { + const auto ops = get_operands(intv); + DREAL_ASSERT(ops.size() == 2); + for (const auto& op : ops) f(op); + } + else f(intv); } - AddLearnedClause(pn, conflict_clause, conflict_box); - } - return match_statistics; -} - -Formula SatSolver::MakeSatIntervalVar(PredicateNormalizer &pn, const Variable& var, const Box::Interval& intv) { - // DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); - if (var.get_type() == Variable::Type::BOOLEAN) { - if (intv.lb() == 1) return Formula{var}; - if (intv.ub() == 0) return !Formula{var}; - DREAL_ASSERT(intv.lb() == 0 && intv.ub() == 1); - return Formula::True(); - } // else { - - DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVar({} ∈ {})", fmt::streamed(var), fmt::streamed(intv)); - auto ub_pred = Formula::True(); - if (isfinite(intv.ub())) { - ub_pred = var <= intv.ub(); // TODO: figure out if this is inclusive or exclusive. - // an iterator pointing to the first element that is greater or equal to intv.ub() - auto& var_ub_preds = all_ub_predicates[var]; - auto ub_gte_it = var_ub_preds.lower_bound(intv.ub()); - if (!var_ub_preds.empty() && ub_gte_it->first == intv.ub()) ub_pred = ub_gte_it->second; - else { - ub_pred = predicate_abstractor_.Convert(pn.Convert(ub_pred)); - MakeSatVar(get_variable(ub_pred)); - - if (ub_gte_it != var_ub_preds.end()) { - const auto& gt = *ub_gte_it; - DREAL_ASSERT(intv.ub() < gt.first); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", ub_pred, gt.second); - // std::cout << ub_pred << " => " << gt.second << std::endl; - // (x < Ub) => (x < Ub+ε) - // = ~(x < Ub) \/ (x < Ub+ε) - // = ~((x < Ub) /\ ~(x < Ub+ε)) - AddLearnedClause(pn, {ub_pred, !gt.second}, {/* empty— will overflow stack otherwise. */}); - } - if (ub_gte_it != var_ub_preds.begin()) { - --ub_gte_it; - const auto& lt = *ub_gte_it; - DREAL_ASSERT(lt.first < intv.ub()); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lt.second, ub_pred); - // std::cout << lt.second << " => " << ub_pred << std::endl; - // (x < Ub-ε) => (x < Ub) - // = ~(x < Ub-ε) \/ (x < Ub) - // = ~((x < Ub-ε) /\ ~(x < Ub)) - AddLearnedClause(pn, {lt.second, !ub_pred}, {/* empty— will overflow stack otherwise. */}); - } - var_ub_preds[intv.ub()] = ub_pred; + void SatSolver::AddLearnedClause( + PredicateNormalizer& pn, + const std::vector& conflicting_conjunction, const Box& unfitted_box + ) { + label_literal_log("AddLearnedClause"); + for (const auto& lit : conflicting_conjunction) { + if (lit.GetFreeVariables().size() != 1 || !is_relational(lit)) continue; + const Variable& var = *lit.GetFreeVariables().begin(); + + const Box infinite_box{{var}}; + Box fitted_box{{var}}; + fitted_box[var] = unfitted_box[var]; + const auto r = FilterAssertion(lit, &fitted_box); + + if (r.filtered) { + // automatically builds implications + // if !r.change: + // unfitted => lit + // if r.change: + // lit /\ unfitted => fitted + + MakeSatIntervalVarWithClauses(pn, var, infinite_box[var]); + // MakeSatIntervalVarWithClauses(pn, var, unfitted_box[var]); // redundant, made later. + MakeSatIntervalVarWithClauses(pn, var, fitted_box[var]); + } + + /*else if (r.filtered && r.changed) { + const auto unfitted = MakeSatIntervalVarWithClauses(pn, var, unfitted_box[var]); + const auto fitted = MakeSatIntervalVarWithClauses(pn, var, fitted_box[var]); + + // lit /\ unfitted => fitted + // ~(lit /\ unfitted) \/ fitted + // ~lit \/ ~unfitted \/ fitted + + AddLiteral(!predicate_abstractor_.Convert(lit)); + FlattenIntervalClause(unfitted, [&](const auto& il) { AddLiteral(!il); }); + FlattenIntervalClause(fitted, [&](const auto& il) { AddLiteral(il); }); + cadical->add(0); + flush_clause(); + + if (DREAL_LOG_INFO_ENABLED) { + std::vector a; + a.emplace_back(!predicate_abstractor_.Convert(lit)); + FlattenIntervalClause(unfitted, [&](const auto& il) { a.emplace_back(!il); }); + FlattenIntervalClause(fitted, [&](const auto& il) { a.emplace_back(il); }); + audit_literals(predicate_abstractor_, a, {}); + } + } + else if (!r.filtered && !r.changed) { + // no-op, was mistaken for something else... + // e.g. `((5 + 6 * x + 2 * pow(x, 2)) < 0)` could end up here + } + else + DREAL_UNREACHABLE();*/ + } + + // a & b & c & ... ==> ~(x & y & z & ...) + // ~(a & b & c & ...) | ~(x & y & z & ...) + // ~a | ~b | ~c | ... | ~x | ~y | ~z | ... + std::vector lhs_implies; + lhs_implies.reserve(unfitted_box.size() * 2); + for (const auto& v : unfitted_box.variables()) { + const auto condition = MakeSatIntervalVarWithClauses(pn, v, unfitted_box[v]); + // need to use lhs_implies since MakeSatIntervalVarWithClauses adds its own sequence of clauses + // terminating with `cadical->add(0)` + FlattenIntervalClause(condition, [&](const auto& l) { lhs_implies.emplace_back(!l); }); + } + + for (const auto& lit : lhs_implies) AddLiteral(lit); + // ==> + for (const Formula& f : conflicting_conjunction) AddLiteral(!predicate_abstractor_.Convert(f)); + cadical->add(0); + flush_clause(); + + if (DREAL_LOG_INFO_ENABLED) { + audit(!make_conjunction(conflicting_conjunction), unfitted_box); + + std::vector a; + for (const auto& lit : lhs_implies) a.emplace_back(lit); + // ==> + for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); + audit_literals(predicate_abstractor_, a, {}); + } + } + + void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { + label_literal_log("AddBox"); + for (const auto& v : base_box.variables()) { + const auto condition = MakeSatIntervalVarWithClauses(pn, v, base_box[v]); + if (is_true(condition)) continue; + for ( + const auto& lit : + is_conjunction(condition) ? get_operands(condition) : set{condition} + ) { + // todo: audit? currently can't because it is already predicate_abstractor-ed + AddLiteral(lit); + cadical->add(0); + flush_clause(); + } + } } - } - - auto lb_pred = Formula::True(); - if (isfinite(intv.lb())) { - lb_pred = intv.lb() <= var; // TODO: figure out if this is inclusive or exclusive. - // an iterator pointing to the first element that is greater or equal to intv.lb() - auto& var_lb_preds = all_lb_predicates[var]; - auto lb_gte_it = var_lb_preds.lower_bound(intv.lb()); - if (!var_lb_preds.empty() && lb_gte_it->first == intv.lb()) lb_pred = lb_gte_it->second; - else { - lb_pred = predicate_abstractor_.Convert(pn.Convert(lb_pred)); - MakeSatVar(get_variable(lb_pred)); - - if (lb_gte_it != var_lb_preds.end()) { - const auto& gt = *lb_gte_it; - DREAL_ASSERT(intv.lb() < gt.first); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", gt.second, lb_pred); - // std::cout << gt.second << " => " << lb_pred << std::endl; - // (Lb+ε < x) => (Lb < x) - // = ~(Lb+ε < x) \/ (Lb < x) - // = ~((Lb+ε < x) /\ ~(Lb < x)) - AddLearnedClause(pn, {gt.second, !lb_pred}, {/* empty— will overflow stack otherwise. */}); - } - if (lb_gte_it != var_lb_preds.begin()) { - --lb_gte_it; - const auto& lt = *lb_gte_it; - DREAL_ASSERT(lt.first < intv.lb()); - DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lb_pred, lt.second); - // std::cout << lb_pred << " => " << lt.second << std::endl; - // (Lb < x) => (Lb-ε < x) - // = ~(Lb < x) \/ (Lb-ε < x) - // = ~((Lb < x) /\ ~(Lb-ε < x)) - AddLearnedClause(pn, {lb_pred, !lt.second}, {/* empty— will overflow stack otherwise. */}); - } - var_lb_preds[intv.lb()] = lb_pred; + + PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( + PredicateNormalizer& pn, + const std::vector& base_conflict, const Box& base_box, + const std::chrono::duration timeout + ) { + label_literal_log("AddLearnedClausePattern"); + // the pattern matching is kinda best-effort now. + // it breaks down when one clause pattern matches into 1000s of permutations of itself + // just make the best effort, and at the very minimum make sure the original at least gets inserted + + const auto [ + all_related_conflicts, + match_statistics + ] = pn.FindSimilar(base_conflict, timeout); + if (all_related_conflicts.empty()) { + DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); + return match_statistics; + } + + for (const auto& [conflict_clause, subs] : all_related_conflicts) { + const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); + + if (DREAL_LOG_INFO_ENABLED) { // todo: better gate. + std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); + audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), conflict_box); + } + + AddLearnedClause(pn, conflict_clause, conflict_box); + } + return match_statistics; + } + + + std::pair SatSolver::MakeSatUbVar(PredicateNormalizer& pn, const Variable& var, const double ub, + const bool inclusive) { + if (!isfinite(ub)) return {Formula::True(), true}; + // else { + + // an iterator pointing to the first element that is greater or equal to ub + auto& var_ub_preds = (inclusive ? all_incl_ub_predicates : all_excl_ub_predicates)[var]; + auto ub_gte_it = var_ub_preds.lower_bound(ub); + if (ub_gte_it != var_ub_preds.end() && ub_gte_it->first == ub) { + return {ub_gte_it->second, true}; + } // else { + + Formula ub_pred = inclusive ? var <= ub : var < ub; + ub_pred = predicate_abstractor_.Convert(pn.Convert(ub_pred)); + MakeSatVar(get_variable(ub_pred)); + + if (ub_gte_it != var_ub_preds.end()) { + const auto& gt = *ub_gte_it; + DREAL_ASSERT(ub < gt.first); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", ub_pred, gt.second); + // std::cout << ub_pred << " => " << gt.second << std::endl; + // (x < Ub) => (x < Ub+ε) + // = ~(x < Ub) \/ (x < Ub+ε) + // = ~((x < Ub) /\ ~(x < Ub+ε)) + AddLearnedClauseUnboxed({ub_pred, !gt.second}); + } + if (ub_gte_it != var_ub_preds.begin()) { + --ub_gte_it; + const auto& lt = *ub_gte_it; + DREAL_ASSERT(lt.first < ub); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lt.second, ub_pred); + // std::cout << lt.second << " => " << ub_pred << std::endl; + // (x < Ub-ε) => (x < Ub) + // = ~(x < Ub-ε) \/ (x < Ub) + // = ~((x < Ub-ε) /\ ~(x < Ub)) + AddLearnedClauseUnboxed({lt.second, !ub_pred}); + } + var_ub_preds[ub] = ub_pred; + return {ub_pred, false}; + } + + + std::pair SatSolver::MakeSatLbVar(PredicateNormalizer& pn, const Variable& var, const double lb, + const bool inclusive) { + if (!isfinite(lb)) return {Formula::True(), true}; + // else { + + // an iterator pointing to the first element that is greater or equal to lb + auto& var_lb_preds = (inclusive ? all_incl_lb_predicates : all_excl_lb_predicates)[var]; + auto lb_gte_it = var_lb_preds.lower_bound(lb); + if (lb_gte_it != var_lb_preds.end() && lb_gte_it->first == lb) { + return {lb_gte_it->second, true}; + } // else { + + Formula lb_pred = inclusive ? lb <= var : lb < var; + lb_pred = predicate_abstractor_.Convert(pn.Convert(lb_pred)); + MakeSatVar(get_variable(lb_pred)); + + if (lb_gte_it != var_lb_preds.end()) { + const auto& gt = *lb_gte_it; + DREAL_ASSERT(lb < gt.first); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", gt.second, lb_pred); + // std::cout << gt.second << " => " << lb_pred << std::endl; + // (Lb+ε < x) => (Lb < x) + // = ~(Lb+ε < x) \/ (Lb < x) + // = ~((Lb+ε < x) /\ ~(Lb < x)) + AddLearnedClauseUnboxed({gt.second, !lb_pred}); + } + if (lb_gte_it != var_lb_preds.begin()) { + --lb_gte_it; + const auto& lt = *lb_gte_it; + DREAL_ASSERT(lt.first < lb); + DREAL_LOG_DEBUG("Adding SAT interval implication: {} => {}", lb_pred, lt.second); + // std::cout << lb_pred << " => " << lt.second << std::endl; + // (Lb < x) => (Lb-ε < x) + // = ~(Lb < x) \/ (Lb-ε < x) + // = ~((Lb < x) /\ ~(Lb-ε < x)) + AddLearnedClauseUnboxed({lb_pred, !lt.second}); + } + var_lb_preds[lb] = lb_pred; + return {lb_pred, false}; + } + + Formula SatSolver::MakeSatIntervalVarWithClauses(PredicateNormalizer& pn, const Variable& var, + const Box::Interval& intv) { + DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVarWithClauses({} ∈ {})", + fmt::streamed(var), fmt::streamed(intv)); + + // DREAL_ASSERT(var.get_type() != Variable::Type::BOOLEAN); + if (var.get_type() == Variable::Type::BOOLEAN) { + if (intv.lb() == 1) return Formula{var}; + if (intv.ub() == 0) return !Formula{var}; + DREAL_ASSERT(intv.lb() == 0 && intv.ub() == 1); + return Formula::True(); + } // else { + + const auto [lb, lb_cache_hit] = MakeSatLbVar(pn, var, intv.lb(), true); + if (!lb_cache_hit) { + DREAL_ASSERT(is_finite(intv.lb())); + label_literal_log("MakeSatIntervalVarWithClauses - LB"); + + const auto [inv_lb, _] = MakeSatUbVar( + pn, var, intv.lb(), false + ); + // ~(lb & inv_lb) & ~(~lb & ~inv_lb) + // ~lb \/ ~inv_lb & lb \/ inv_lb + AddLiteral(!lb); + AddLiteral(!inv_lb); + cadical->add(0); + flush_clause(); + AddLiteral(lb); + AddLiteral(inv_lb); + cadical->add(0); + flush_clause(); + + if (DREAL_LOG_INFO_ENABLED) { + audit_literals(predicate_abstractor_, {!lb, !inv_lb}, {}); + audit_literals(predicate_abstractor_, {lb, inv_lb}, {}); + } + } + + const auto [ub, ub_cache_hit] = MakeSatUbVar(pn, var, intv.ub(), true); + if (!ub_cache_hit) { + DREAL_ASSERT(is_finite(intv.ub())); + label_literal_log("MakeSatIntervalVarWithClauses - UB"); + + const auto [inv_ub, _] = MakeSatLbVar( + pn, var, intv.ub(), false + ); + // ~(ub & inv_ub) & ~(~ub & ~inv_ub) + // ~ub \/ ~inv_ub & ub \/ inv_ub + AddLiteral(!ub); + AddLiteral(!inv_ub); + cadical->add(0); + flush_clause(); + AddLiteral(ub); + AddLiteral(inv_ub); + cadical->add(0); + flush_clause(); + + if (DREAL_LOG_INFO_ENABLED) { + audit_literals(predicate_abstractor_, {!ub, !inv_ub}, {}); + audit_literals(predicate_abstractor_, {ub, inv_ub}, {}); + } + } + + return lb && ub; + } + + bool SatSolver::learning(const int size) { + buffer_i = 0; + expected_clause_size = size; + if (size < BUFFER_SIZE) return true; + else { + label_literal_log("Learning clause which is too big to show. size=" + size); + return false; + } + } + + void SatSolver::learn(const int new_lit) { + if (new_lit != 0) { + DREAL_ASSERT(buffer_i < expected_clause_size); + buffer[buffer_i] = new_lit; + buffer_i++; + return; + } // else { + + DREAL_ASSERT(buffer_i == expected_clause_size); + + label_literal_log("Learned: "); + std::set neg_conjunction; + for (int i = 0; i < expected_clause_size; i++) { + const int lit = buffer[i]; + log_clause(lit); + const bool lit_is_neg = lit < 0; + + const auto sym_var_it = to_sym_var_.find(lit_is_neg ? -lit : +lit); + DREAL_ASSERT(sym_var_it != to_sym_var_.end()); + const auto theory_lit_it = predicate_abstractor_.var_to_formula_map().find(sym_var_it->second); + const Formula theory_lit = + theory_lit_it == predicate_abstractor_.var_to_formula_map().end() + ? Formula{sym_var_it->second} + : theory_lit_it->second; + neg_conjunction.emplace( + !(lit_is_neg ? !theory_lit : theory_lit) + ); + } + flush_clause(); + const Formula sat_clause = !make_conjunction(neg_conjunction); + label_literal_log("i.e. " + sat_clause.to_string()); } - } - - return lb_pred && ub_pred; -} - -bool SatSolver::learning(const int size) { - buffer_i = 0; - expected_clause_size = size; - return size < BUFFER_SIZE; -} - -void SatSolver::learn(const int new_lit) { - if (new_lit != 0) { - DREAL_ASSERT(buffer_i < expected_clause_size); - buffer[buffer_i] = new_lit; - buffer_i++; - return; - } // else { - - DREAL_ASSERT(buffer_i == expected_clause_size); - - set neg_conjunction; - for (int i = 0; i < expected_clause_size; i++) { - const int lit = buffer[i]; - const bool lit_is_neg = lit < 0; - - const auto sym_var_it = to_sym_var_.find(lit_is_neg ? -lit : +lit); - DREAL_ASSERT(sym_var_it != to_sym_var_.end()); - const auto theory_lit_it = predicate_abstractor_.var_to_formula_map().find(sym_var_it->second); - const Formula theory_lit = - theory_lit_it == predicate_abstractor_.var_to_formula_map().end() - ? Formula{sym_var_it->second} - : theory_lit_it->second; - neg_conjunction.emplace( - !(lit_is_neg ? !theory_lit : theory_lit) - ); - } - const Formula sat_clause = !make_conjunction(neg_conjunction); - std::cout << "LEARNED: " << sat_clause << std::endl; -} - -} // namespace dreal +} // namespace dreal diff --git a/test/dreal/solver/test/sat_solver_inteveral_test.cc b/test/dreal/solver/test/sat_solver_inteveral_test.cc index 38c2f8ebd..ffb93c924 100644 --- a/test/dreal/solver/test/sat_solver_inteveral_test.cc +++ b/test/dreal/solver/test/sat_solver_inteveral_test.cc @@ -39,54 +39,54 @@ namespace dreal }; TEST_F(SatSolverIntervalTest, Implication7) { - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-3, +4})); - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-4, +3})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-3, +4})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-4, +3})); EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_TRUE(s.CheckSat()); } TEST_F(SatSolverIntervalTest, Implication6) { - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-2, +4})); - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-4, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +4})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-4, +2})); EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_FALSE(s.CheckSat()); } TEST_F(SatSolverIntervalTest, Implication5) { - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {+0, +2})); - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-2, -0})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, -0})); EXPECT_TRUE(s.CheckSat()); // todo: is this true?? (incl. vs. excl. 0) - s.AddFormula(!s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_FALSE(s.CheckSat()); } TEST_F(SatSolverIntervalTest, Implication4) { - s.AddFormula(s.MakeSatIntervalVar(pn, y_, {+0, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, y_, {+0, +2})); EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_TRUE(s.CheckSat()); } TEST_F(SatSolverIntervalTest, Implication3) { - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVar(pn, x_, {+0, +2})); + s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); EXPECT_TRUE(s.CheckSat()); } TEST_F(SatSolverIntervalTest, Implication2) { - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {+0, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); EXPECT_TRUE(s.CheckSat()); - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_TRUE(s.CheckSat()); } TEST_F(SatSolverIntervalTest, Implication1) { - s.AddFormula(s.MakeSatIntervalVar(pn, x_, {+0, +2})); + s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVar(pn, x_, {-2, +2})); + s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); EXPECT_FALSE(s.CheckSat()); } } // namespace From 645d62786e6612dae4a50ff0a86ed6be4e6a320e Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 00:57:35 -0700 Subject: [PATCH 38/79] Add rounding guards to prefix_printer.cc. --- src/dreal/symbolic/prefix_printer.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/dreal/symbolic/prefix_printer.cc b/src/dreal/symbolic/prefix_printer.cc index 165508240..56b7f4952 100644 --- a/src/dreal/symbolic/prefix_printer.cc +++ b/src/dreal/symbolic/prefix_printer.cc @@ -18,6 +18,7 @@ #include #include #include +#include using std::ostream; using std::ostringstream; @@ -28,6 +29,7 @@ namespace dreal { namespace { ostream& print_constant(ostream& os, double c) { + RoundingModeGuard g(FE_TONEAREST); if (c >= 0) { return os << c; } else { @@ -63,6 +65,7 @@ ostream& PrefixPrinter::VisitConstant(const Expression& e) { } ostream& PrefixPrinter::VisitRealConstant(const Expression& e) { + RoundingModeGuard g(FE_TONEAREST); const double mid{get_lb_of_real_constant(e) / 2.0 + get_ub_of_real_constant(e) / 2.0}; return print_constant(os_, mid); From a3fed52d81f7b09dfbda465169dd5137ec2d402b Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 01:53:25 -0700 Subject: [PATCH 39/79] Add SAT logging to auditor.cc. --- src/dreal/solver/auditor.cc | 55 +++++++- src/dreal/solver/auditor.h | 11 +- src/dreal/solver/sat_solver.cc | 5 +- src/dreal/solver/sat_solver_interval_logic.cc | 123 ++++++++---------- 4 files changed, 119 insertions(+), 75 deletions(-) diff --git a/src/dreal/solver/auditor.cc b/src/dreal/solver/auditor.cc index 7a4739aa9..4a67c5f7c 100644 --- a/src/dreal/solver/auditor.cc +++ b/src/dreal/solver/auditor.cc @@ -21,7 +21,60 @@ namespace dreal { - void audit(const Formula& formula, const std::optional& box) { + std::ofstream literal_log("/tmp/dreal_audit_sat_literal_log.txt"); + std::set literal_log_clause; + + void sat_log_label_clause(const std::string& s) { + if (!SAT_AUDIT_ENABLED) return; + literal_log << s << std::endl; + } + + void sat_log_literal(const int lit, const std::optional& def) { + if (!SAT_AUDIT_ENABLED) return; + DREAL_ASSERT(lit != 0); + + static std::set seen_literals; + if (def && !seen_literals.count(*def)) { + literal_log << "def:\t" << ::abs(lit) << " := " << *def << std::endl; + seen_literals.emplace(*def); + } + + literal_log_clause.insert(lit); + } + + void sat_log_literal0() { + if (!SAT_AUDIT_ENABLED) return; + for (int v : literal_log_clause) literal_log << v << ' '; + literal_log << '0' << std::endl; + literal_log_clause.clear(); + } + + void theory_audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box) { + // the operands passed here are expensive to produce, so really shouldn't be called unnecessarily. + DREAL_ASSERT(THEORY_AUDIT_ENABLED); + + for (auto& l : lits) { + if (is_variable(l)) { + // f = b + const auto iter = pa.var_to_formula_map().find(get_variable(l)); + if (iter != pa.var_to_formula_map().end()) l = iter->second; + // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` + } + else { + // f = ¬b + DREAL_ASSERT(is_negation(l) && is_variable(get_operand(l))); + const auto iter = pa.var_to_formula_map().find(get_variable(get_operand(l))); + if (iter != pa.var_to_formula_map().end()) l = !iter->second; + // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` + } + } + theory_audit_formula(make_disjunction(lits), box); + } + + void theory_audit_formula(const Formula& formula, const std::optional& box) { + // the operands passed here are expensive to produce, so really shouldn't be called unnecessarily. + DREAL_ASSERT(THEORY_AUDIT_ENABLED); + const auto& vs = formula.GetFreeVariables(); std::string lemma_comment; diff --git a/src/dreal/solver/auditor.h b/src/dreal/solver/auditor.h index 48db50642..e0c1fc946 100644 --- a/src/dreal/solver/auditor.h +++ b/src/dreal/solver/auditor.h @@ -6,10 +6,19 @@ #define AUDITOR_H #include +#include namespace dreal { - void audit(const Formula& formula, const std::optional& box); +#define THEORY_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED +#define SAT_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED + + void sat_log_label_clause(const std::string& label); + void sat_log_literal(int lit, const std::optional& def = {}); + void sat_log_literal0(); + + void theory_audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box); + void theory_audit_formula(const Formula& formula, const std::optional& box); } #endif //AUDITOR_H diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 661f6f6a9..3480e029a 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -85,6 +85,7 @@ void SatSolver::AddClause(const Formula& f) { AddLiteral(f); } cadical->add(0); + sat_log_literal0(); } namespace { @@ -113,7 +114,7 @@ class SatSolverStat : public Stat { optional SatSolver::CheckSat() { static SatSolverStat stat{DREAL_LOG_INFO_ENABLED}; - DREAL_LOG_DEBUG("SatSolver::CheckSat(#vars = {}, #clauses = {})", + DREAL_LOG_TRACE("SatSolver::CheckSat(#vars = {}, #clauses = {})", cadical->vars(), cadical->irredundant()); stat.num_check_sat_++; @@ -204,6 +205,7 @@ void SatSolver::AddLiteral(const Formula& f) { DREAL_ASSERT(var.get_type() == Variable::Type::BOOLEAN); // Add l = b cadical->add(to_sat_var_[var.get_id()]); + sat_log_literal(to_sat_var_[var.get_id()], var); } else { // f = ¬b DREAL_ASSERT(is_negation(f) && is_variable(get_operand(f))); @@ -211,6 +213,7 @@ void SatSolver::AddLiteral(const Formula& f) { DREAL_ASSERT(var.get_type() == Variable::Type::BOOLEAN); // Add l = ¬b cadical->add(-to_sat_var_[var.get_id()]); + sat_log_literal(-to_sat_var_[var.get_id()], var); } } diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 256c0a9cc..a37ac0204 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -11,43 +11,20 @@ namespace dreal { - void audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, - const std::optional& box) { - for (auto& l : lits) { - if (is_variable(l)) { - // f = b - const auto& var = get_variable(l); - const auto iter = pa.var_to_formula_map().find(get_variable(l)); - if (iter != pa.var_to_formula_map().end()) l = iter->second; - // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` - } - else { - // f = ¬b - DREAL_ASSERT(is_negation(l) && is_variable(get_operand(l))); - const auto iter = pa.var_to_formula_map().find(get_variable(get_operand(l))); - if (iter != pa.var_to_formula_map().end()) l = !iter->second; - // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` - } - } - audit(make_disjunction(lits), box); - } - void SatSolver::AddLearnedClauseUnboxed( const std::vector& conflicting_conjunction ) { - label_literal_log("AddLearnedClauseUnboxed"); + sat_log_label_clause("SatSolver::AddLearnedClauseUnboxed"); for (const Formula& f : conflicting_conjunction) { AddLiteral(!predicate_abstractor_.Convert(f)); } cadical->add(0); - flush_clause(); + sat_log_literal0(); - if (DREAL_LOG_INFO_ENABLED) { + if (THEORY_AUDIT_ENABLED) { std::vector a; - for (const Formula& f : conflicting_conjunction) { - a.emplace_back(!predicate_abstractor_.Convert(f)); - } - audit_literals(predicate_abstractor_, a, {}); + for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); + theory_audit_literals(predicate_abstractor_, a, {}); } } @@ -65,7 +42,7 @@ namespace dreal PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& unfitted_box ) { - label_literal_log("AddLearnedClause"); + sat_log_label_clause("SatSolver::AddLearnedClause - Boxes"); for (const auto& lit : conflicting_conjunction) { if (lit.GetFreeVariables().size() != 1 || !is_relational(lit)) continue; const Variable& var = *lit.GetFreeVariables().begin(); @@ -76,7 +53,7 @@ namespace dreal const auto r = FilterAssertion(lit, &fitted_box); if (r.filtered) { - // automatically builds implications + // MakeSatIntervalVarWithClauses automatically builds implications // if !r.change: // unfitted => lit // if r.change: @@ -99,9 +76,9 @@ namespace dreal FlattenIntervalClause(unfitted, [&](const auto& il) { AddLiteral(!il); }); FlattenIntervalClause(fitted, [&](const auto& il) { AddLiteral(il); }); cadical->add(0); - flush_clause(); + sat_log_literal0(); - if (DREAL_LOG_INFO_ENABLED) { + if (THEORY_AUDIT_ENABLED) { std::vector a; a.emplace_back(!predicate_abstractor_.Convert(lit)); FlattenIntervalClause(unfitted, [&](const auto& il) { a.emplace_back(!il); }); @@ -129,37 +106,32 @@ namespace dreal FlattenIntervalClause(condition, [&](const auto& l) { lhs_implies.emplace_back(!l); }); } + sat_log_label_clause("SatSolver::AddLearnedClause - Predicated Clause"); for (const auto& lit : lhs_implies) AddLiteral(lit); // ==> for (const Formula& f : conflicting_conjunction) AddLiteral(!predicate_abstractor_.Convert(f)); cadical->add(0); - flush_clause(); - - if (DREAL_LOG_INFO_ENABLED) { - audit(!make_conjunction(conflicting_conjunction), unfitted_box); + sat_log_literal0(); + if (THEORY_AUDIT_ENABLED) { + theory_audit_formula(!make_conjunction(conflicting_conjunction), unfitted_box); std::vector a; for (const auto& lit : lhs_implies) a.emplace_back(lit); // ==> for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); - audit_literals(predicate_abstractor_, a, {}); + theory_audit_literals(predicate_abstractor_, a, {}); } } void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { - label_literal_log("AddBox"); + sat_log_label_clause("SatSolver::AddBox"); for (const auto& v : base_box.variables()) { const auto condition = MakeSatIntervalVarWithClauses(pn, v, base_box[v]); - if (is_true(condition)) continue; - for ( - const auto& lit : - is_conjunction(condition) ? get_operands(condition) : set{condition} - ) { - // todo: audit? currently can't because it is already predicate_abstractor-ed - AddLiteral(lit); + FlattenIntervalClause(condition, [&](const auto& f) { + AddLiteral(f); cadical->add(0); - flush_clause(); - } + sat_log_literal0(); + }); } } @@ -168,7 +140,7 @@ namespace dreal const std::vector& base_conflict, const Box& base_box, const std::chrono::duration timeout ) { - label_literal_log("AddLearnedClausePattern"); + sat_log_label_clause("SatSolver::AddLearnedClausePattern"); // the pattern matching is kinda best-effort now. // it breaks down when one clause pattern matches into 1000s of permutations of itself // just make the best effort, and at the very minimum make sure the original at least gets inserted @@ -185,9 +157,12 @@ namespace dreal for (const auto& [conflict_clause, subs] : all_related_conflicts) { const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); - if (DREAL_LOG_INFO_ENABLED) { // todo: better gate. + if (THEORY_AUDIT_ENABLED) { std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); - audit(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), conflict_box); + theory_audit_formula( + !make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), + conflict_box + ); } AddLearnedClause(pn, conflict_clause, conflict_box); @@ -295,7 +270,7 @@ namespace dreal const auto [lb, lb_cache_hit] = MakeSatLbVar(pn, var, intv.lb(), true); if (!lb_cache_hit) { DREAL_ASSERT(is_finite(intv.lb())); - label_literal_log("MakeSatIntervalVarWithClauses - LB"); + sat_log_label_clause("SatSolver::MakeSatIntervalVarWithClauses - LB"); const auto [inv_lb, _] = MakeSatUbVar( pn, var, intv.lb(), false @@ -305,22 +280,22 @@ namespace dreal AddLiteral(!lb); AddLiteral(!inv_lb); cadical->add(0); - flush_clause(); + sat_log_literal0(); AddLiteral(lb); AddLiteral(inv_lb); cadical->add(0); - flush_clause(); + sat_log_literal0(); - if (DREAL_LOG_INFO_ENABLED) { - audit_literals(predicate_abstractor_, {!lb, !inv_lb}, {}); - audit_literals(predicate_abstractor_, {lb, inv_lb}, {}); + if (THEORY_AUDIT_ENABLED) { + theory_audit_literals(predicate_abstractor_, {!lb, !inv_lb}, {}); + theory_audit_literals(predicate_abstractor_, {lb, inv_lb}, {}); } } const auto [ub, ub_cache_hit] = MakeSatUbVar(pn, var, intv.ub(), true); if (!ub_cache_hit) { DREAL_ASSERT(is_finite(intv.ub())); - label_literal_log("MakeSatIntervalVarWithClauses - UB"); + sat_log_label_clause("SatSolver::MakeSatIntervalVarWithClauses - UB"); const auto [inv_ub, _] = MakeSatLbVar( pn, var, intv.ub(), false @@ -330,15 +305,15 @@ namespace dreal AddLiteral(!ub); AddLiteral(!inv_ub); cadical->add(0); - flush_clause(); + sat_log_literal0(); AddLiteral(ub); AddLiteral(inv_ub); cadical->add(0); - flush_clause(); + sat_log_literal0(); - if (DREAL_LOG_INFO_ENABLED) { - audit_literals(predicate_abstractor_, {!ub, !inv_ub}, {}); - audit_literals(predicate_abstractor_, {ub, inv_ub}, {}); + if (THEORY_AUDIT_ENABLED) { + theory_audit_literals(predicate_abstractor_, {!ub, !inv_ub}, {}); + theory_audit_literals(predicate_abstractor_, {ub, inv_ub}, {}); } } @@ -348,11 +323,9 @@ namespace dreal bool SatSolver::learning(const int size) { buffer_i = 0; expected_clause_size = size; - if (size < BUFFER_SIZE) return true; - else { - label_literal_log("Learning clause which is too big to show. size=" + size); - return false; - } + if (size <= LOG_INFO_SIZE) return true; + if (SAT_AUDIT_ENABLED && size < MAX_BUFFER_SIZE) return true; + return false; } void SatSolver::learn(const int new_lit) { @@ -365,11 +338,11 @@ namespace dreal DREAL_ASSERT(buffer_i == expected_clause_size); - label_literal_log("Learned: "); + sat_log_label_clause("SatSolver::learn"); std::set neg_conjunction; for (int i = 0; i < expected_clause_size; i++) { const int lit = buffer[i]; - log_clause(lit); + sat_log_literal(lit); const bool lit_is_neg = lit < 0; const auto sym_var_it = to_sym_var_.find(lit_is_neg ? -lit : +lit); @@ -383,8 +356,14 @@ namespace dreal !(lit_is_neg ? !theory_lit : theory_lit) ); } - flush_clause(); - const Formula sat_clause = !make_conjunction(neg_conjunction); - label_literal_log("i.e. " + sat_clause.to_string()); + sat_log_literal0(); + if (SAT_AUDIT_ENABLED) { + const Formula sat_clause = !make_conjunction(neg_conjunction); + sat_log_label_clause("i.e. " + sat_clause.to_string()); + } + if (expected_clause_size <= LOG_INFO_SIZE) { + const Formula sat_clause = !make_conjunction(neg_conjunction); + DREAL_LOG_INFO("SAT Solver Learned: {}", sat_clause); + } } } // namespace dreal From a2698087326e161adbba14b0bfdae3f67156a286 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 01:54:20 -0700 Subject: [PATCH 40/79] Tune CaDiCaL options - increase vivification and subsumption aggressiveness. --- src/dreal/solver/sat_solver.cc | 36 +++++++++++++++++++++------------- 1 file changed, 22 insertions(+), 14 deletions(-) diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 3480e029a..58231d368 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -35,23 +35,31 @@ using std::vector; SatSolver::SatSolver(const Config& config) : cadical(new CaDiCaL::Solver) { // SatSolver::CheckSat(). + bool success = false; if (config.random_seed() != 0) { - cadical->set("seed", config.random_seed()); + success = cadical->set("seed", config.random_seed()); DREAL_ASSERT(success); DREAL_LOG_DEBUG("SatSolver::Set Random Seed {}", config.random_seed()); } - // this actually doesn't work lol. - // cadical->set("phase", static_cast(config.sat_default_phase())); - // DREAL_LOG_DEBUG("SatSolver::Set Default Phase {}", - // config.sat_default_phase()); - - // todo: look into this? want to absolutely minimize calls to theory solver. - // eliminate as many variables as possible. ? - cadical->optimize(9); - cadical->set("condition", 1); // "globally blocked clause elim" - cadical->set("cover", 1); // "covered clause elimination" - cadical->set("block", 1); // "blocked clause elimination" - - cadical->connect_learner(this); + + // todo: remove dReal phase flag... + + success = cadical->set("vivify", 1); DREAL_ASSERT(success); + success = cadical->set("vivifyonce", 2); DREAL_ASSERT(success); + success = cadical->set("vivifymineff", 1e3); DREAL_ASSERT(success); + success = cadical->set("vivifymaxeff", 2e9); DREAL_ASSERT(success); + success = cadical->set("vivifyreleff", 20); DREAL_ASSERT(success); + success = cadical->set("eagersubsume", 1); DREAL_ASSERT(success); + success = cadical->set("subsume", 1); DREAL_ASSERT(success); + success = cadical->set("subsumeclslim", 1e3); DREAL_ASSERT(success); + success = cadical->set("subsumeint", 1e3); DREAL_ASSERT(success); + cadical->options(); + + if (DREAL_LOG_INFO_ENABLED || SAT_AUDIT_ENABLED) cadical->connect_learner(this); + + all_incl_lb_predicates.max_load_factor(0.25); + all_excl_lb_predicates.max_load_factor(0.25); + all_incl_ub_predicates.max_load_factor(0.25); + all_excl_ub_predicates.max_load_factor(0.25); } SatSolver::~SatSolver() { delete cadical; } From e5a077d005c250b5b5691e973fa8816c4b48feda Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 01:55:00 -0700 Subject: [PATCH 41/79] Increase load factor of heavily queried hash maps in predicate_abstractor.cc. --- src/dreal/util/predicate_abstractor.cc | 2 ++ src/dreal/util/predicate_abstractor.h | 6 ++++++ 2 files changed, 8 insertions(+) diff --git a/src/dreal/util/predicate_abstractor.cc b/src/dreal/util/predicate_abstractor.cc index 990010409..b55287517 100644 --- a/src/dreal/util/predicate_abstractor.cc +++ b/src/dreal/util/predicate_abstractor.cc @@ -82,6 +82,8 @@ Formula PredicateAbstractor::Convert(const vector& formulas) { } Formula PredicateAbstractor::Visit(const Formula& f) { + DREAL_ASSERT(!(is_variable(f) && var_to_formula_map_.count(get_variable(f)))); + // First check if we processed this formula before. const auto it = formula_to_var_map_.find(f); if (it == formula_to_var_map_.cend()) { diff --git a/src/dreal/util/predicate_abstractor.h b/src/dreal/util/predicate_abstractor.h index 9ba64195c..526d2b2a0 100644 --- a/src/dreal/util/predicate_abstractor.h +++ b/src/dreal/util/predicate_abstractor.h @@ -26,6 +26,12 @@ namespace dreal { class PredicateAbstractor { public: + + PredicateAbstractor() { + formula_to_var_map_.max_load_factor(0.25); + var_to_formula_map_.max_load_factor(0.25); + } + /// Converts a first-order logic formula @p f into a Boolean formula /// by predicate abstraction. For example, a formula `(x > 0) ∧ (y < /// 0)` will be converted into `b₁ ∧ b₂` while `b₁` corresponds with From 1e6e0ff1b807b19b4ec8af0fee172c7fdfcc8683 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 02:54:07 -0700 Subject: [PATCH 42/79] Create concept of underconstrained models. --- src/dreal/solver/context_impl.cc | 60 +++-- src/dreal/solver/context_impl.h | 2 + src/dreal/solver/sat_solver.cc | 80 ++++++- src/dreal/solver/sat_solver.h | 13 +- .../test/sat_solver_model_minimizer_test.cc | 205 ++++++++++++++++++ 5 files changed, 327 insertions(+), 33 deletions(-) create mode 100644 test/dreal/solver/test/sat_solver_model_minimizer_test.cc diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index dc1a44442..b8d732465 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -135,7 +135,6 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { //////////////////////////////////////////////////////////////////////////////// - static constexpr bool GENERATE_CSV = false; std::ofstream myfile; if (GENERATE_CSV) { std::ostringstream s; @@ -195,7 +194,8 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, } //////////////////////////////////////////////////////////////////////////////// - sat_solver->AddBox(pn_, box); // SKIPS Boolean Variables ✔ + sat_solver->AddBox(pn_, box); + //////////////////////////////////////////////////////////////////////////////// for (const auto & variable : box.variables()) { if (variable.get_type() == Variable::Type::CONTINUOUS) kunal_paper_data.box_continuous_count++; @@ -208,8 +208,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, DREAL_LOG_INFO("Initialized. Beginning SAT <=> Theory cycles."); DREAL_LOG_INFO( - "{} continuous variables. {} integer variables. {} boolean variables.", - kunal_paper_data.box_continuous_count, kunal_paper_data.box_integer_count, kunal_paper_data.box_boolean_count + "{} continuous variables. {} integer variables. {} boolean variables. Fully Constrained: {}", + kunal_paper_data.box_continuous_count, kunal_paper_data.box_integer_count, kunal_paper_data.box_boolean_count, + recent_under_constrained_deltasat > 0 ); while (true) { // Note that 'DREAL_CHECK_INTERRUPT' is only defined in setup.py, @@ -220,11 +221,14 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, throw std::runtime_error("KeyboardInterrupt(SIGINT) Detected."); } #endif + const bool request_fully_constrained = recent_under_constrained_deltasat > 0; + const auto optional_model_and_fully_constrained = sat_solver->CheckSat(request_fully_constrained); + if (optional_model_and_fully_constrained) { + const auto &[optional_model, is_full_constrained] = *optional_model_and_fully_constrained; + if (request_fully_constrained) DREAL_ASSERT(is_full_constrained); - const auto optional_model = sat_solver->CheckSat(); - if (optional_model) { - const vector>& boolean_model{optional_model->first}; - const vector>& theory_model{optional_model->second}; + const vector>& boolean_model{optional_model.first}; + const vector>& theory_model{optional_model.second}; for (const auto& [sat_var, assignment] : boolean_model) box[sat_var] = assignment ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 @@ -263,35 +267,44 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.theory_checksat_ms = tscs_elapsed.count(); //////////////////////////////////////////////////////////////////////////////// - if (tscs_result) { + if (tscs_result && !is_full_constrained) { // SAT from TheorySolver. - DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Theory Check = delta-SAT"); - Box model{theory_solver_.GetModel()}; - return model; + // the next 3 unsats should be fully constrained before we can try under constrained stuff again. + // or, we get a fully constrained deltasat, in which case we are done :) + recent_under_constrained_deltasat = 3; + DREAL_LOG_WARN("ContextImpl::CheckSatCore() - Underconstrained Theory Check = delta-SAT."); + return CheckSatCore(stack, std::move(box), sat_solver); + } else if (tscs_result && is_full_constrained) { + DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Fully Constrained Theory Check = delta-SAT"); + return theory_solver_.GetModel(); } else { // UNSAT from TheorySolver. + if (recent_under_constrained_deltasat > 0) recent_under_constrained_deltasat--; + DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Theory Check = UNSAT"); - const set& explanation{theory_solver_.GetExplanation()}; + std::vector explanation( + theory_solver_.GetExplanation().begin(), + theory_solver_.GetExplanation().end() + ); DREAL_LOG_DEBUG( "ContextImpl::CheckSatCore() - size of explanation = {} - stack size = {}", explanation.size(), stack.get_vector().size()); // ordering the literals like this makes pattern matching fast. // todo: abstract this away better. should not happen at the top-level like it is now. - std::vector explanation_vec(explanation.begin(), explanation.end()); - std::sort(explanation_vec.begin(), explanation_vec.end(), [](const Formula &a, const Formula &b) { + std::sort(explanation.begin(), explanation.end(), [](const Formula &a, const Formula &b) { return a.GetFreeVariables().size() > b.GetFreeVariables().size(); // descending }); //////////////////////////////////////////////////////////////////////////////// - kunal_paper_data.lemma_size = explanation_vec.size(); + kunal_paper_data.lemma_size = explanation.size(); const auto ranking_start2 = std::chrono::high_resolution_clock::now(); // kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation.first)); // doing individual literals doesn't cost extra because they cache hit after running the entire conjunction - kunal_paper_data.biggest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[0]); - kunal_paper_data.middle_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size() / 2]); - kunal_paper_data.smallest_literal_stats = pn_.heuristic.collect_statistics(explanation_vec[explanation_vec.size()-1]); + kunal_paper_data.biggest_literal_stats = pn_.heuristic.collect_statistics(explanation[0]); + kunal_paper_data.middle_literal_stats = pn_.heuristic.collect_statistics(explanation[explanation.size() / 2]); + kunal_paper_data.smallest_literal_stats = pn_.heuristic.collect_statistics(explanation[explanation.size()-1]); const float predicted_is_worth_it = PatternMatchingHeuristic::calculate(kunal_paper_data); const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; @@ -300,10 +313,13 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, // if (false) { const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( - pn_, explanation_vec, box, - // std::chrono::duration_cast(100 * tscs_elapsed) - std::chrono::seconds(10) // based on information from WORTH_IT_regression_4.ipynb + pn_, explanation, box, + std::min( // based on information from WORTH_IT_regression_4.ipynb + std::chrono::duration_cast(100 * tscs_elapsed), + std::chrono::duration_cast(std::chrono::milliseconds(200)) + ) ); + sat_solver->AddLearnedClauseUnboxed(explanation); // just to be sure, sound because this is unmatched, straight from theory solver. const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index 89176c078..85058a587 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -98,6 +98,8 @@ class Context::Impl { std::unordered_set model_variables_; TheorySolver theory_solver_; + int recent_under_constrained_deltasat = 0; + // Stores the result of the latest checksat. // Note that if the checksat result was UNSAT, this box holds an empty box. Box model_; diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 58231d368..be5b11345 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -120,7 +120,7 @@ class SatSolverStat : public Stat { }; } // namespace -optional SatSolver::CheckSat() { +optional> SatSolver::CheckSat(const bool request_fully_constrained) { static SatSolverStat stat{DREAL_LOG_INFO_ENABLED}; DREAL_LOG_TRACE("SatSolver::CheckSat(#vars = {}, #clauses = {})", cadical->vars(), @@ -135,13 +135,77 @@ optional SatSolver::CheckSat() { Model model; if (ret == CaDiCaL::SATISFIABLE) { // SAT Case. - const auto& var_to_formula_map = predicate_abstractor_.var_to_formula_map(); - // from CaDiCaL documentation: - // try to avoid mixing 'flip' and 'val' (for efficiency only). + + bool model_is_fully_constrained = true; std::vector model_is(cadical->vars()+1); - for (int i = 1; i <= cadical->vars(); ++i) model_is[i] = cadical->val(i) > 0 ? +1 : -1; - for (int i = 1; i <= cadical->vars(); ++i) if(cadical->flip(i)) model_is[i] = 0; // todo: use IPASIR-UP, see cvc5 paper. - // for (int i = 1; i <= cadical->vars(); ++i) if(model_is[i] == 0) cadical->flip(i); // restore default state. + if (request_fully_constrained) { + for (int i = 1; i <= cadical->vars(); ++i) { + model_is[i] = cadical->val(i) > 0 ? +1 : -1; + } + } else /*(request_fully_constrained)*/ { + // MASK to prevent XOR issue... + // e.g. if we have 1 2 0, with model -1 2 0 + // then flipping -1 to +1, subsequently makes 2 flippable to -2 + // however, this DOES NOT MEAN they both can be set to 0 / don't care. + // need to mask away variables which were not flippable to begin with. + for (int i = 1; i <= cadical->vars(); ++i) { + model_is[i] = cadical->flippable(i); // mask + } + for (int i = 1; i <= cadical->vars(); ++i) { + // try to zero-out non-decision variables first, + // make the theory solver "focus" on decision variables to promote backtracking. + if (cadical->is_decision(i)) continue; + model_is[i] = model_is[i] && cadical->flip(i); + } + for (int i = 1; i <= cadical->vars(); ++i) { + if (!cadical->is_decision(i)) continue; + model_is[i] = model_is[i] && cadical->flip(i); + } + + // UPDATE - don't bother, this folds into the "combinatorial" issue below... + // I cannot trigger this in a unit test but it happens + // sporadically on large problems... + // a future flip "locks" a previous assignment, making it no longer flippable. + // for (int i = 1; i <= cadical->vars(); ++i) { + // model_is[i] = model_is[i] && cadical->flippable(i); + // } + + for (int i = 1; i <= cadical->vars(); ++i) { + if (model_is[i] /* was flippable and then flipped */) { + model_is_fully_constrained = false; + model_is[i] = 0; + } else { + const int val = cadical->val(i) > 0 ? +1 : -1; + model_is[i] = val; + } + } + + // todo: + // so it turns out we can basically never actually calculate what is flippable and what is not. + // unless we were to go through the full O(2^N) combinatorial set of flips-and-not-flips + // the best we can do is give an underconstrained model... + // and then scrutinize any SAT results with the full model. + // for (int i = 1; i <= cadical->vars(); ++i) { + // if (partial_model[i] == 0) { + // cadical->assume(+i); + // for (int j = 1; j <= cadical->vars(); ++j) if (partial_model[j] != 0) cadical->assume(j * partial_model[j]); + // DREAL_ASSERT (cadical->solve() == CaDiCaL::SATISFIABLE); + // cadical->assume(-i); + // for (int j = 1; j <= cadical->vars(); ++j) if (partial_model[j] != 0) cadical->assume(j * partial_model[j]); + // DREAL_ASSERT (cadical->solve() == CaDiCaL::SATISFIABLE); + // } + // } + } + + if (model_is_fully_constrained) { + sat_log_label_clause("SatSolver::CheckSat - Fully Constrained"); + } else { + sat_log_label_clause("SatSolver::CheckSat - Partially Constrained"); + } + for (int i = 1; i <= cadical->vars(); ++i) if (model_is[i] != 0) sat_log_literal(i * model_is[i]); + sat_log_literal0(); + + const auto& var_to_formula_map = predicate_abstractor_.var_to_formula_map(); for (int i = 1; i <= cadical->vars(); ++i) { const auto model_i = model_is[i]; if (model_i == 0) { @@ -174,7 +238,7 @@ optional SatSolver::CheckSat() { } } DREAL_LOG_DEBUG("SatSolver::CheckSat() Found a model."); - return model; + return {{model, model_is_fully_constrained}}; } else if (ret == CaDiCaL::UNSATISFIABLE) { DREAL_LOG_DEBUG("SatSolver::CheckSat() No solution."); // UNSAT Case. diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index c049f16f2..52da38e7a 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -68,7 +68,10 @@ class SatSolver : public CaDiCaL::Learner { /// Given a @p formulas = {f₁, ..., fₙ}, adds a clause (¬f₁ ∨ ... ∨ ¬ fₙ) to /// the solver. + void AddLearnedClauseUnboxed(const std::vector& conflicting_conjunction); + void AddLearnedClause(PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& box); + PatternMatchingTrie::matching_stats_t AddLearnedClausePattern( PredicateNormalizer& pn, const std::vector& base_conflict, @@ -83,7 +86,10 @@ class SatSolver : public CaDiCaL::Learner { /// /// @returns a witness, satisfying model if the problem is satisfiable. /// @returns nullopt if UNSAT. - optional CheckSat(); + optional> CheckSat( + // false because I guess that used to be the default. + bool request_fully_constrained = false + ); // TODO(soonho): Push/Pop cnfizer and predicate_abstractor? void Pop(); @@ -135,8 +141,9 @@ class SatSolver : public CaDiCaL::Learner { // learner stuff. private: - static constexpr size_t BUFFER_SIZE = 3; - int buffer[BUFFER_SIZE] = {0}; + static constexpr size_t LOG_INFO_SIZE = 2; + static constexpr size_t MAX_BUFFER_SIZE = 8; + int buffer[MAX_BUFFER_SIZE] = {0}; int buffer_i = 0; int expected_clause_size = 0; diff --git a/test/dreal/solver/test/sat_solver_model_minimizer_test.cc b/test/dreal/solver/test/sat_solver_model_minimizer_test.cc new file mode 100644 index 000000000..faf10312a --- /dev/null +++ b/test/dreal/solver/test/sat_solver_model_minimizer_test.cc @@ -0,0 +1,205 @@ +/* + Copyright 2017 Toyota Research Institute + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +#include + +#include + +#include "dreal/solver/config.h" +#include "dreal/symbolic/symbolic.h" + +namespace dreal +{ + namespace + { + class SatSolverModelMinimizerTest : public ::testing::Test + { + protected: + const Variable b1{"b1", Variable::Type::BOOLEAN}; + const Variable b2{"b2", Variable::Type::BOOLEAN}; + const Variable b3{"b3", Variable::Type::BOOLEAN}; + const Variable b4{"b4", Variable::Type::BOOLEAN}; + const Variable b5{"b5", Variable::Type::BOOLEAN}; + const Variable b6{"b6", Variable::Type::BOOLEAN}; + const Variable b7{"b7", Variable::Type::BOOLEAN}; + const Variable b8{"b8", Variable::Type::BOOLEAN}; + }; + + Formula xor_of(const Formula& a, const Formula& b) { + return (a || b) && (!a || !b); + } + Formula xor_of(const Variable& a, const Variable& b) { + return xor_of(Formula{a}, Formula{b}); + } + + + TEST_F(SatSolverModelMinimizerTest, Xor1) { + SatSolver cdcl{Config()}; + + cdcl.AddFormula(xor_of(b1, b2)); + cdcl.AddFormula(Formula{b1}); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + + EXPECT_EQ(assignments.size(), 2); + EXPECT_TRUE( + assignments[b1] & !assignments[b2] + ); + } + + TEST_F(SatSolverModelMinimizerTest, Xor2) { + SatSolver cdcl{Config()}; + cdcl.AddFormula(xor_of(b1, b2)); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + + EXPECT_EQ(assignments.size(), 2); + EXPECT_TRUE( + assignments[b1] ^ assignments[b2] + ); + } + + TEST_F(SatSolverModelMinimizerTest, Or1) { + SatSolver cdcl{Config()}; + cdcl.AddFormula(b1 || b2); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + + EXPECT_EQ(assignments.size(), 1); + EXPECT_TRUE(assignments.count(b1) ^ assignments.count(b2)); + if (assignments.count(b1)) EXPECT_TRUE(assignments[b1]); + if (assignments.count(b2)) EXPECT_TRUE(assignments[b2]); + } + + TEST_F(SatSolverModelMinimizerTest, Or2) { + SatSolver cdcl{Config()}; + cdcl.AddFormula(b1 || b2); + cdcl.AddFormula(b1 || b2 || b3); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + + EXPECT_EQ(assignments.size(), 1); + EXPECT_TRUE(assignments.count(b1) ^ assignments.count(b2)); + if (assignments.count(b1)) EXPECT_TRUE(assignments[b1]); + if (assignments.count(b2)) EXPECT_TRUE(assignments[b2]); + EXPECT_EQ(assignments.count(b3), 0); + } + + TEST_F(SatSolverModelMinimizerTest, Or3) { + SatSolver cdcl{Config()}; + cdcl.AddFormula(b1 || b2); + cdcl.AddFormula(b1 || !b2); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + + EXPECT_EQ(assignments.size(), 1); + EXPECT_TRUE(assignments.count(b1) == 1); + EXPECT_TRUE(assignments.count(b2) == 0); + EXPECT_TRUE(assignments[b1]); + } + + TEST_F(SatSolverModelMinimizerTest, Or4) { + SatSolver cdcl{Config()}; + cdcl.AddFormula(b1 || b2 || b3 || b4); + cdcl.AddFormula(b5 || b6 || b7 || b8); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + EXPECT_EQ(assignments.size(), 2); + for (const auto & [k,v] : assignments) EXPECT_TRUE(v); + } + + TEST_F(SatSolverModelMinimizerTest, Or5) { + SatSolver cdcl{Config()}; + cdcl.AddFormula(b1 || b2 || b3 || b4); + cdcl.AddFormula(b1 || b6 || b7 || b8); + const auto model = cdcl.CheckSat(); + EXPECT_TRUE(model); + + std::map assignments; + for (const auto& kv : model->first.first) assignments.emplace(kv); + EXPECT_LE(assignments.size(), 2); + } + + // update: gave up on the idea of "perfect" partial models... + // see comments inside `SatSolver::CheckSat()` for details. + + // TEST_F(SatSolverModelMinimizerTest, FlippableMasking) { + // SatSolver cdcl{Config()}; + // // order of variable initialization matters in internal data structures + // cdcl.AddFormula(b1 || !b1); + // cdcl.AddFormula(b2 || !b2); + // + // // mess with private members to try and replicate this + // // happens extremely rarely on larger problems + // cdcl.AddFormula(b1 || b2); + // + // // force it to be a particular model to trigger it. + // cdcl.cadical->assume(-cdcl.to_sat_var_[b1.get_id()]); + // cdcl.cadical->assume(+cdcl.to_sat_var_[b2.get_id()]); + // + // auto model = cdcl.CheckSat(); + // EXPECT_TRUE(model); + // std::map assignments; + // for (const auto& kv : model->first.first) assignments.emplace(kv); + // EXPECT_EQ(assignments.size(), 1); + // EXPECT_TRUE(assignments[b2]); + // } + + // TEST_F(SatSolverModelMinimizerTest, Flippable3rdPass) { + // // cannot replicate :( + // // but it does happen. + // + // SatSolver cdcl{Config()}; + // // order of variable initialization matters in internal data structures + // cdcl.AddFormula(b1 || !b1); + // cdcl.AddFormula(b2 || !b2); + // + // // mess with private members to try and replicate this + // // happens extremely rarely on larger problems + // cdcl.AddFormula(b1 || b2 || b3); + // + // // force it to be a particular model to trigger it. + // cdcl.cadical->assume(+cdcl.to_sat_var_[b1.get_id()]); + // cdcl.cadical->assume(-cdcl.to_sat_var_[b2.get_id()]); + // cdcl.cadical->assume(+cdcl.to_sat_var_[b3.get_id()]); + // + // auto model = cdcl.CheckSat(); + // EXPECT_TRUE(model); + // std::map assignments; + // for (const auto& kv : model->first.first) assignments.emplace(kv); + // EXPECT_EQ(assignments.size(), 1); + // EXPECT_TRUE(assignments[b2]); + // } + + } // namespace +} // namespace dreal From 59f4e2c7138541cf464d392dc6b0822f9b74d3b7 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 02:54:56 -0700 Subject: [PATCH 43/79] Add conjunction unrolling to `Context::Impl::Assert` for more accurate box creation. --- src/dreal/solver/context_impl.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index b8d732465..04d989758 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -112,6 +112,10 @@ void Context::Impl::Assert(const Formula& f) { box().set_empty(); return; } + if (is_conjunction(f)) { // because otherwise FilterAssertion may miss some box updates! + for (const auto& operand : get_operands(f)) Assert(operand); + return; + } if (!FilterAssertion(f, &box()).filtered) { DREAL_LOG_DEBUG("ContextImpl::Assert: {} is added.", f); IfThenElseEliminator ite_eliminator; From a9de323564ccaaa58da28127abdd4e397726a129 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 02:59:24 -0700 Subject: [PATCH 44/79] Add `FMCAD25_MODE_*` macros for easier benchmarking runs. --- src/dreal/solver/context_impl.cc | 53 +++++++++++++------ src/dreal/solver/context_impl.h | 6 +++ src/dreal/solver/sat_solver_interval_logic.cc | 3 -- .../pattern_matching_trie_general.cc | 8 +-- 4 files changed, 46 insertions(+), 24 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 04d989758..eadb91c38 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -138,6 +138,16 @@ void Context::Impl::Assert(const Formula& f) { optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { +#ifdef FMCAD25_MODE_MATCH_ALL + std::cout << "FMCAD25_MODE_MATCH_ALL" << std::endl; +#endif +#ifdef FMCAD25_MODE_MATCH_SOME + std::cout << "FMCAD25_MODE_MATCH_SOME" << std::endl; +#endif +#ifdef FMCAD25_MODE_CONTROL + std::cout << "FMCAD25_MODE_CONTROL" << std::endl; +#endif + //////////////////////////////////////////////////////////////////////////////// std::ofstream myfile; if (GENERATE_CSV) { @@ -313,8 +323,15 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; - if (predicted_is_worth_it >= 0.5) { - // if (false) { +#ifdef FMCAD25_MODE_MATCH_ALL + if (true) { +#endif +#ifdef FMCAD25_MODE_MATCH_SOME + if (predicted_is_worth_it >= 0.5 && explanation.size() < 96) { +#endif +#ifdef FMCAD25_MODE_CONTROL + if (false) { +#endif const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( pn_, explanation, box, @@ -323,37 +340,39 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, std::chrono::duration_cast(std::chrono::milliseconds(200)) ) ); + + // the pattern matching is kinda best-effort now. + // it breaks down when one clause pattern matches into 1000s of permutations of itself + // just make the best effort, and at the very minimum make sure the original at least gets inserted sat_solver->AddLearnedClauseUnboxed(explanation); // just to be sure, sound because this is unmatched, straight from theory solver. + const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; kunal_paper_data.pattern_match_ms = alcp_elapsed.count(); kunal_paper_data.pattern_matching_stats = alcp_result; + std::cerr << "P(is W.I.)=" << std::setprecision(3) << predicted_is_worth_it; + std::cerr << ". Matched " << alcp_result.matches << " size " << explanation.size() << " in " << alcp_elapsed.count(); + std::cerr << " ms. TSCS " << tscs_elapsed.count() << " ms." << std::endl; + // const double bb_lpms = 1 / tscs_elapsed.count(); - // const double pm_lpms = (alcp_result.matches - 0.999) / alcp_elapsed.count(); + // const double pm_lpms = (std::max(alcp_result.matches, 1u) - 0.999) / alcp_elapsed.count(); // const double actual_worth_it = pm_lpms / bb_lpms; // const double actual_log2_worth_it = log2(actual_worth_it); - - std::cerr << "P(is W.I.)=" << predicted_is_worth_it; - std::cerr << ". Matched " << alcp_result.matches << " size " << explanation_vec.size() << " in " << alcp_elapsed.count(); - std::cerr << " ms. TSCS " << tscs_elapsed.count() << " ms." << std::endl; - - // DREAL_LOG_INFO("Predicted P(is W.I.)={}, Measured log2 W.I. ratio = {}", predicted_is_worth_it, actual_log2_worth_it); // const bool overestimated = (actual_log2_worth_it < 1) && (predicted_is_worth_it > 0.5); // const bool valid_over = (actual_log2_worth_it > 1) && (predicted_is_worth_it > 0.5); // const bool valid_under = (actual_log2_worth_it < 1) && (predicted_is_worth_it < 0.5); // const bool underestimated = (actual_log2_worth_it > 1) && (predicted_is_worth_it < 0.5); - // if (overestimated) DREAL_LOG_INFO("OVERESTIMATED. Had high hopes but were disappointed in the end."); - // if (valid_over) DREAL_LOG_INFO("VALID_OVER. It was worth it like we thought."); - // if (valid_under) DREAL_LOG_INFO("VALID_UNDER. We knew to avoid this one."); - // if (underestimated) DREAL_LOG_INFO("UNDERESTIMATED. Sorry we didn't believe in you."); - } else { - std::cerr << "P(is W.I.)=" << predicted_is_worth_it; - std::cerr << ". Adding 1 size " << explanation_vec.size() << " directly. "; + std::cerr << "P(is W.I.)=" << std::setprecision(3) << predicted_is_worth_it; + std::cerr << ". Adding 1 size " << explanation.size() << " directly. "; std::cerr << "TSCS " << tscs_elapsed.count() << " ms." << std::endl; - sat_solver->AddLearnedClause(explanation_vec, box); +#ifdef FMCAD25_MODE_CONTROL + sat_solver->AddLearnedClauseUnboxed(explanation); +#else + sat_solver->AddLearnedClause(pn_, explanation, box); +#endif } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index 85058a587..a0f0d039e 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -29,6 +29,12 @@ namespace dreal { +// #define FMCAD25_MODE_MATCH_ALL +// #define FMCAD25_MODE_MATCH_SOME +#define FMCAD25_MODE_CONTROL + +#define GENERATE_CSV false + // The actual implementation. class Context::Impl { public: diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index a37ac0204..892ad1169 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -141,9 +141,6 @@ namespace dreal const std::chrono::duration timeout ) { sat_log_label_clause("SatSolver::AddLearnedClausePattern"); - // the pattern matching is kinda best-effort now. - // it breaks down when one clause pattern matches into 1000s of permutations of itself - // just make the best effort, and at the very minimum make sure the original at least gets inserted const auto [ all_related_conflicts, diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index 6f81b3801..0a3341f7c 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -94,10 +94,10 @@ namespace dreal recMatchForm(*ibegin, f_root, substitutions, match_next_literal(ibegin), partial_matches, misses); DREAL_ASSERT(result.size() == stats.matches); if (did_time_out) - DREAL_LOG_WARN("Pattern matching timed out after {} usec.", timeout.count()); - DREAL_LOG_INFO( - "Found {} matches of size {} ({} effective literals) with {} misses.", - stats.matches, literals.size(), stats.matches / ::pow(2, literals.size()), stats.misses + DREAL_LOG_INFO("Pattern matching timed out after {} usec.", timeout.count()); + DREAL_LOG_DEBUG( + "Found {} matches of size {} with {} misses.", + stats.matches, literals.size(), stats.misses ); // if (DREAL_LOG_INFO_ENABLED) { // for (const auto& [matched_clause, _] : result) { From 3b38ae78c03d76c76e638e952fe3aadef2f71af4 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 03:11:43 -0700 Subject: [PATCH 45/79] Cleanup - make sure SAT logging hooks don't harm benchmarking performance. --- src/dreal/solver/auditor.h | 6 ++++-- src/dreal/solver/context_impl.h | 4 ++-- src/dreal/solver/sat_solver.cc | 14 ++++++++------ src/dreal/util/predicate_abstractor.cc | 4 +++- 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/src/dreal/solver/auditor.h b/src/dreal/solver/auditor.h index e0c1fc946..e5c2e3a63 100644 --- a/src/dreal/solver/auditor.h +++ b/src/dreal/solver/auditor.h @@ -10,8 +10,10 @@ namespace dreal { -#define THEORY_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED -#define SAT_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED +// #define THEORY_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED +// #define SAT_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED + #define THEORY_AUDIT_ENABLED false + #define SAT_AUDIT_ENABLED false void sat_log_label_clause(const std::string& label); void sat_log_literal(int lit, const std::optional& def = {}); diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index a0f0d039e..62429e6d0 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -29,9 +29,9 @@ namespace dreal { -// #define FMCAD25_MODE_MATCH_ALL +#define FMCAD25_MODE_MATCH_ALL // #define FMCAD25_MODE_MATCH_SOME -#define FMCAD25_MODE_CONTROL +// #define FMCAD25_MODE_CONTROL #define GENERATE_CSV false diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index be5b11345..9d89cd92b 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -197,13 +197,15 @@ optional> SatSolver::CheckSat(const bool reque // } } - if (model_is_fully_constrained) { - sat_log_label_clause("SatSolver::CheckSat - Fully Constrained"); - } else { - sat_log_label_clause("SatSolver::CheckSat - Partially Constrained"); + if (SAT_AUDIT_ENABLED) { + if (model_is_fully_constrained) { + sat_log_label_clause("SatSolver::CheckSat - Fully Constrained"); + } else { + sat_log_label_clause("SatSolver::CheckSat - Partially Constrained"); + } + for (int i = 1; i <= cadical->vars(); ++i) if (model_is[i] != 0) sat_log_literal(i * model_is[i]); + sat_log_literal0(); } - for (int i = 1; i <= cadical->vars(); ++i) if (model_is[i] != 0) sat_log_literal(i * model_is[i]); - sat_log_literal0(); const auto& var_to_formula_map = predicate_abstractor_.var_to_formula_map(); for (int i = 1; i <= cadical->vars(); ++i) { diff --git a/src/dreal/util/predicate_abstractor.cc b/src/dreal/util/predicate_abstractor.cc index b55287517..39d477180 100644 --- a/src/dreal/util/predicate_abstractor.cc +++ b/src/dreal/util/predicate_abstractor.cc @@ -82,7 +82,9 @@ Formula PredicateAbstractor::Convert(const vector& formulas) { } Formula PredicateAbstractor::Visit(const Formula& f) { - DREAL_ASSERT(!(is_variable(f) && var_to_formula_map_.count(get_variable(f)))); + // eh.. no harm, a few wasted cycles, but too much work to fix this. + // called from lots of places with complicated call stack + // DREAL_ASSERT(!(is_variable(f) && var_to_formula_map_.count(get_variable(f)))); // First check if we processed this formula before. const auto it = formula_to_var_map_.find(f); From 8ad69933405600a5e39a360c4410758d8b9f0901 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 21 Apr 2025 03:23:23 -0700 Subject: [PATCH 46/79] Use tabs to improve readability of std:cerr prints. --- src/dreal/solver/context_impl.cc | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index eadb91c38..6922a73ad 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -353,8 +353,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.pattern_matching_stats = alcp_result; std::cerr << "P(is W.I.)=" << std::setprecision(3) << predicted_is_worth_it; - std::cerr << ". Matched " << alcp_result.matches << " size " << explanation.size() << " in " << alcp_elapsed.count(); - std::cerr << " ms. TSCS " << tscs_elapsed.count() << " ms." << std::endl; + std::cerr << ".\tMatched " << alcp_result.matches << " size " << explanation.size() << " in " << alcp_elapsed.count(); + std::cerr << " ms.\tTSCS " << tscs_elapsed.count() << " ms.\t"; + std::cerr << "Fully constrained = " << is_full_constrained << std::endl; // const double bb_lpms = 1 / tscs_elapsed.count(); // const double pm_lpms = (std::max(alcp_result.matches, 1u) - 0.999) / alcp_elapsed.count(); @@ -366,8 +367,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, // const bool underestimated = (actual_log2_worth_it > 1) && (predicted_is_worth_it < 0.5); } else { std::cerr << "P(is W.I.)=" << std::setprecision(3) << predicted_is_worth_it; - std::cerr << ". Adding 1 size " << explanation.size() << " directly. "; - std::cerr << "TSCS " << tscs_elapsed.count() << " ms." << std::endl; + std::cerr << ".\tAdding 1 size " << explanation.size() << " directly.\t"; + std::cerr << "TSCS " << tscs_elapsed.count() << " ms.\t"; + std::cerr << "Fully constrained = " << is_full_constrained << std::endl; #ifdef FMCAD25_MODE_CONTROL sat_solver->AddLearnedClauseUnboxed(explanation); #else From 6bbdfc19f7e7b918e97dc55dfddb47987ddac0e1 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 22 Apr 2025 20:28:26 -0700 Subject: [PATCH 47/79] Add exponential backoff to fully/under constrained switching logic in `context_impl.cc`. --- src/dreal/solver/context_impl.cc | 5 +++-- src/dreal/solver/context_impl.h | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 6922a73ad..a71ebc5f8 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -285,8 +285,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, // SAT from TheorySolver. // the next 3 unsats should be fully constrained before we can try under constrained stuff again. // or, we get a fully constrained deltasat, in which case we are done :) - recent_under_constrained_deltasat = 3; - DREAL_LOG_WARN("ContextImpl::CheckSatCore() - Underconstrained Theory Check = delta-SAT."); + recent_under_constrained_deltasat = recent_under_constrained_deltasat_limit; + DREAL_LOG_WARN("ContextImpl::CheckSatCore() - Underconstrained Theory Check = delta-SAT. Exponential Backoff = {}", recent_under_constrained_deltasat_limit); + recent_under_constrained_deltasat_limit *= 2; // exponential backoff return CheckSatCore(stack, std::move(box), sat_solver); } else if (tscs_result && is_full_constrained) { DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Fully Constrained Theory Check = delta-SAT"); diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index 62429e6d0..5559041c0 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -105,6 +105,7 @@ class Context::Impl { TheorySolver theory_solver_; int recent_under_constrained_deltasat = 0; + int recent_under_constrained_deltasat_limit = 2; // exponential back off. // Stores the result of the latest checksat. // Note that if the checksat result was UNSAT, this box holds an empty box. From ff975f9dd29657a787771db8ffc2f9204b438f96 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 22 Apr 2025 21:08:30 -0700 Subject: [PATCH 48/79] Log SAT clauses learned to std::err instead of INFO. --- src/dreal/solver/sat_solver_interval_logic.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 892ad1169..524e84476 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -360,7 +360,7 @@ namespace dreal } if (expected_clause_size <= LOG_INFO_SIZE) { const Formula sat_clause = !make_conjunction(neg_conjunction); - DREAL_LOG_INFO("SAT Solver Learned: {}", sat_clause); + std::cerr << "SAT Solver Learned: " << sat_clause << std::endl; } } } // namespace dreal From 9c5619f5a9b09fab73c7733692fe1f0ef6aa8fa0 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 22 Apr 2025 21:10:17 -0700 Subject: [PATCH 49/79] Remove `sat_solver->AddBox(pn_, box);` from `FMCAD25_MODE_CONTROL`. --- src/dreal/solver/auditor.h | 9 ++++++--- src/dreal/solver/context_impl.cc | 2 ++ 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/dreal/solver/auditor.h b/src/dreal/solver/auditor.h index e5c2e3a63..909ab0716 100644 --- a/src/dreal/solver/auditor.h +++ b/src/dreal/solver/auditor.h @@ -12,14 +12,17 @@ namespace dreal { // #define THEORY_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED // #define SAT_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED - #define THEORY_AUDIT_ENABLED false - #define SAT_AUDIT_ENABLED false +#define THEORY_AUDIT_ENABLED false +#define SAT_AUDIT_ENABLED false void sat_log_label_clause(const std::string& label); void sat_log_literal(int lit, const std::optional& def = {}); void sat_log_literal0(); - void theory_audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box); + void theory_audit_literals( + const PredicateAbstractor& pa, /*copy*/ std::vector lits, + const std::optional& box + ); void theory_audit_formula(const Formula& formula, const std::optional& box); } diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index a71ebc5f8..4c8901982 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -208,7 +208,9 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, } //////////////////////////////////////////////////////////////////////////////// +#ifndef FMCAD25_MODE_CONTROL sat_solver->AddBox(pn_, box); +#endif //////////////////////////////////////////////////////////////////////////////// for (const auto & variable : box.variables()) { From 7e966762bc999d77f191775cd9b42c3c95a6ba10 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 22 Apr 2025 21:10:47 -0700 Subject: [PATCH 50/79] Make it build on ubuntu. --- CMakeLists.txt | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0c5043765..7708ef55a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.30) +cmake_minimum_required(VERSION 3.16) project(dreal4_cmake) include(CMakePrintHelpers) @@ -108,7 +108,7 @@ include(FetchContent) FetchContent_Declare( ibex GIT_REPOSITORY https://github.com/ncsys-lab/ibex-lib - GIT_TAG 4d61b84139eaeab628506d9edaf5fd8879a3302e) # Kunal's M1 + namespace fixes + GIT_TAG cd44b915bbe300b8ba021f6a2437bf662679d093) # Kunal's M1 + namespace fixes FetchContent_MakeAvailable(ibex) FetchContent_Declare( @@ -156,6 +156,10 @@ target_link_libraries( dreal4_cmake PUBLIC ibex nlopt spdlog::spdlog fmt::fmt ) +# On some platforms, linking is purely sequential, and the order you specify libraries in matters. +# I am repeating these libraries from above so that everything gets resolved on Ubuntu +target_link_libraries(dreal4_cmake PUBLIC "${GMP_C_LIB}" "${GMP_CXX_LIB}") +target_link_libraries(dreal4_cmake PUBLIC "${FLEX_LIBRARIES}") # executable add_executable(dreal4 "${PROJECT_SOURCE_DIR}/src/dreal/dreal_main.cc") From 37e2900dc03b2a6ba364d382499a55271d53c6f6 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Fri, 25 Apr 2025 11:08:53 -0700 Subject: [PATCH 51/79] Fix build on CentOS with GCC 14 (sherlock). --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7708ef55a..29da6054e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -108,7 +108,7 @@ include(FetchContent) FetchContent_Declare( ibex GIT_REPOSITORY https://github.com/ncsys-lab/ibex-lib - GIT_TAG cd44b915bbe300b8ba021f6a2437bf662679d093) # Kunal's M1 + namespace fixes + GIT_TAG 33408ed0733da56979ddf797473609d4c39ea1ea) # Kunal's M1 + namespace fixes FetchContent_MakeAvailable(ibex) FetchContent_Declare( From f76a99a307cbb14fd0162d381c4649ac6228ece5 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Fri, 25 Apr 2025 12:05:45 -0700 Subject: [PATCH 52/79] Fix includes for more restrictive headers on CentOS --- CMakeLists.txt | 3 ++- src/dreal/solver/auditor.h | 1 + src/dreal/util/optional.h | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 29da6054e..6051d8025 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -81,8 +81,9 @@ target_include_directories(dreal4_cmake PUBLIC ) # system dependencies +find_library( FLEX_LIB NAMES libfl.a HINTS "${FLEX_ROOT}" PATH_SUFFIXES lib libs lib32 lib64 REQUIRED NO_CACHE) target_include_directories(dreal4_cmake PUBLIC "${FLEX_INCLUDE_DIRS}") -target_link_libraries(dreal4_cmake PUBLIC "${FLEX_LIBRARIES}") +target_link_libraries(dreal4_cmake PUBLIC "${FLEX_LIB}") find_path( GMP_INC NAMES gmpxx.h HINTS "${GMP_ROOT}" PATH_SUFFIXES include includes REQUIRED NO_CACHE) find_library( GMP_C_LIB NAMES libgmp.a HINTS "${GMP_ROOT}" PATH_SUFFIXES lib libs lib32 lib64 REQUIRED NO_CACHE) diff --git a/src/dreal/solver/auditor.h b/src/dreal/solver/auditor.h index 909ab0716..43c724ef5 100644 --- a/src/dreal/solver/auditor.h +++ b/src/dreal/solver/auditor.h @@ -7,6 +7,7 @@ #include #include +#include namespace dreal { diff --git a/src/dreal/util/optional.h b/src/dreal/util/optional.h index df0c0caaf..eae4f6d4d 100644 --- a/src/dreal/util/optional.h +++ b/src/dreal/util/optional.h @@ -15,6 +15,8 @@ */ #pragma once +#include + namespace dreal { template using optional = std::optional; From 4122e0619832e41f296fe50bea161bdd701605a0 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 10:26:31 -0700 Subject: [PATCH 53/79] Make cmake STATIC --- CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6051d8025..42c87c05f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,7 +63,7 @@ file(GLOB_RECURSE DREAL_SOURCES "${LIBCDS_HOME}/src/**.cpp" "${PICOSAT_HOME}/src/**.c" ) -add_library(dreal4_cmake +add_library(dreal4_cmake STATIC ${DREAL_SOURCES} ${BISON_smt2_parser_OUTPUTS} ${FLEX_smt2_scanner_OUTPUTS} ${BISON_dr_parser_OUTPUTS} ${FLEX_dr_scanner_OUTPUTS} @@ -160,7 +160,6 @@ target_link_libraries( # On some platforms, linking is purely sequential, and the order you specify libraries in matters. # I am repeating these libraries from above so that everything gets resolved on Ubuntu target_link_libraries(dreal4_cmake PUBLIC "${GMP_C_LIB}" "${GMP_CXX_LIB}") -target_link_libraries(dreal4_cmake PUBLIC "${FLEX_LIBRARIES}") # executable add_executable(dreal4 "${PROJECT_SOURCE_DIR}/src/dreal/dreal_main.cc") From 7539e555d62d9aa51f3201f6a0046f9d94a349dc Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 12:36:13 -0700 Subject: [PATCH 54/79] Consolidate experimental build flags into version.h to avoid accidents when benchmarking. --- .idea/misc.xml | 2 + src/dreal/solver/auditor.cc | 11 ++--- src/dreal/solver/auditor.h | 4 -- src/dreal/solver/context.cc | 21 ++++++++- src/dreal/solver/context_impl.cc | 45 +++++++++++-------- src/dreal/solver/context_impl.h | 6 --- src/dreal/solver/sat_solver.cc | 5 ++- src/dreal/solver/sat_solver_interval_logic.cc | 17 +++---- src/dreal/version.h | 44 +++++++++++++++--- 9 files changed, 105 insertions(+), 50 deletions(-) diff --git a/.idea/misc.xml b/.idea/misc.xml index f9ee57f05..0f57ff474 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -11,8 +11,10 @@ + + {} \ No newline at end of file diff --git a/src/dreal/solver/auditor.cc b/src/dreal/solver/auditor.cc index 4a67c5f7c..612c527a7 100644 --- a/src/dreal/solver/auditor.cc +++ b/src/dreal/solver/auditor.cc @@ -18,6 +18,7 @@ #include "dreal/solver/filter_assertion.h" #include "dreal/util/assert.h" #include "dreal/util/logging.h" +#include "dreal/version.h" namespace dreal { @@ -25,12 +26,12 @@ namespace dreal std::set literal_log_clause; void sat_log_label_clause(const std::string& s) { - if (!SAT_AUDIT_ENABLED) return; + if (!DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) return; literal_log << s << std::endl; } void sat_log_literal(const int lit, const std::optional& def) { - if (!SAT_AUDIT_ENABLED) return; + if (!DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) return; DREAL_ASSERT(lit != 0); static std::set seen_literals; @@ -43,7 +44,7 @@ namespace dreal } void sat_log_literal0() { - if (!SAT_AUDIT_ENABLED) return; + if (!DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) return; for (int v : literal_log_clause) literal_log << v << ' '; literal_log << '0' << std::endl; literal_log_clause.clear(); @@ -51,7 +52,7 @@ namespace dreal void theory_audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box) { // the operands passed here are expensive to produce, so really shouldn't be called unnecessarily. - DREAL_ASSERT(THEORY_AUDIT_ENABLED); + DREAL_ASSERT(DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED); for (auto& l : lits) { if (is_variable(l)) { @@ -73,7 +74,7 @@ namespace dreal void theory_audit_formula(const Formula& formula, const std::optional& box) { // the operands passed here are expensive to produce, so really shouldn't be called unnecessarily. - DREAL_ASSERT(THEORY_AUDIT_ENABLED); + DREAL_ASSERT(DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED); const auto& vs = formula.GetFreeVariables(); diff --git a/src/dreal/solver/auditor.h b/src/dreal/solver/auditor.h index 43c724ef5..570efd653 100644 --- a/src/dreal/solver/auditor.h +++ b/src/dreal/solver/auditor.h @@ -11,10 +11,6 @@ namespace dreal { -// #define THEORY_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED -// #define SAT_AUDIT_ENABLED DREAL_LOG_DEBUG_ENABLED -#define THEORY_AUDIT_ENABLED false -#define SAT_AUDIT_ENABLED false void sat_log_label_clause(const std::string& label); void sat_log_literal(int lit, const std::optional& def = {}); diff --git a/src/dreal/solver/context.cc b/src/dreal/solver/context.cc index 7d92fb170..c712da519 100644 --- a/src/dreal/solver/context.cc +++ b/src/dreal/solver/context.cc @@ -113,7 +113,26 @@ optional Context::GetOption(const string& key) const { const Config& Context::config() const { return impl_->config(); } Config& Context::mutable_config() { return impl_->mutable_config(); } -string Context::version() { return DREAL_VERSION_STRING; } +string Context::version() { + std::ostringstream oss; + oss << DREAL_VERSION_FULL << '.'; + oss << DREAL_VERSION_MAJOR << '.'; + oss << DREAL_VERSION_MINOR << '.'; + oss << DREAL_VERSION_REVISION << '.'; + + oss << "patmat" << pattern_matching_mode << '.'; + oss << "parmod" << partial_model_mode << '.'; + + oss << "audit" << + static_cast(DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) << + static_cast(DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED); + +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV + oss << ".GENERATE_CSV"; +#endif + + return oss.str(); +} const Box& Context::box() const { return impl_->box(); } diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 4c8901982..52eef215c 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -38,6 +38,7 @@ #include "dreal/util/if_then_else_eliminator.h" #include "dreal/util/interrupt.h" #include "dreal/util/logging.h" +#include "dreal/version.h" namespace dreal { @@ -138,19 +139,10 @@ void Context::Impl::Assert(const Formula& f) { optional Context::Impl::CheckSatCore(const ScopedVector& stack, Box box, SatSolver* const sat_solver) { -#ifdef FMCAD25_MODE_MATCH_ALL - std::cout << "FMCAD25_MODE_MATCH_ALL" << std::endl; -#endif -#ifdef FMCAD25_MODE_MATCH_SOME - std::cout << "FMCAD25_MODE_MATCH_SOME" << std::endl; -#endif -#ifdef FMCAD25_MODE_CONTROL - std::cout << "FMCAD25_MODE_CONTROL" << std::endl; -#endif - //////////////////////////////////////////////////////////////////////////////// +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV std::ofstream myfile; - if (GENERATE_CSV) { + { std::ostringstream s; s << "./kunal_paper_data_epoch"; s << std::chrono::system_clock::now().time_since_epoch().count(); @@ -169,6 +161,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, myfile.open(file_name, std::ios::app); if (!myfile) throw DREAL_RUNTIME_ERROR("Failed to open log file"); } +#endif PatternMatchingHeuristic::statistics kunal_paper_data{0}; //////////////////////////////////////////////////////////////////////////////// @@ -185,7 +178,8 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, } //////////////////////////////////////////////////////////////////////////////// - if (GENERATE_CSV) { +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV + { std::ostringstream s; s << "box_continuous_count,"; s << "box_integer_count,"; @@ -206,9 +200,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, s << PatternMatchingTrie::matching_stats_csv_header("pattern_matching_stats_"); myfile << s.str() << std::endl; } +#endif //////////////////////////////////////////////////////////////////////////////// -#ifndef FMCAD25_MODE_CONTROL +#ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE + static_assert(pattern_matching_mode != 0); sat_solver->AddBox(pn_, box); #endif @@ -326,22 +322,29 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; -#ifdef FMCAD25_MODE_MATCH_ALL +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL + static_assert(pattern_matching_mode == 2); if (true) { #endif -#ifdef FMCAD25_MODE_MATCH_SOME +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME + static_assert(pattern_matching_mode == 1); if (predicted_is_worth_it >= 0.5 && explanation.size() < 96) { #endif -#ifdef FMCAD25_MODE_CONTROL - if (false) { +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE + static_assert(pattern_matching_mode == 0); + if (false) { #endif const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( pn_, explanation, box, +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV + std::chrono::duration_cast(std::chrono::seconds(20)) +#else std::min( // based on information from WORTH_IT_regression_4.ipynb std::chrono::duration_cast(100 * tscs_elapsed), std::chrono::duration_cast(std::chrono::milliseconds(200)) ) +#endif ); // the pattern matching is kinda best-effort now. @@ -373,16 +376,19 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, std::cerr << ".\tAdding 1 size " << explanation.size() << " directly.\t"; std::cerr << "TSCS " << tscs_elapsed.count() << " ms.\t"; std::cerr << "Fully constrained = " << is_full_constrained << std::endl; -#ifdef FMCAD25_MODE_CONTROL +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE + static_assert(pattern_matching_mode == 0); sat_solver->AddLearnedClauseUnboxed(explanation); #else + static_assert(pattern_matching_mode != 0); sat_solver->AddLearnedClause(pn_, explanation, box); #endif } //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// - if (GENERATE_CSV) { +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV + { std::ostringstream s; s << kunal_paper_data.box_continuous_count << ','; s << kunal_paper_data.box_integer_count << ','; @@ -403,6 +409,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, s << kunal_paper_data.pattern_matching_stats; myfile << s.str() << std::endl; // also flushes } +#endif { typeof(kunal_paper_data) reset_data{0}; diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index 5559041c0..bc3865aca 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -29,12 +29,6 @@ namespace dreal { -#define FMCAD25_MODE_MATCH_ALL -// #define FMCAD25_MODE_MATCH_SOME -// #define FMCAD25_MODE_CONTROL - -#define GENERATE_CSV false - // The actual implementation. class Context::Impl { public: diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 9d89cd92b..28e1e0376 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -17,6 +17,7 @@ #include #include +#include #include #include @@ -54,7 +55,7 @@ SatSolver::SatSolver(const Config& config) : cadical(new CaDiCaL::Solver) { success = cadical->set("subsumeint", 1e3); DREAL_ASSERT(success); cadical->options(); - if (DREAL_LOG_INFO_ENABLED || SAT_AUDIT_ENABLED) cadical->connect_learner(this); + if (DREAL_LOG_INFO_ENABLED || DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) cadical->connect_learner(this); all_incl_lb_predicates.max_load_factor(0.25); all_excl_lb_predicates.max_load_factor(0.25); @@ -197,7 +198,7 @@ optional> SatSolver::CheckSat(const bool reque // } } - if (SAT_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) { if (model_is_fully_constrained) { sat_log_label_clause("SatSolver::CheckSat - Fully Constrained"); } else { diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 524e84476..7e095fc1f 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -4,6 +4,7 @@ #include #include +#include #include "auditor.h" #include "filter_assertion.h" @@ -21,7 +22,7 @@ namespace dreal cadical->add(0); sat_log_literal0(); - if (THEORY_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { std::vector a; for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); theory_audit_literals(predicate_abstractor_, a, {}); @@ -78,7 +79,7 @@ namespace dreal cadical->add(0); sat_log_literal0(); - if (THEORY_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { std::vector a; a.emplace_back(!predicate_abstractor_.Convert(lit)); FlattenIntervalClause(unfitted, [&](const auto& il) { a.emplace_back(!il); }); @@ -113,7 +114,7 @@ namespace dreal cadical->add(0); sat_log_literal0(); - if (THEORY_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { theory_audit_formula(!make_conjunction(conflicting_conjunction), unfitted_box); std::vector a; for (const auto& lit : lhs_implies) a.emplace_back(lit); @@ -154,7 +155,7 @@ namespace dreal for (const auto& [conflict_clause, subs] : all_related_conflicts) { const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); - if (THEORY_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); theory_audit_formula( !make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), @@ -283,7 +284,7 @@ namespace dreal cadical->add(0); sat_log_literal0(); - if (THEORY_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { theory_audit_literals(predicate_abstractor_, {!lb, !inv_lb}, {}); theory_audit_literals(predicate_abstractor_, {lb, inv_lb}, {}); } @@ -308,7 +309,7 @@ namespace dreal cadical->add(0); sat_log_literal0(); - if (THEORY_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { theory_audit_literals(predicate_abstractor_, {!ub, !inv_ub}, {}); theory_audit_literals(predicate_abstractor_, {ub, inv_ub}, {}); } @@ -321,7 +322,7 @@ namespace dreal buffer_i = 0; expected_clause_size = size; if (size <= LOG_INFO_SIZE) return true; - if (SAT_AUDIT_ENABLED && size < MAX_BUFFER_SIZE) return true; + if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED && size < MAX_BUFFER_SIZE) return true; return false; } @@ -354,7 +355,7 @@ namespace dreal ); } sat_log_literal0(); - if (SAT_AUDIT_ENABLED) { + if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) { const Formula sat_clause = !make_conjunction(neg_conjunction); sat_log_label_clause("i.e. " + sat_clause.to_string()); } diff --git a/src/dreal/version.h b/src/dreal/version.h index 728c3ee0c..b78976847 100644 --- a/src/dreal/version.h +++ b/src/dreal/version.h @@ -3,10 +3,44 @@ #ifndef VERSION_H #define VERSION_H -#define DREAL_VERSION_STRING "4.21.06.2" -#define DREAL_VERSION_FULL 4 -#define DREAL_VERSION_MAJOR 21 -#define DREAL_VERSION_MINOR 06 -#define DREAL_VERSION_REVISION 2 +#define DREAL_VERSION_FULL 5 +#define DREAL_VERSION_MAJOR 00 +#define DREAL_VERSION_MINOR 00 +#define DREAL_VERSION_REVISION 1 + +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL +// #define DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME +// #define DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE + +#define DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS +// #define DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS + +#define DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED false +#define DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED false + +// #define DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV + + +// check that options are required and mutually exclusive +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL +constexpr int pattern_matching_mode = 2; +#endif +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME +constexpr int pattern_matching_mode = 1; +#endif +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE +constexpr int pattern_matching_mode = 0; +#endif + +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS +constexpr int partial_model_mode = 1; +#endif +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS +constexpr int partial_model_mode = 0; +#endif + +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV +static_assert(pattern_matching_mode == 2); +#endif #endif //VERSION_H From e953754793d71892bf0ca31de05e0e8d957aa302 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 13:47:09 -0700 Subject: [PATCH 55/79] Add additional build flags for using partial v.s. full SAT models. --- src/dreal/solver/context_impl.cc | 14 +++- src/dreal/solver/sat_solver.cc | 79 ++++--------------- src/dreal/solver/sat_solver.h | 11 ++- src/dreal/solver/sat_solver_model_logic.cc | 70 ++++++++++++++++ .../test/sat_solver_model_minimizer_test.cc | 19 +++-- 5 files changed, 118 insertions(+), 75 deletions(-) create mode 100644 src/dreal/solver/sat_solver_model_logic.cc diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 52eef215c..372cc9f0a 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -233,11 +233,23 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, throw std::runtime_error("KeyboardInterrupt(SIGINT) Detected."); } #endif + +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS + static_assert(partial_model_mode == 0); + constexpr bool request_fully_constrained = true; +#endif +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS + static_assert(partial_model_mode == 1); const bool request_fully_constrained = recent_under_constrained_deltasat > 0; +#endif + const auto optional_model_and_fully_constrained = sat_solver->CheckSat(request_fully_constrained); if (optional_model_and_fully_constrained) { - const auto &[optional_model, is_full_constrained] = *optional_model_and_fully_constrained; + const auto& [optional_model, is_full_constrained] = *optional_model_and_fully_constrained; if (request_fully_constrained) DREAL_ASSERT(is_full_constrained); +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS + DREAL_ASSERT(request_fully_constrained && is_full_constrained); +#endif const vector>& boolean_model{optional_model.first}; const vector>& theory_model{optional_model.second}; diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 28e1e0376..67788bd41 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -128,8 +128,7 @@ optional> SatSolver::CheckSat(const bool reque cadical->irredundant()); stat.num_check_sat_++; // Call SAT solver. - TimerGuard check_sat_timer_guard(&stat.timer_check_sat_, - DREAL_LOG_INFO_ENABLED); + TimerGuard check_sat_timer_guard(&stat.timer_check_sat_,DREAL_LOG_INFO_ENABLED); const int ret{cadical->solve()}; // check_sat_timer_guard.pause(); @@ -137,75 +136,31 @@ optional> SatSolver::CheckSat(const bool reque if (ret == CaDiCaL::SATISFIABLE) { // SAT Case. - bool model_is_fully_constrained = true; - std::vector model_is(cadical->vars()+1); + int num_literals_omitted = 0; + std::vector model_is(cadical->vars() + 1); if (request_fully_constrained) { - for (int i = 1; i <= cadical->vars(); ++i) { - model_is[i] = cadical->val(i) > 0 ? +1 : -1; - } - } else /*(request_fully_constrained)*/ { - // MASK to prevent XOR issue... - // e.g. if we have 1 2 0, with model -1 2 0 - // then flipping -1 to +1, subsequently makes 2 flippable to -2 - // however, this DOES NOT MEAN they both can be set to 0 / don't care. - // need to mask away variables which were not flippable to begin with. - for (int i = 1; i <= cadical->vars(); ++i) { - model_is[i] = cadical->flippable(i); // mask - } - for (int i = 1; i <= cadical->vars(); ++i) { - // try to zero-out non-decision variables first, - // make the theory solver "focus" on decision variables to promote backtracking. - if (cadical->is_decision(i)) continue; - model_is[i] = model_is[i] && cadical->flip(i); - } - for (int i = 1; i <= cadical->vars(); ++i) { - if (!cadical->is_decision(i)) continue; - model_is[i] = model_is[i] && cadical->flip(i); - } - - // UPDATE - don't bother, this folds into the "combinatorial" issue below... - // I cannot trigger this in a unit test but it happens - // sporadically on large problems... - // a future flip "locks" a previous assignment, making it no longer flippable. - // for (int i = 1; i <= cadical->vars(); ++i) { - // model_is[i] = model_is[i] && cadical->flippable(i); - // } - - for (int i = 1; i <= cadical->vars(); ++i) { - if (model_is[i] /* was flippable and then flipped */) { - model_is_fully_constrained = false; - model_is[i] = 0; - } else { - const int val = cadical->val(i) > 0 ? +1 : -1; - model_is[i] = val; - } - } - - // todo: - // so it turns out we can basically never actually calculate what is flippable and what is not. - // unless we were to go through the full O(2^N) combinatorial set of flips-and-not-flips - // the best we can do is give an underconstrained model... - // and then scrutinize any SAT results with the full model. - // for (int i = 1; i <= cadical->vars(); ++i) { - // if (partial_model[i] == 0) { - // cadical->assume(+i); - // for (int j = 1; j <= cadical->vars(); ++j) if (partial_model[j] != 0) cadical->assume(j * partial_model[j]); - // DREAL_ASSERT (cadical->solve() == CaDiCaL::SATISFIABLE); - // cadical->assume(-i); - // for (int j = 1; j <= cadical->vars(); ++j) if (partial_model[j] != 0) cadical->assume(j * partial_model[j]); - // DREAL_ASSERT (cadical->solve() == CaDiCaL::SATISFIABLE); - // } - // } + num_literals_omitted = 0; + for (int i = 1; i <= cadical->vars(); ++i) model_is[i] = cadical->val(i) > 0 ? +1 : -1; } + else { + num_literals_omitted = get_partial_model(model_is); + // DREAL_LOG_INFO("SatSolver::CheckSat - Shrank model by {}%", num_literals_omitted * 100.0 / cadical->vars()); + } + std::cerr << "Shrank model by " << std::setprecision(3) << num_literals_omitted * 100.0 / cadical->vars() << '%' << std::endl; if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) { - if (model_is_fully_constrained) { + if (/*model_is_fully_constrained*/ num_literals_omitted == 0) { sat_log_label_clause("SatSolver::CheckSat - Fully Constrained"); } else { sat_log_label_clause("SatSolver::CheckSat - Partially Constrained"); } for (int i = 1; i <= cadical->vars(); ++i) if (model_is[i] != 0) sat_log_literal(i * model_is[i]); sat_log_literal0(); + + // check that we haven't OVER constrained somehow. + for (int i = 1; i <= cadical->vars(); ++i) if (model_is[i] != 0) cadical->assume(i * model_is[i]); + int result = cadical->solve(); // must call OUTSIDE of DREAL_ASSERT since we added a bunch of `assumes` + DREAL_ASSERT(result == CaDiCaL::SATISFIABLE); } const auto& var_to_formula_map = predicate_abstractor_.var_to_formula_map(); @@ -241,7 +196,7 @@ optional> SatSolver::CheckSat(const bool reque } } DREAL_LOG_DEBUG("SatSolver::CheckSat() Found a model."); - return {{model, model_is_fully_constrained}}; + return {{model, /*model_is_fully_constrained*/ num_literals_omitted == 0}}; } else if (ret == CaDiCaL::UNSATISFIABLE) { DREAL_LOG_DEBUG("SatSolver::CheckSat() No solution."); // UNSAT Case. diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 52da38e7a..468d49e26 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -32,6 +32,7 @@ #include "dreal/util/scoped_unordered_map.h" #include "dreal/util/scoped_unordered_set.h" #include "dreal/util/tseitin_cnfizer.h" +#include "dreal/version.h" namespace dreal { @@ -87,8 +88,12 @@ class SatSolver : public CaDiCaL::Learner { /// @returns a witness, satisfying model if the problem is satisfiable. /// @returns nullopt if UNSAT. optional> CheckSat( - // false because I guess that used to be the default. +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS + bool request_fully_constrained = true +#endif +#ifdef DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS bool request_fully_constrained = false +#endif ); // TODO(soonho): Push/Pop cnfizer and predicate_abstractor? @@ -98,7 +103,7 @@ class SatSolver : public CaDiCaL::Learner { [[nodiscard]] Formula theory_literal(const Variable& var) const; - private: +private: // Adds a formula @p f to the solver. // // @pre @p f is a clause. That is, it is either a literal (b or ¬b) @@ -116,6 +121,8 @@ class SatSolver : public CaDiCaL::Learner { // variable. void AddLiteral(const Formula& f); + int get_partial_model(std::vector& model_is); + // Member variables // ---------------- CaDiCaL::Solver* const cadical; diff --git a/src/dreal/solver/sat_solver_model_logic.cc b/src/dreal/solver/sat_solver_model_logic.cc new file mode 100644 index 000000000..f4d555e05 --- /dev/null +++ b/src/dreal/solver/sat_solver_model_logic.cc @@ -0,0 +1,70 @@ +#include + +#include "dreal/solver/sat_solver.h" + +namespace dreal { + +int SatSolver::get_partial_model(std::vector &model_is) { + DREAL_ASSERT(model_is.size() == cadical->vars() + 1); + + // make sure not to mix `flip` and `val` calls... slows things down. + // do all the "flipping" first, then call "val" in one sweep at the end. + + // MASK to prevent XOR issue... + // e.g. if we have 1 2 0, with model -1 2 0 + // then flipping -1 to +1, subsequently makes 2 flippable to -2 + // however, this DOES NOT MEAN they both can be set to 0 / don't care. + // need to mask away variables which were not flippable to begin with. + for (int i = 1; i <= cadical->vars(); ++i) { + model_is[i] = cadical->flippable(i); // mask + } + for (int i = 1; i <= cadical->vars(); ++i) { + // try to zero-out non-decision variables first, + // make the theory solver "focus" on decision variables to promote backtracking. + if (cadical->is_decision(i)) continue; + model_is[i] = model_is[i] && cadical->flip(i); + } + for (int i = 1; i <= cadical->vars(); ++i) { + if (!cadical->is_decision(i)) continue; + model_is[i] = model_is[i] && cadical->flip(i); + } + + // UPDATE - don't bother, this folds into the "combinatorial" issue below... + // I cannot trigger this in a unit test but it happens + // sporadically on large problems... + // a future flip "locks" a previous assignment, making it no longer flippable. + // for (int i = 1; i <= cadical->vars(); ++i) { + // model_is[i] = model_is[i] && cadical->flippable(i); + // } + + int num_omitted_literals = 0; + for (int i = 1; i <= cadical->vars(); ++i) { + if (model_is[i] /* was flippable and then flipped */) { + num_omitted_literals++; + model_is[i] = 0; + } else { + model_is[i] = cadical->val(i) > 0 ? +1 : -1; + } + } + + if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) { + // todo: + // so it turns out we can basically never actually calculate what is flippable and what is not. + // unless we were to go through the full O(2^N) combinatorial set of flips-and-not-flips + // the best we can do is give an underconstrained model... + // and then scrutinize any theory-SAT results with the full model. + // for (int i = 1; i <= cadical->vars(); ++i) { + // if (partial_model[i] == 0) { + // cadical->assume(+i); + // for (int j = 1; j <= cadical->vars(); ++j) if (partial_model[j] != 0) cadical->assume(j * partial_model[j]); + // DREAL_ASSERT (cadical->solve() == CaDiCaL::SATISFIABLE); + // cadical->assume(-i); + // for (int j = 1; j <= cadical->vars(); ++j) if (partial_model[j] != 0) cadical->assume(j * partial_model[j]); + // DREAL_ASSERT (cadical->solve() == CaDiCaL::SATISFIABLE); + // } + // } + } + + return num_omitted_literals; +} +} diff --git a/test/dreal/solver/test/sat_solver_model_minimizer_test.cc b/test/dreal/solver/test/sat_solver_model_minimizer_test.cc index faf10312a..8c0a101b5 100644 --- a/test/dreal/solver/test/sat_solver_model_minimizer_test.cc +++ b/test/dreal/solver/test/sat_solver_model_minimizer_test.cc @@ -50,7 +50,7 @@ namespace dreal cdcl.AddFormula(xor_of(b1, b2)); cdcl.AddFormula(Formula{b1}); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -65,7 +65,7 @@ namespace dreal TEST_F(SatSolverModelMinimizerTest, Xor2) { SatSolver cdcl{Config()}; cdcl.AddFormula(xor_of(b1, b2)); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -80,7 +80,7 @@ namespace dreal TEST_F(SatSolverModelMinimizerTest, Or1) { SatSolver cdcl{Config()}; cdcl.AddFormula(b1 || b2); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -96,7 +96,7 @@ namespace dreal SatSolver cdcl{Config()}; cdcl.AddFormula(b1 || b2); cdcl.AddFormula(b1 || b2 || b3); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -113,7 +113,7 @@ namespace dreal SatSolver cdcl{Config()}; cdcl.AddFormula(b1 || b2); cdcl.AddFormula(b1 || !b2); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -129,7 +129,7 @@ namespace dreal SatSolver cdcl{Config()}; cdcl.AddFormula(b1 || b2 || b3 || b4); cdcl.AddFormula(b5 || b6 || b7 || b8); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -142,7 +142,7 @@ namespace dreal SatSolver cdcl{Config()}; cdcl.AddFormula(b1 || b2 || b3 || b4); cdcl.AddFormula(b1 || b6 || b7 || b8); - const auto model = cdcl.CheckSat(); + const auto model = cdcl.CheckSat(false); EXPECT_TRUE(model); std::map assignments; @@ -167,7 +167,7 @@ namespace dreal // cdcl.cadical->assume(-cdcl.to_sat_var_[b1.get_id()]); // cdcl.cadical->assume(+cdcl.to_sat_var_[b2.get_id()]); // - // auto model = cdcl.CheckSat(); + // auto model = cdcl.CheckSat(false); // EXPECT_TRUE(model); // std::map assignments; // for (const auto& kv : model->first.first) assignments.emplace(kv); @@ -193,13 +193,12 @@ namespace dreal // cdcl.cadical->assume(-cdcl.to_sat_var_[b2.get_id()]); // cdcl.cadical->assume(+cdcl.to_sat_var_[b3.get_id()]); // - // auto model = cdcl.CheckSat(); + // auto model = cdcl.CheckSat(false); // EXPECT_TRUE(model); // std::map assignments; // for (const auto& kv : model->first.first) assignments.emplace(kv); // EXPECT_EQ(assignments.size(), 1); // EXPECT_TRUE(assignments[b2]); // } - } // namespace } // namespace dreal From d9f284286415c0cc75c7f054b2a428c3c4dd7993 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 16:32:24 -0700 Subject: [PATCH 56/79] Add pattern matching upper timeout to version.h. --- src/dreal/solver/context_impl.cc | 2 +- src/dreal/version.h | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 372cc9f0a..162cc22dc 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -354,7 +354,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #else std::min( // based on information from WORTH_IT_regression_4.ipynb std::chrono::duration_cast(100 * tscs_elapsed), - std::chrono::duration_cast(std::chrono::milliseconds(200)) + std::chrono::duration_cast(DREAL_EXPERIMENTAL_PATTERN_MATCH_TIMEOUT) ) #endif ); diff --git a/src/dreal/version.h b/src/dreal/version.h index b78976847..9e5cd2fa3 100644 --- a/src/dreal/version.h +++ b/src/dreal/version.h @@ -20,6 +20,9 @@ // #define DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV +// this is an *upper* limit for calculated timeout, 100 * TSCS +// should be taken from data reflected in WORTH_IT_regression_*.ipynb +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_TIMEOUT (std::chrono::milliseconds(500)) // check that options are required and mutually exclusive #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL From 2d3b259bbafc811221142b793d7e7d8fd71d629c Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 16:39:42 -0700 Subject: [PATCH 57/79] Downgrade verbose `Finding matches for:...` logs to DEBUG. --- src/dreal/util/predicate_normalizer.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index c1d7b1d24..eb9fdaf81 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -25,12 +25,12 @@ namespace dreal const std::vector& ordered_clause, const std::chrono::duration timeout ) const { - if (DREAL_LOG_INFO_ENABLED) { + if (DREAL_LOG_DEBUG_ENABLED) { std::ostringstream s; s << "!("; for (const auto& lit : ordered_clause) s << '(' << lit << ") and "; s << ")"; - DREAL_LOG_INFO("Finding matches for: {}", s.str()); + DREAL_LOG_DEBUG("Finding matches for: {}", s.str()); } // todo `std::reverse()` and compare performance. From 9f40016e429e4de8d4463226228f62e4053087d6 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 16:52:15 -0700 Subject: [PATCH 58/79] Remove no longer necessary permutation check in pmtg.cc. --- .../pattern_matching_trie_general.cc | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index 0a3341f7c..1eddea022 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -19,6 +19,8 @@ namespace dreal const std::vector& literals, const std::chrono::duration timeout ) const { + // todo: somehow prioritize decision literals? + matching_stats_t stats = {0}; std::vector matches_vec; std::vector, substitutions_map>> result; @@ -50,8 +52,8 @@ namespace dreal const auto ibegin = literals.begin(); const auto iend = literals.end(); - std::unordered_set seen_truncateds; // lexo-compare for nary goes one by one... - seen_truncateds.reserve(1024 * literals.size()); + // std::unordered_set seen_truncateds; // lexo-compare for nary goes one by one... + // seen_truncateds.reserve(1024 * literals.size()); std::function< std::function(typeof(ibegin)) > match_next_literal = [&](const auto& it1) { @@ -65,14 +67,14 @@ namespace dreal // avoid re-finding 1000s of permutations of the same clause on fedor_13.smt2, etc. // copy required. do NOT modify matches_vec... that needs to be a pure stack - std::set matches_vec_set(matches_vec.begin(), matches_vec.end()); - const auto [_, successful_emplace] = seen_truncateds.emplace( - make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(matches_vec_set)) - ); - if (!successful_emplace) { - matches_vec.pop_back(); - return; - } + // std::set matches_vec_set(matches_vec.begin(), matches_vec.end()); + // const auto [_, successful_emplace] = seen_truncateds.emplace( + // make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(matches_vec_set)) + // ); + // if (!successful_emplace) { + // matches_vec.pop_back(); + // return; + // } if (it1 == iend) { DREAL_ASSERT(literals.size() == 1); From cab058da1d2470a42a3815c8208352b7b2a2ffd8 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sat, 26 Apr 2025 19:29:20 -0700 Subject: [PATCH 59/79] Filter theory solver explanations at the top level to avoid unnecessary pattern matching work. --- src/dreal/solver/context_impl.cc | 81 ++++++++++++------- src/dreal/solver/context_impl.h | 2 +- src/dreal/solver/sat_solver.cc | 2 +- src/dreal/solver/sat_solver.h | 2 +- src/dreal/solver/sat_solver_interval_logic.cc | 2 +- 5 files changed, 57 insertions(+), 32 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 162cc22dc..e3cd6eeb3 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -137,7 +137,7 @@ void Context::Impl::Assert(const Formula& f) { } optional Context::Impl::CheckSatCore(const ScopedVector& stack, - Box box, + Box problem_box, SatSolver* const sat_solver) { //////////////////////////////////////////////////////////////////////////////// #ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV @@ -167,14 +167,14 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, //////////////////////////////////////////////////////////////////////////////// DREAL_LOG_DEBUG("ContextImpl::CheckSatCore()"); - DREAL_LOG_TRACE("ContextImpl::CheckSat: Box =\n{}", box); - if (box.empty()) return {}; + DREAL_LOG_TRACE("ContextImpl::CheckSat: Box =\n{}", problem_box); + if (problem_box.empty()) return {}; // If false ∈ stack, it's UNSAT. for (const auto& f : stack.get_vector()) if (is_false(f)) return {}; // If stack = ∅ or stack = {true}, it's trivially SAT. if (stack.empty() || (stack.size() == 1 && is_true(stack.first()))) { - DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Found Model\n{}", box); - return box; + DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Found Model\n{}", problem_box); + return problem_box; } //////////////////////////////////////////////////////////////////////////////// @@ -205,11 +205,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE static_assert(pattern_matching_mode != 0); - sat_solver->AddBox(pn_, box); + sat_solver->AddBox(pn_, problem_box); #endif //////////////////////////////////////////////////////////////////////////////// - for (const auto & variable : box.variables()) { + for (const auto & variable : problem_box.variables()) { if (variable.get_type() == Variable::Type::CONTINUOUS) kunal_paper_data.box_continuous_count++; else if (variable.get_type() == Variable::Type::INTEGER) kunal_paper_data.box_integer_count++; else if (variable.get_type() == Variable::Type::BOOLEAN) kunal_paper_data.box_boolean_count++; @@ -255,7 +255,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const vector>& theory_model{optional_model.second}; for (const auto& [sat_var, assignment] : boolean_model) - box[sat_var] = assignment ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 + problem_box[sat_var] = assignment ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 if (!theory_model.empty()) { // SAT from SATSolver. @@ -285,7 +285,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const std::chrono::duration ranking_elapsed1 = ranking_end1 - ranking_start1; const auto tscs_start = std::chrono::high_resolution_clock::now(); - const auto tscs_result = theory_solver_.CheckSat(box, assertions); + const auto tscs_result = theory_solver_.CheckSat(problem_box, assertions); const auto tscs_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration tscs_elapsed = tscs_end - tscs_start; kunal_paper_data.theory_checksat_ms = tscs_elapsed.count(); @@ -298,7 +298,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, recent_under_constrained_deltasat = recent_under_constrained_deltasat_limit; DREAL_LOG_WARN("ContextImpl::CheckSatCore() - Underconstrained Theory Check = delta-SAT. Exponential Backoff = {}", recent_under_constrained_deltasat_limit); recent_under_constrained_deltasat_limit *= 2; // exponential backoff - return CheckSatCore(stack, std::move(box), sat_solver); + return CheckSatCore(stack, std::move(problem_box), sat_solver); } else if (tscs_result && is_full_constrained) { DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Fully Constrained Theory Check = delta-SAT"); return theory_solver_.GetModel(); @@ -307,19 +307,46 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (recent_under_constrained_deltasat > 0) recent_under_constrained_deltasat--; DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Theory Check = UNSAT"); - std::vector explanation( - theory_solver_.GetExplanation().begin(), - theory_solver_.GetExplanation().end() - ); DREAL_LOG_DEBUG( "ContextImpl::CheckSatCore() - size of explanation = {} - stack size = {}", - explanation.size(), stack.get_vector().size()); + theory_solver_.GetExplanation().size(), stack.get_vector().size()); - // ordering the literals like this makes pattern matching fast. // todo: abstract this away better. should not happen at the top-level like it is now. + /*copy*/ Box explanation_box = problem_box; + std::vector explanation; + explanation.reserve(theory_solver_.GetExplanation().size()); +#ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE + static_assert(pattern_matching_mode != 0); + for (const auto & lit : theory_solver_.GetExplanation()) { + const auto result = FilterAssertion(lit, &explanation_box); + if(!result.filtered) explanation.emplace_back(lit); + } + + if (explanation.empty()) { + // accidentally filtered all... + // these lemmas come from trivial bounds e.g. (x < NUMBER) + // which exist in the original problem but aren't at the top-level. + // so they become "exposed" on particular models, and need to be dealt with. + DREAL_LOG_WARN("Learned trivial lemma of size {}", theory_solver_.GetExplanation().size()); + DREAL_ASSERT(explanation_box.interval_vector().is_flat()); // shrunk to 0 + explanation_box = problem_box; + explanation.insert( + explanation.begin(), + theory_solver_.GetExplanation().begin(), theory_solver_.GetExplanation().end() + ); + } + + // ordering the literals like this makes pattern matching fast. std::sort(explanation.begin(), explanation.end(), [](const Formula &a, const Formula &b) { return a.GetFreeVariables().size() > b.GetFreeVariables().size(); // descending }); +#else + static_assert(pattern_matching_mode == 0); + explanation.insert( + explanation.begin(), + theory_solver_.GetExplanation().begin(), theory_solver_.GetExplanation().end() + ); +#endif //////////////////////////////////////////////////////////////////////////////// kunal_paper_data.lemma_size = explanation.size(); @@ -348,7 +375,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #endif const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( - pn_, explanation, box, + pn_, explanation, explanation_box, #ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV std::chrono::duration_cast(std::chrono::seconds(20)) #else @@ -359,11 +386,6 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #endif ); - // the pattern matching is kinda best-effort now. - // it breaks down when one clause pattern matches into 1000s of permutations of itself - // just make the best effort, and at the very minimum make sure the original at least gets inserted - sat_solver->AddLearnedClauseUnboxed(explanation); // just to be sure, sound because this is unmatched, straight from theory solver. - const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; @@ -388,14 +410,17 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, std::cerr << ".\tAdding 1 size " << explanation.size() << " directly.\t"; std::cerr << "TSCS " << tscs_elapsed.count() << " ms.\t"; std::cerr << "Fully constrained = " << is_full_constrained << std::endl; -#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE - static_assert(pattern_matching_mode == 0); - sat_solver->AddLearnedClauseUnboxed(explanation); -#else +#ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE static_assert(pattern_matching_mode != 0); - sat_solver->AddLearnedClause(pn_, explanation, box); + sat_solver->AddLearnedClause(pn_, explanation, explanation_box); #endif } + // the pattern matching is kinda best-effort now. + // it breaks down when one clause pattern matches into 1000s of permutations of itself + // just make the best effort, and at the very minimum make sure the original at least gets inserted + // just to be sure, sound because this is unmatched, straight from theory solver. + // also, this should just happen in all modes no matter what. + sat_solver->AddLearnedClauseUnboxed(theory_solver_.GetExplanation()); //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// @@ -439,7 +464,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, DREAL_LOG_TRACE("ContextImpl::CheckSatCore: Explanation {}", f_i); } } - } else /* theory_model.empty() */ return box; + } else /* theory_model.empty() */ return problem_box; } else /* !optional_model */ { // UNSAT from SATSolver. Escape the loop. DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Sat Check = UNSAT"); diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index bc3865aca..721729ffe 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -69,7 +69,7 @@ class Context::Impl { void AddToBox(const Variable& v); // Returns the current box in the stack. - optional CheckSatCore(const ScopedVector& stack, Box box, + optional CheckSatCore(const ScopedVector& stack, Box problem_box, SatSolver* sat_solver); // Marks variable @p v as a model variable diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 67788bd41..5e606904f 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -146,7 +146,7 @@ optional> SatSolver::CheckSat(const bool reque num_literals_omitted = get_partial_model(model_is); // DREAL_LOG_INFO("SatSolver::CheckSat - Shrank model by {}%", num_literals_omitted * 100.0 / cadical->vars()); } - std::cerr << "Shrank model by " << std::setprecision(3) << num_literals_omitted * 100.0 / cadical->vars() << '%' << std::endl; + std::cerr << "Omitted " << num_literals_omitted << " literals from model of size " << cadical->vars() << '.' << std::endl; if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) { if (/*model_is_fully_constrained*/ num_literals_omitted == 0) { diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 468d49e26..51a1de06f 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -69,7 +69,7 @@ class SatSolver : public CaDiCaL::Learner { /// Given a @p formulas = {f₁, ..., fₙ}, adds a clause (¬f₁ ∨ ... ∨ ¬ fₙ) to /// the solver. - void AddLearnedClauseUnboxed(const std::vector& conflicting_conjunction); + void AddLearnedClauseUnboxed(const std::set& conflicting_conjunction); void AddLearnedClause(PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& box); diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 7e095fc1f..a9859c149 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -13,7 +13,7 @@ namespace dreal { void SatSolver::AddLearnedClauseUnboxed( - const std::vector& conflicting_conjunction + const std::set& conflicting_conjunction ) { sat_log_label_clause("SatSolver::AddLearnedClauseUnboxed"); for (const Formula& f : conflicting_conjunction) { From b78d0c73c3fc97cc08df115be6db153a7e30eca4 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 27 Apr 2025 10:36:58 -0700 Subject: [PATCH 60/79] Add QF_IDL to supported logics. --- src/dreal/smt2/logic.cc | 5 +++++ src/dreal/smt2/logic.h | 1 + 2 files changed, 6 insertions(+) diff --git a/src/dreal/smt2/logic.cc b/src/dreal/smt2/logic.cc index 52d0f8030..9fa04d47e 100644 --- a/src/dreal/smt2/logic.cc +++ b/src/dreal/smt2/logic.cc @@ -26,6 +26,9 @@ Logic parse_logic(const string& s) { if (s == "ALL") { return Logic::ALL; } + if (s == "QF_IDL") { + return Logic::QF_IDL; + } if (s == "QF_LIA") { return Logic::QF_LIA; } @@ -63,6 +66,8 @@ ostream& operator<<(ostream& os, const Logic& logic) { switch (logic) { case Logic::ALL: return os << "ALL"; + case Logic::QF_IDL: + return os << "QF_IDL"; case Logic::QF_LIA: return os << "QF_LIA"; case Logic::QF_LIRA: diff --git a/src/dreal/smt2/logic.h b/src/dreal/smt2/logic.h index c04051376..18fe4e08b 100644 --- a/src/dreal/smt2/logic.h +++ b/src/dreal/smt2/logic.h @@ -23,6 +23,7 @@ namespace dreal { enum class Logic { ALL, + QF_IDL, QF_LIA, QF_LIRA, QF_LRA, From 97b7cce5c53f639fd25ef9c260158cbb3d2f75c0 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Sun, 27 Apr 2025 10:48:52 -0700 Subject: [PATCH 61/79] Revert "Add QF_IDL to supported logics." This reverts commit b78d0c73c3fc97cc08df115be6db153a7e30eca4. --- src/dreal/smt2/logic.cc | 5 ----- src/dreal/smt2/logic.h | 1 - 2 files changed, 6 deletions(-) diff --git a/src/dreal/smt2/logic.cc b/src/dreal/smt2/logic.cc index 9fa04d47e..52d0f8030 100644 --- a/src/dreal/smt2/logic.cc +++ b/src/dreal/smt2/logic.cc @@ -26,9 +26,6 @@ Logic parse_logic(const string& s) { if (s == "ALL") { return Logic::ALL; } - if (s == "QF_IDL") { - return Logic::QF_IDL; - } if (s == "QF_LIA") { return Logic::QF_LIA; } @@ -66,8 +63,6 @@ ostream& operator<<(ostream& os, const Logic& logic) { switch (logic) { case Logic::ALL: return os << "ALL"; - case Logic::QF_IDL: - return os << "QF_IDL"; case Logic::QF_LIA: return os << "QF_LIA"; case Logic::QF_LIRA: diff --git a/src/dreal/smt2/logic.h b/src/dreal/smt2/logic.h index 18fe4e08b..c04051376 100644 --- a/src/dreal/smt2/logic.h +++ b/src/dreal/smt2/logic.h @@ -23,7 +23,6 @@ namespace dreal { enum class Logic { ALL, - QF_IDL, QF_LIA, QF_LIRA, QF_LRA, From 6d114dfc5d0d6b8514fe150c10e18654273bac6a Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 29 Apr 2025 18:51:37 -0700 Subject: [PATCH 62/79] Revert "Filter theory solver explanations at the top level to avoid unnecessary pattern matching work." This reverts commit cab058da1d2470a42a3815c8208352b7b2a2ffd8. --- src/dreal/solver/context_impl.cc | 81 +++++++------------ src/dreal/solver/context_impl.h | 2 +- src/dreal/solver/sat_solver.h | 2 +- src/dreal/solver/sat_solver_interval_logic.cc | 2 +- 4 files changed, 31 insertions(+), 56 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index e3cd6eeb3..162cc22dc 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -137,7 +137,7 @@ void Context::Impl::Assert(const Formula& f) { } optional Context::Impl::CheckSatCore(const ScopedVector& stack, - Box problem_box, + Box box, SatSolver* const sat_solver) { //////////////////////////////////////////////////////////////////////////////// #ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV @@ -167,14 +167,14 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, //////////////////////////////////////////////////////////////////////////////// DREAL_LOG_DEBUG("ContextImpl::CheckSatCore()"); - DREAL_LOG_TRACE("ContextImpl::CheckSat: Box =\n{}", problem_box); - if (problem_box.empty()) return {}; + DREAL_LOG_TRACE("ContextImpl::CheckSat: Box =\n{}", box); + if (box.empty()) return {}; // If false ∈ stack, it's UNSAT. for (const auto& f : stack.get_vector()) if (is_false(f)) return {}; // If stack = ∅ or stack = {true}, it's trivially SAT. if (stack.empty() || (stack.size() == 1 && is_true(stack.first()))) { - DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Found Model\n{}", problem_box); - return problem_box; + DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Found Model\n{}", box); + return box; } //////////////////////////////////////////////////////////////////////////////// @@ -205,11 +205,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE static_assert(pattern_matching_mode != 0); - sat_solver->AddBox(pn_, problem_box); + sat_solver->AddBox(pn_, box); #endif //////////////////////////////////////////////////////////////////////////////// - for (const auto & variable : problem_box.variables()) { + for (const auto & variable : box.variables()) { if (variable.get_type() == Variable::Type::CONTINUOUS) kunal_paper_data.box_continuous_count++; else if (variable.get_type() == Variable::Type::INTEGER) kunal_paper_data.box_integer_count++; else if (variable.get_type() == Variable::Type::BOOLEAN) kunal_paper_data.box_boolean_count++; @@ -255,7 +255,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const vector>& theory_model{optional_model.second}; for (const auto& [sat_var, assignment] : boolean_model) - problem_box[sat_var] = assignment ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 + box[sat_var] = assignment ? 1.0 : 0.0; // true -> 1.0 and false -> 0.0 if (!theory_model.empty()) { // SAT from SATSolver. @@ -285,7 +285,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const std::chrono::duration ranking_elapsed1 = ranking_end1 - ranking_start1; const auto tscs_start = std::chrono::high_resolution_clock::now(); - const auto tscs_result = theory_solver_.CheckSat(problem_box, assertions); + const auto tscs_result = theory_solver_.CheckSat(box, assertions); const auto tscs_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration tscs_elapsed = tscs_end - tscs_start; kunal_paper_data.theory_checksat_ms = tscs_elapsed.count(); @@ -298,7 +298,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, recent_under_constrained_deltasat = recent_under_constrained_deltasat_limit; DREAL_LOG_WARN("ContextImpl::CheckSatCore() - Underconstrained Theory Check = delta-SAT. Exponential Backoff = {}", recent_under_constrained_deltasat_limit); recent_under_constrained_deltasat_limit *= 2; // exponential backoff - return CheckSatCore(stack, std::move(problem_box), sat_solver); + return CheckSatCore(stack, std::move(box), sat_solver); } else if (tscs_result && is_full_constrained) { DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Fully Constrained Theory Check = delta-SAT"); return theory_solver_.GetModel(); @@ -307,46 +307,19 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (recent_under_constrained_deltasat > 0) recent_under_constrained_deltasat--; DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Theory Check = UNSAT"); + std::vector explanation( + theory_solver_.GetExplanation().begin(), + theory_solver_.GetExplanation().end() + ); DREAL_LOG_DEBUG( "ContextImpl::CheckSatCore() - size of explanation = {} - stack size = {}", - theory_solver_.GetExplanation().size(), stack.get_vector().size()); - - // todo: abstract this away better. should not happen at the top-level like it is now. - /*copy*/ Box explanation_box = problem_box; - std::vector explanation; - explanation.reserve(theory_solver_.GetExplanation().size()); -#ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE - static_assert(pattern_matching_mode != 0); - for (const auto & lit : theory_solver_.GetExplanation()) { - const auto result = FilterAssertion(lit, &explanation_box); - if(!result.filtered) explanation.emplace_back(lit); - } - - if (explanation.empty()) { - // accidentally filtered all... - // these lemmas come from trivial bounds e.g. (x < NUMBER) - // which exist in the original problem but aren't at the top-level. - // so they become "exposed" on particular models, and need to be dealt with. - DREAL_LOG_WARN("Learned trivial lemma of size {}", theory_solver_.GetExplanation().size()); - DREAL_ASSERT(explanation_box.interval_vector().is_flat()); // shrunk to 0 - explanation_box = problem_box; - explanation.insert( - explanation.begin(), - theory_solver_.GetExplanation().begin(), theory_solver_.GetExplanation().end() - ); - } + explanation.size(), stack.get_vector().size()); // ordering the literals like this makes pattern matching fast. + // todo: abstract this away better. should not happen at the top-level like it is now. std::sort(explanation.begin(), explanation.end(), [](const Formula &a, const Formula &b) { return a.GetFreeVariables().size() > b.GetFreeVariables().size(); // descending }); -#else - static_assert(pattern_matching_mode == 0); - explanation.insert( - explanation.begin(), - theory_solver_.GetExplanation().begin(), theory_solver_.GetExplanation().end() - ); -#endif //////////////////////////////////////////////////////////////////////////////// kunal_paper_data.lemma_size = explanation.size(); @@ -375,7 +348,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #endif const auto alcp_start = std::chrono::high_resolution_clock::now(); const auto alcp_result = sat_solver->AddLearnedClausePattern( - pn_, explanation, explanation_box, + pn_, explanation, box, #ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV std::chrono::duration_cast(std::chrono::seconds(20)) #else @@ -386,6 +359,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #endif ); + // the pattern matching is kinda best-effort now. + // it breaks down when one clause pattern matches into 1000s of permutations of itself + // just make the best effort, and at the very minimum make sure the original at least gets inserted + sat_solver->AddLearnedClauseUnboxed(explanation); // just to be sure, sound because this is unmatched, straight from theory solver. + const auto alcp_end = std::chrono::high_resolution_clock::now(); const std::chrono::duration alcp_elapsed = alcp_end - alcp_start; @@ -410,17 +388,14 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, std::cerr << ".\tAdding 1 size " << explanation.size() << " directly.\t"; std::cerr << "TSCS " << tscs_elapsed.count() << " ms.\t"; std::cerr << "Fully constrained = " << is_full_constrained << std::endl; -#ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE +#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE + static_assert(pattern_matching_mode == 0); + sat_solver->AddLearnedClauseUnboxed(explanation); +#else static_assert(pattern_matching_mode != 0); - sat_solver->AddLearnedClause(pn_, explanation, explanation_box); + sat_solver->AddLearnedClause(pn_, explanation, box); #endif } - // the pattern matching is kinda best-effort now. - // it breaks down when one clause pattern matches into 1000s of permutations of itself - // just make the best effort, and at the very minimum make sure the original at least gets inserted - // just to be sure, sound because this is unmatched, straight from theory solver. - // also, this should just happen in all modes no matter what. - sat_solver->AddLearnedClauseUnboxed(theory_solver_.GetExplanation()); //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// @@ -464,7 +439,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, DREAL_LOG_TRACE("ContextImpl::CheckSatCore: Explanation {}", f_i); } } - } else /* theory_model.empty() */ return problem_box; + } else /* theory_model.empty() */ return box; } else /* !optional_model */ { // UNSAT from SATSolver. Escape the loop. DREAL_LOG_DEBUG("ContextImpl::CheckSatCore() - Sat Check = UNSAT"); diff --git a/src/dreal/solver/context_impl.h b/src/dreal/solver/context_impl.h index 721729ffe..bc3865aca 100644 --- a/src/dreal/solver/context_impl.h +++ b/src/dreal/solver/context_impl.h @@ -69,7 +69,7 @@ class Context::Impl { void AddToBox(const Variable& v); // Returns the current box in the stack. - optional CheckSatCore(const ScopedVector& stack, Box problem_box, + optional CheckSatCore(const ScopedVector& stack, Box box, SatSolver* sat_solver); // Marks variable @p v as a model variable diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 51a1de06f..468d49e26 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -69,7 +69,7 @@ class SatSolver : public CaDiCaL::Learner { /// Given a @p formulas = {f₁, ..., fₙ}, adds a clause (¬f₁ ∨ ... ∨ ¬ fₙ) to /// the solver. - void AddLearnedClauseUnboxed(const std::set& conflicting_conjunction); + void AddLearnedClauseUnboxed(const std::vector& conflicting_conjunction); void AddLearnedClause(PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& box); diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index a9859c149..7e095fc1f 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -13,7 +13,7 @@ namespace dreal { void SatSolver::AddLearnedClauseUnboxed( - const std::set& conflicting_conjunction + const std::vector& conflicting_conjunction ) { sat_log_label_clause("SatSolver::AddLearnedClauseUnboxed"); for (const Formula& f : conflicting_conjunction) { From 1580ec64e3600f2e83b0bacc53f46f79b8b2e9c1 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Wed, 30 Apr 2025 02:23:48 -0700 Subject: [PATCH 63/79] Revert "Remove no longer necessary permutation check in pmtg.cc." This reverts commit 9f40016e429e4de8d4463226228f62e4053087d6. --- .../pattern_matching_trie_general.cc | 22 +++++++++---------- 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index 1eddea022..0a3341f7c 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -19,8 +19,6 @@ namespace dreal const std::vector& literals, const std::chrono::duration timeout ) const { - // todo: somehow prioritize decision literals? - matching_stats_t stats = {0}; std::vector matches_vec; std::vector, substitutions_map>> result; @@ -52,8 +50,8 @@ namespace dreal const auto ibegin = literals.begin(); const auto iend = literals.end(); - // std::unordered_set seen_truncateds; // lexo-compare for nary goes one by one... - // seen_truncateds.reserve(1024 * literals.size()); + std::unordered_set seen_truncateds; // lexo-compare for nary goes one by one... + seen_truncateds.reserve(1024 * literals.size()); std::function< std::function(typeof(ibegin)) > match_next_literal = [&](const auto& it1) { @@ -67,14 +65,14 @@ namespace dreal // avoid re-finding 1000s of permutations of the same clause on fedor_13.smt2, etc. // copy required. do NOT modify matches_vec... that needs to be a pure stack - // std::set matches_vec_set(matches_vec.begin(), matches_vec.end()); - // const auto [_, successful_emplace] = seen_truncateds.emplace( - // make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(matches_vec_set)) - // ); - // if (!successful_emplace) { - // matches_vec.pop_back(); - // return; - // } + std::set matches_vec_set(matches_vec.begin(), matches_vec.end()); + const auto [_, successful_emplace] = seen_truncateds.emplace( + make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(matches_vec_set)) + ); + if (!successful_emplace) { + matches_vec.pop_back(); + return; + } if (it1 == iend) { DREAL_ASSERT(literals.size() == 1); From abf64f6b909d37901913b173051f837f79d2170c Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Wed, 30 Apr 2025 18:39:04 -0700 Subject: [PATCH 64/79] Add safety checks preventing segfaults and/or egregiously wasted effort when pattern matching. --- src/dreal/solver/context_impl.cc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 162cc22dc..0cf92a0d0 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -336,7 +336,10 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL static_assert(pattern_matching_mode == 2); - if (true) { + if (true + && explanation.size() < 384 /* stack overflows around size=960 on x86 */ + && tscs_elapsed > std::chrono::milliseconds(3) + ) { #endif #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME static_assert(pattern_matching_mode == 1); From 91854058638306c416b1a8147bc38a1638c89222 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Wed, 30 Apr 2025 21:09:15 -0700 Subject: [PATCH 65/79] Set RLIMIT stack size in main to avoid overflows on pattern matching algo. --- src/dreal/dreal_main.cc | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/dreal/dreal_main.cc b/src/dreal/dreal_main.cc index b67fad806..b22a42255 100644 --- a/src/dreal/dreal_main.cc +++ b/src/dreal/dreal_main.cc @@ -476,6 +476,24 @@ void HandleSigInt(const int) { } // namespace int main(int argc, const char* argv[]) { + // default stack size is 8MB + // CPS-pattern matching algo goes DEEP... + // doing 63MB because that's approximately the max on macOS + constexpr rlim_t desired_stack_size = 63 * 1024 * 1024; + rlimit rl{0}; + getrlimit(RLIMIT_STACK, &rl); + rl.rlim_cur = std::max(rl.rlim_cur, desired_stack_size); + setrlimit(RLIMIT_STACK, &rl); + rl.rlim_cur = 0; + getrlimit(RLIMIT_STACK, &rl); + if (rl.rlim_cur < desired_stack_size) { + std::cerr << "Failed to configure desired stack size limit. Exiting." << std::endl; + std::cerr << "\tCurrent Size = " << rl.rlim_cur << std::endl; + std::cerr << "\tMaximum Size = " << rl.rlim_max << std::endl; + std::cerr << "\tDesired Size = " << desired_stack_size << std::endl; + exit(-1); + } + std::signal(SIGINT, HandleSigInt); dreal::MainProgram main_program{argc, argv}; return main_program.Run(); From 75017a5aec9a5defeddd680af47d18d0fd7c49e1 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 1 May 2025 02:32:53 -0700 Subject: [PATCH 66/79] Rotate pattern matching "starting" variable in parent vector to avoid biasing towards beginning due to timeout. --- .../pattern_matching/pattern_matching_trie_expr.cc | 10 +++++++++- .../pattern_matching/pattern_matching_trie_form.cc | 10 +++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc index 6ad1e7b10..7dc100c46 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc @@ -44,7 +44,15 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E VISIT_DECL(VisitVariable) { const auto& e = get_variable(_e); - for (auto& node : parent.c(ExpressionKind::Var)) { + + static unsigned variable_indexer_offset = 0; + const unsigned offset = variable_indexer_offset++; + + // for (auto& node : parent.c(ExpressionKind::Var)) { + const auto& pcekv = parent.c(ExpressionKind::Var); // its a vector + for (size_t i = 0; i < pcekv.size(); i++) { + auto& node = pcekv[(i + offset) % pcekv.size()]; + substitutions.push(); const auto& matched_e = get_variable(*node.leaf); diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index e95382075..151f95010 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -95,7 +95,15 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form VISIT_DECL(VisitVariable) { const auto& f = get_variable(_f); - for (auto& node : parent.c(FormulaKind::Var)) { + + static unsigned variable_indexer_offset = 0; + const unsigned offset = variable_indexer_offset++; + + // for (auto& node : parent.c(FormulaKind::Var)) { + const auto& pcekv = parent.c(FormulaKind::Var); // its a vector + for (size_t i = 0; i < pcekv.size(); i++) { + auto& node = pcekv[(i + offset) % pcekv.size()]; + substitutions.push(); const auto& matched_f = get_variable(*node.leaf); From ae4312bf78de9b3344f1740db932b847c01672db Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 1 May 2025 02:34:56 -0700 Subject: [PATCH 67/79] Tweak PM filtering for ODEs. --- src/dreal/solver/context_impl.cc | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 0cf92a0d0..84cd8eb37 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -337,8 +337,10 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL static_assert(pattern_matching_mode == 2); if (true - && explanation.size() < 384 /* stack overflows around size=960 on x86 */ - && tscs_elapsed > std::chrono::milliseconds(3) + // && explanation.size() < 384 /* stack overflows around size=960 on x86 */ + // && tscs_elapsed > std::chrono::milliseconds(3) + && explanation.size() < 32 /* stack overflows around size=960 on x86 */ + // && tscs_elapsed > std::chrono::milliseconds(3) ) { #endif #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME From 4ab2e9076fc62f975ac687929b9a27f2596a1873 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 8 May 2025 10:56:30 -0700 Subject: [PATCH 68/79] Remove unused case from find_matches(). --- .../util/pattern_matching/pattern_matching_trie_general.cc | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index 0a3341f7c..b31372dee 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -74,10 +74,6 @@ namespace dreal return; } - if (it1 == iend) { - DREAL_ASSERT(literals.size() == 1); - return all_literals_match(s2); - } auto it2 = it1; ++it2; stats.partial_matches++; From 93021020283031b00b27b49a8ef89a97305180c6 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 8 May 2025 12:19:18 -0700 Subject: [PATCH 69/79] Revert "Rotate pattern matching "starting" variable in parent vector to avoid biasing towards beginning due to timeout." This reverts commit 75017a5aec9a5defeddd680af47d18d0fd7c49e1. --- .../pattern_matching/pattern_matching_trie_expr.cc | 10 +--------- .../pattern_matching/pattern_matching_trie_form.cc | 10 +--------- 2 files changed, 2 insertions(+), 18 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc index 7dc100c46..6ad1e7b10 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc @@ -44,15 +44,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E VISIT_DECL(VisitVariable) { const auto& e = get_variable(_e); - - static unsigned variable_indexer_offset = 0; - const unsigned offset = variable_indexer_offset++; - - // for (auto& node : parent.c(ExpressionKind::Var)) { - const auto& pcekv = parent.c(ExpressionKind::Var); // its a vector - for (size_t i = 0; i < pcekv.size(); i++) { - auto& node = pcekv[(i + offset) % pcekv.size()]; - + for (auto& node : parent.c(ExpressionKind::Var)) { substitutions.push(); const auto& matched_e = get_variable(*node.leaf); diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index 151f95010..e95382075 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -95,15 +95,7 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form VISIT_DECL(VisitVariable) { const auto& f = get_variable(_f); - - static unsigned variable_indexer_offset = 0; - const unsigned offset = variable_indexer_offset++; - - // for (auto& node : parent.c(FormulaKind::Var)) { - const auto& pcekv = parent.c(FormulaKind::Var); // its a vector - for (size_t i = 0; i < pcekv.size(); i++) { - auto& node = pcekv[(i + offset) % pcekv.size()]; - + for (auto& node : parent.c(FormulaKind::Var)) { substitutions.push(); const auto& matched_f = get_variable(*node.leaf); From e56c31a6eb1fb7112b2f97c0c0a1e5adc91ca1c3 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 8 May 2025 12:24:47 -0700 Subject: [PATCH 70/79] Always `AddLearnedClauseUnboxed`, in all cases. --- src/dreal/solver/context_impl.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 84cd8eb37..2ae373738 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -399,6 +399,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #else static_assert(pattern_matching_mode != 0); sat_solver->AddLearnedClause(pn_, explanation, box); + sat_solver->AddLearnedClauseUnboxed(explanation); #endif } //////////////////////////////////////////////////////////////////////////////// From 6d10c9e19c4d1f4d7fc5eee768f8ecd5118b03de Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Thu, 8 May 2025 12:39:53 -0700 Subject: [PATCH 71/79] Always `AddLearnedClauseUnboxed`, in all cases. --- src/dreal/solver/context_impl.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index 2ae373738..d45b5608d 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -398,7 +398,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, sat_solver->AddLearnedClauseUnboxed(explanation); #else static_assert(pattern_matching_mode != 0); - sat_solver->AddLearnedClause(pn_, explanation, box); + // sat_solver->AddLearnedClause(pn_, explanation, box); sat_solver->AddLearnedClauseUnboxed(explanation); #endif } From c6d544acae02f24a920a32fa35597cf65badacc0 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 13 May 2025 15:42:14 -0700 Subject: [PATCH 72/79] Add labels to theory auditor. --- src/dreal/solver/auditor.cc | 11 ++++--- src/dreal/solver/auditor.h | 3 +- src/dreal/solver/sat_solver_interval_logic.cc | 29 ++++++++++--------- 3 files changed, 24 insertions(+), 19 deletions(-) diff --git a/src/dreal/solver/auditor.cc b/src/dreal/solver/auditor.cc index 612c527a7..aa83c1e50 100644 --- a/src/dreal/solver/auditor.cc +++ b/src/dreal/solver/auditor.cc @@ -50,7 +50,10 @@ namespace dreal literal_log_clause.clear(); } - void theory_audit_literals(const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box) { + void theory_audit_literals( + const std::string& label, + const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box + ) { // the operands passed here are expensive to produce, so really shouldn't be called unnecessarily. DREAL_ASSERT(DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED); @@ -69,10 +72,10 @@ namespace dreal // else ... the variable is probably, actually, a BOOL such as `DigitalPDController_0__omega_sensor_bit0__t0ad` } } - theory_audit_formula(make_disjunction(lits), box); + theory_audit_formula(label, make_disjunction(lits), box); } - void theory_audit_formula(const Formula& formula, const std::optional& box) { + void theory_audit_formula(const std::string& label, const Formula& formula, const std::optional& box) { // the operands passed here are expensive to produce, so really shouldn't be called unnecessarily. DREAL_ASSERT(DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED); @@ -81,7 +84,7 @@ namespace dreal std::string lemma_comment; { std::ostringstream s; - s << ";\t∀ "; + s << ";\t" << label << "\t∀ "; for (const auto& v : vs) { s << v; if (box) s << "∈" << (*box)[v]; diff --git a/src/dreal/solver/auditor.h b/src/dreal/solver/auditor.h index 570efd653..1c6a2994b 100644 --- a/src/dreal/solver/auditor.h +++ b/src/dreal/solver/auditor.h @@ -17,10 +17,11 @@ namespace dreal void sat_log_literal0(); void theory_audit_literals( + const std::string& label, const PredicateAbstractor& pa, /*copy*/ std::vector lits, const std::optional& box ); - void theory_audit_formula(const Formula& formula, const std::optional& box); + void theory_audit_formula(const std::string& label, const Formula& formula, const std::optional& box); } #endif //AUDITOR_H diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 7e095fc1f..657f23c57 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -25,7 +25,7 @@ namespace dreal if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { std::vector a; for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); - theory_audit_literals(predicate_abstractor_, a, {}); + theory_audit_literals("AddLearnedClauseUnboxed", predicate_abstractor_, a, {}); } } @@ -115,12 +115,12 @@ namespace dreal sat_log_literal0(); if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { - theory_audit_formula(!make_conjunction(conflicting_conjunction), unfitted_box); + theory_audit_formula("AddLearnedClause - Formula", !make_conjunction(conflicting_conjunction), unfitted_box); std::vector a; for (const auto& lit : lhs_implies) a.emplace_back(lit); // ==> for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); - theory_audit_literals(predicate_abstractor_, a, {}); + theory_audit_literals("AddLearnedClause - Literals", predicate_abstractor_, a, {}); } } @@ -155,13 +155,14 @@ namespace dreal for (const auto& [conflict_clause, subs] : all_related_conflicts) { const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); - if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { - std::set conflict_clause_set(conflict_clause.begin(), conflict_clause.end()); - theory_audit_formula( - !make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(conflict_clause_set)), - conflict_box - ); - } + if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { + std::set s(base_conflict.begin(), base_conflict.end()); + theory_audit_formula( + "AddLearnedClausePattern", + !make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(s)), + base_box // conflict_box + ); + } AddLearnedClause(pn, conflict_clause, conflict_box); } @@ -285,8 +286,8 @@ namespace dreal sat_log_literal0(); if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { - theory_audit_literals(predicate_abstractor_, {!lb, !inv_lb}, {}); - theory_audit_literals(predicate_abstractor_, {lb, inv_lb}, {}); + theory_audit_literals("MakeSatIntervalVarWithClauses - lb neg", predicate_abstractor_, {!lb, !inv_lb}, {}); + theory_audit_literals("MakeSatIntervalVarWithClauses - lb pos",predicate_abstractor_, {lb, inv_lb}, {}); } } @@ -310,8 +311,8 @@ namespace dreal sat_log_literal0(); if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { - theory_audit_literals(predicate_abstractor_, {!ub, !inv_ub}, {}); - theory_audit_literals(predicate_abstractor_, {ub, inv_ub}, {}); + theory_audit_literals("MakeSatIntervalVarWithClauses - ub neg", predicate_abstractor_, {!ub, !inv_ub}, {}); + theory_audit_literals("MakeSatIntervalVarWithClauses - ub pos", predicate_abstractor_, {ub, inv_ub}, {}); } } From 2e748212fdde8906ae78c0e7a741398fc3529348 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 13 May 2025 17:18:44 -0700 Subject: [PATCH 73/79] Remove SAT inverval behavior from pattern matching. --- .idea/.gitignore | 8 - .idea/.name | 1 - .idea/dreal4-cmake.iml | 8 - .idea/editor.xml | 490 ------------------ .idea/inspectionProfiles/Project_Default.xml | 19 - .idea/misc.xml | 20 - .idea/modules.xml | 8 - .idea/vcs.xml | 6 - src/dreal/solver/context_impl.cc | 18 +- src/dreal/solver/sat_solver.h | 6 +- src/dreal/solver/sat_solver_interval_logic.cc | 32 +- .../pattern_matching/pattern_matching_trie.h | 41 +- .../pattern_matching_trie_expr.cc | 31 +- .../pattern_matching_trie_form.cc | 31 +- .../pattern_matching_trie_general.cc | 52 +- .../pattern_matching/substitutions_map.cc | 50 +- .../util/pattern_matching/substitutions_map.h | 22 +- src/dreal/util/predicate_normalizer.cc | 4 +- src/dreal/util/predicate_normalizer.h | 2 +- src/dreal/version.h | 2 + .../solver/test/sat_solver_inteveral_test.cc | 186 +++---- test/dreal/test/smt2/test.py | 39 +- test/dreal/util/test/pattern_matching_test.cc | 8 +- 23 files changed, 276 insertions(+), 808 deletions(-) delete mode 100644 .idea/.gitignore delete mode 100644 .idea/.name delete mode 100644 .idea/dreal4-cmake.iml delete mode 100644 .idea/editor.xml delete mode 100644 .idea/inspectionProfiles/Project_Default.xml delete mode 100644 .idea/misc.xml delete mode 100644 .idea/modules.xml delete mode 100644 .idea/vcs.xml diff --git a/.idea/.gitignore b/.idea/.gitignore deleted file mode 100644 index 13566b81b..000000000 --- a/.idea/.gitignore +++ /dev/null @@ -1,8 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml -# Editor-based HTTP Client requests -/httpRequests/ -# Datasource local storage ignored files -/dataSources/ -/dataSources.local.xml diff --git a/.idea/.name b/.idea/.name deleted file mode 100644 index b2d597b9e..000000000 --- a/.idea/.name +++ /dev/null @@ -1 +0,0 @@ -dreal4_cmake \ No newline at end of file diff --git a/.idea/dreal4-cmake.iml b/.idea/dreal4-cmake.iml deleted file mode 100644 index bd985f000..000000000 --- a/.idea/dreal4-cmake.iml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/editor.xml b/.idea/editor.xml deleted file mode 100644 index 2b1d539e7..000000000 --- a/.idea/editor.xml +++ /dev/null @@ -1,490 +0,0 @@ - - - - - \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml deleted file mode 100644 index 290b57bbb..000000000 --- a/.idea/inspectionProfiles/Project_Default.xml +++ /dev/null @@ -1,19 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100644 index 0f57ff474..000000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,20 +0,0 @@ - - - - - - - - - - - - - - - - - {} - \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index 9a30b535e..000000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 35eb1ddfb..000000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index d45b5608d..f0164c3c5 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -117,6 +117,7 @@ void Context::Impl::Assert(const Formula& f) { for (const auto& operand : get_operands(f)) Assert(operand); return; } + // if (true) { if (!FilterAssertion(f, &box()).filtered) { DREAL_LOG_DEBUG("ContextImpl::Assert: {} is added.", f); IfThenElseEliminator ite_eliminator; @@ -203,10 +204,10 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, #endif //////////////////////////////////////////////////////////////////////////////// -#ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE - static_assert(pattern_matching_mode != 0); - sat_solver->AddBox(pn_, box); -#endif +// #ifndef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE +// static_assert(pattern_matching_mode != 0); +// sat_solver->AddBox(pn_, box); +// #endif //////////////////////////////////////////////////////////////////////////////// for (const auto & variable : box.variables()) { @@ -339,7 +340,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, if (true // && explanation.size() < 384 /* stack overflows around size=960 on x86 */ // && tscs_elapsed > std::chrono::milliseconds(3) - && explanation.size() < 32 /* stack overflows around size=960 on x86 */ + && explanation.size() < DREAL_EXPERIMENTAL_PATTERN_MATCH_SIZE_THRESH /* stack overflows around size=960 on x86 */ // && tscs_elapsed > std::chrono::milliseconds(3) ) { #endif @@ -393,14 +394,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, std::cerr << ".\tAdding 1 size " << explanation.size() << " directly.\t"; std::cerr << "TSCS " << tscs_elapsed.count() << " ms.\t"; std::cerr << "Fully constrained = " << is_full_constrained << std::endl; -#ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE - static_assert(pattern_matching_mode == 0); sat_solver->AddLearnedClauseUnboxed(explanation); -#else - static_assert(pattern_matching_mode != 0); - // sat_solver->AddLearnedClause(pn_, explanation, box); - sat_solver->AddLearnedClauseUnboxed(explanation); -#endif } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/dreal/solver/sat_solver.h b/src/dreal/solver/sat_solver.h index 468d49e26..c006feaef 100644 --- a/src/dreal/solver/sat_solver.h +++ b/src/dreal/solver/sat_solver.h @@ -71,7 +71,7 @@ class SatSolver : public CaDiCaL::Learner { /// the solver. void AddLearnedClauseUnboxed(const std::vector& conflicting_conjunction); - void AddLearnedClause(PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& box); + // void AddLearnedClause(PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& box); PatternMatchingTrie::matching_stats_t AddLearnedClausePattern( PredicateNormalizer& pn, @@ -79,9 +79,9 @@ class SatSolver : public CaDiCaL::Learner { const Box& base_box, std::chrono::duration timeout); std::pair MakeSatUbVar(PredicateNormalizer& pn, const Variable& var, double ub, bool inclusive); std::pair MakeSatLbVar(PredicateNormalizer& pn, const Variable& var, double lb, bool inclusive); - void AddBox(PredicateNormalizer& pn, const Box& base_box); + // void AddBox(PredicateNormalizer& pn, const Box& base_box); - Formula MakeSatIntervalVarWithClauses(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv); + // Formula MakeSatIntervalVarWithClauses(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv); /// Checks the satisfiability of the current configuration. /// diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index 657f23c57..d51e36fdc 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -29,17 +29,17 @@ namespace dreal } } - void FlattenIntervalClause(const Formula& intv, const std::function& f) { - if (is_true(intv)) { /* no-op */ } + /*void FlattenIntervalClause(const Formula& intv, const std::function& f) { + if (is_true(intv)) { /* no-op #1# } else if (is_conjunction(intv)) { const auto ops = get_operands(intv); DREAL_ASSERT(ops.size() == 2); for (const auto& op : ops) f(op); } else f(intv); - } + }*/ - void SatSolver::AddLearnedClause( + /*void SatSolver::AddLearnedClause( PredicateNormalizer& pn, const std::vector& conflicting_conjunction, const Box& unfitted_box ) { @@ -92,7 +92,7 @@ namespace dreal // e.g. `((5 + 6 * x + 2 * pow(x, 2)) < 0)` could end up here } else - DREAL_UNREACHABLE();*/ + DREAL_UNREACHABLE();#1# } // a & b & c & ... ==> ~(x & y & z & ...) @@ -122,9 +122,9 @@ namespace dreal for (const Formula& f : conflicting_conjunction) a.emplace_back(!predicate_abstractor_.Convert(f)); theory_audit_literals("AddLearnedClause - Literals", predicate_abstractor_, a, {}); } - } + }*/ - void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { + /*void SatSolver::AddBox(PredicateNormalizer& pn, const Box& base_box) { sat_log_label_clause("SatSolver::AddBox"); for (const auto& v : base_box.variables()) { const auto condition = MakeSatIntervalVarWithClauses(pn, v, base_box[v]); @@ -134,7 +134,7 @@ namespace dreal sat_log_literal0(); }); } - } + }*/ PatternMatchingTrie::matching_stats_t SatSolver::AddLearnedClausePattern( PredicateNormalizer& pn, @@ -146,14 +146,13 @@ namespace dreal const auto [ all_related_conflicts, match_statistics - ] = pn.FindSimilar(base_conflict, timeout); + ] = pn.FindSimilar(base_conflict, base_box, timeout); if (all_related_conflicts.empty()) { DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); return match_statistics; } - - for (const auto& [conflict_clause, subs] : all_related_conflicts) { - const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); + if (match_statistics.misses.bc_box) + DREAL_LOG_INFO("Rejected {} matches due to box-missmatch.", match_statistics.misses.bc_box); if (DREAL_EXPERIMENTAL_THEORY_AUDIT_ENABLED) { std::set s(base_conflict.begin(), base_conflict.end()); @@ -164,7 +163,10 @@ namespace dreal ); } - AddLearnedClause(pn, conflict_clause, conflict_box); + for (const auto& [conflict_clause, subs] : all_related_conflicts) { + // const auto conflict_box = substitutions_map::apply_substitution(base_box, subs, true); + // AddLearnedClause(pn, conflict_clause, conflict_box); + AddLearnedClauseUnboxed(conflict_clause); } return match_statistics; } @@ -253,7 +255,7 @@ namespace dreal return {lb_pred, false}; } - Formula SatSolver::MakeSatIntervalVarWithClauses(PredicateNormalizer& pn, const Variable& var, + /*Formula SatSolver::MakeSatIntervalVarWithClauses(PredicateNormalizer& pn, const Variable& var, const Box::Interval& intv) { DREAL_LOG_DEBUG("SatSolver::MakeSatIntervalVarWithClauses({} ∈ {})", fmt::streamed(var), fmt::streamed(intv)); @@ -317,7 +319,7 @@ namespace dreal } return lb && ub; - } + }*/ bool SatSolver::learning(const int size) { buffer_i = 0; diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index 221d88930..889a8b779 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -19,7 +19,13 @@ namespace dreal public: typedef struct { - unsigned misses; + struct + { + unsigned bc_type; + unsigned bc_box; + unsigned bc_bij; + unsigned bc_const; + } misses; unsigned partial_matches; unsigned matches; } matching_stats_t; @@ -38,7 +44,7 @@ namespace dreal [[nodiscard]] std::pair, substitutions_map>>, matching_stats_t> find_matches( const std::vector& literals, - std::chrono::duration timeout = std::chrono::microseconds{-1} + const Box& b, std::chrono::duration timeout = std::chrono::microseconds{-1} ) const; [[nodiscard]] std::pair>, matching_stats_t> find_matches( @@ -47,9 +53,9 @@ namespace dreal ) const; [[nodiscard]] std::pair>, matching_stats_t> find_matches( - const Formula& f + const Formula& f, const Box &box ) const { - substitutions_map s(f.GetFreeVariables().size()); + substitutions_map s(box, f.GetFreeVariables().size()); return find_matches(f, s); } @@ -59,9 +65,9 @@ namespace dreal ) const; [[nodiscard]] std::pair>, matching_stats_t> find_matches( - const Expression& e + const Expression& e, const Box &b ) const { - substitutions_map s(e.GetVariables().size()); + substitutions_map s(b, e.GetVariables().size()); return find_matches(e, s); } @@ -182,8 +188,8 @@ namespace dreal using f_partial_matches_vec = std::function; using f_est_continuation_vec = std::function; - using e_misses_vec = std::function; - using f_misses_vec = std::function; + using e_misses_vec = std::function; + using f_misses_vec = std::function; #define PM_CONT_LAMBDA(n,s) [&](const auto &n, auto &s) #define EST_CONT_LAMBDA(n) [&](const auto &n) @@ -381,12 +387,19 @@ namespace dreal ); }; - inline std::ostream& operator<<(std::ostream& os, const PatternMatchingTrie::matching_stats_t& stats) { - os << stats.misses << ','; - os << stats.partial_matches << ','; - os << stats.matches; - return os; - } + // inline std::ostream& operator<<(std::ostream& os, const PatternMatchingTrie::matching_stats_t& stats) { + // os << "matching_stats_t {\n" + // << " misses {\n" + // << " bc_type: " << stats.misses.bc_type << ",\n" + // << " bc_box: " << stats.misses.bc_box << ",\n" + // << " bc_bij: " << stats.misses.bc_bij << ",\n" + // << " bc_const: " << stats.misses.bc_const << "\n" + // << " },\n" + // << " partial_matches: " << stats.partial_matches << ",\n" + // << " matches: " << stats.matches << "\n" + // << "}"; + // return os; + // } } // namespace dreal diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc index 6ad1e7b10..e78309273 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc @@ -48,22 +48,23 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E substitutions.push(); const auto& matched_e = get_variable(*node.leaf); - if (!substitutions.attempt_substitution(matched_e, e)) + if ( + substitutions_map::substitution_status reason; + (reason = substitutions.attempt_substitution(matched_e, e)) + != substitutions_map::SUCCESS + ) // type check failed // or match already substituted for something else, stop. - misses(substitutions); + misses(reason); else if (!node.terminal_expression.has_value()) // partial match, keep going! partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) + else // terminal match! BINGO! matches(*node.terminal_expression, substitutions); - else - misses(substitutions); - substitutions.pop(); } } @@ -88,13 +89,11 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E for (auto& node : parent.c(ExpressionKind::Constant)) { const auto& matched_e = get_constant_value(*node.leaf); if (e != matched_e) - misses(substitutions); + misses(substitutions_map::CONST_MISS); else if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) - matches(*node.terminal_expression, substitutions); else - misses(substitutions); + matches(*node.terminal_expression, substitutions); } } @@ -118,13 +117,11 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E for (auto& node : parent.c(ExpressionKind::RealConstant)) { const auto& matched_e = to_real_constant(*node.leaf); if (!e->EqualTo(*matched_e) /* confirmed non-recursive, simple one-liner */) - misses(substitutions); + misses(substitutions_map::CONST_MISS); else if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) - matches(*node.terminal_expression, substitutions); else - misses(substitutions); + matches(*node.terminal_expression, substitutions); } } @@ -558,13 +555,11 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E for (auto& node : parent.c(ExpressionKind::UninterpretedFunction)) { const auto& matched_e = to_uninterpreted_function(*node.leaf); if (!e->EqualTo(*matched_e) /*confirmed non-recursive, simple one-liner*/) - misses(substitutions); + misses(substitutions_map::CONST_MISS); else if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) - matches(*node.terminal_expression, substitutions); else - misses(substitutions); + matches(*node.terminal_expression, substitutions); } } #undef VISIT_DECL diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index e95382075..e8a8d0c0e 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -43,10 +43,8 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form for (auto& node : parent.c(FormulaKind::False)) { if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) - matches(*node.terminal_expression, substitutions); else - misses(substitutions); + matches(*node.terminal_expression, substitutions); } } @@ -69,10 +67,8 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form for (auto& node : parent.c(FormulaKind::True)) { if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) - matches(*node.terminal_expression, substitutions); else - misses(substitutions); + matches(*node.terminal_expression, substitutions); } } @@ -99,22 +95,23 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form substitutions.push(); const auto& matched_f = get_variable(*node.leaf); - if (!substitutions.attempt_substitution(matched_f, f)) + if ( + substitutions_map::substitution_status reason; + (reason = substitutions.attempt_substitution(matched_f, f)) + != substitutions_map::SUCCESS + ) // type check failed // or match already substituted for something else, stop. - misses(substitutions); + misses(reason); else if (!node.terminal_expression.has_value()) // partial match, keep going! partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) + else // terminal match! BINGO! matches(*node.terminal_expression, substitutions); - else - misses(substitutions); - substitutions.pop(); } } @@ -165,10 +162,8 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form recMatchExpr(get_rhs_expression(_f), n2, s2, e_matches, PM_CONT_LAMBDA(n3, s3) { if (!n3.switch_kind->terminal_expression.has_value()) partial_matches(*n3.switch_kind, s3); - else if (substitutions_map::verify_substitutions(s3)) - matches(*n3.switch_kind->terminal_expression, s3); else - misses(s3); + matches(*n3.switch_kind->terminal_expression, s3); }, misses); }, misses); } @@ -343,13 +338,11 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form for (auto& node : parent.c(FormulaKind::Forall)) { const auto& matched_f = to_forall(*node.leaf); if (!f->EqualTo(*matched_f)) - misses(substitutions); + misses(substitutions_map::CONST_MISS); else if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); - else if (substitutions_map::verify_substitutions(substitutions)) - matches(*node.terminal_expression, substitutions); else - misses(substitutions); + matches(*node.terminal_expression, substitutions); } } #undef VISIT_DECL diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc index b31372dee..b339a9f76 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_general.cc @@ -14,9 +14,20 @@ namespace dreal { + void handle_misses_reason( + PatternMatchingTrie::matching_stats_t& stats, + const substitutions_map::substitution_status& status + ) { + // TYPE_MISS, BOX_MISS, BIJ_MISS, CONST_MISS + if (status == substitutions_map::TYPE_MISS) stats.misses.bc_type++; + if (status == substitutions_map::BOX_MISS) stats.misses.bc_box++; + if (status == substitutions_map::BIJ_MISS) stats.misses.bc_bij++; + if (status == substitutions_map::CONST_MISS) stats.misses.bc_const++; + } + std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> PatternMatchingTrie::find_matches( - const std::vector& literals, + const std::vector& literals, const Box& box, const std::chrono::duration timeout ) const { matching_stats_t stats = {0}; @@ -26,25 +37,11 @@ namespace dreal const auto start_time = std::chrono::steady_clock::now(); - const f_misses_vec misses = [&](const auto& _) { - stats.misses++; - }; + const f_misses_vec misses = [&](const auto& reason) { handle_misses_reason(stats, reason); }; const f_partial_matches_vec partial_matches = PM_CONT_LAMBDA(n, s) { DREAL_LOG_ERROR("Unterminated partial matching?"); DREAL_UNREACHABLE(); // everything should AT LEAST match itself !?!?! }; - const f_misses_vec all_literals_match = [&](const auto& s) { - DREAL_ASSERT(matches_vec.size() == literals.size()); - // todo: GATE THIS USING THE SAME FLAG AS AUDIT MODE. - // if (DREAL_LOG_DEBUG_ENABLED) - // for (const auto& lit : matches_vec) { - // DREAL_ASSERT(literals.count( - // substitutions_map::apply_substitution(lit, s, false) - // ) == 1); - // } - stats.matches++; - result.emplace_back(matches_vec, s); - }; bool did_time_out = false; @@ -77,7 +74,18 @@ namespace dreal auto it2 = it1; ++it2; stats.partial_matches++; - if (it2 == iend) all_literals_match(s2); + if (it2 == iend) { + DREAL_ASSERT(matches_vec.size() == literals.size()); + // todo: GATE THIS USING THE SAME FLAG AS AUDIT MODE. + // if (DREAL_LOG_DEBUG_ENABLED) + // for (const auto& lit : matches_vec) { + // DREAL_ASSERT(literals.count( + // substitutions_map::apply_substitution(lit, s, false) + // ) == 1); + // } + stats.matches++; + result.emplace_back(matches_vec, s2); + } else recMatchForm(*it2, f_root, s2, match_next_literal(it2), partial_matches, misses); matches_vec.pop_back(); }; @@ -85,16 +93,12 @@ namespace dreal size_t sub_preallocations = 0; for (const auto& literal : literals) sub_preallocations += literal.GetFreeVariables().size(); - substitutions_map substitutions(sub_preallocations); + substitutions_map substitutions(box, sub_preallocations); recMatchForm(*ibegin, f_root, substitutions, match_next_literal(ibegin), partial_matches, misses); DREAL_ASSERT(result.size() == stats.matches); if (did_time_out) DREAL_LOG_INFO("Pattern matching timed out after {} usec.", timeout.count()); - DREAL_LOG_DEBUG( - "Found {} matches of size {} with {} misses.", - stats.matches, literals.size(), stats.misses - ); // if (DREAL_LOG_INFO_ENABLED) { // for (const auto& [matched_clause, _] : result) { // std::ostringstream s; @@ -126,7 +130,7 @@ namespace dreal stats.partial_matches++; DREAL_LOG_ERROR("Unterminated partial matching? Not sure if this should ever be reachable."); }, - [&](const auto& s) { stats.misses++; } + [&](const auto& reason) { handle_misses_reason(stats, reason); } ); DREAL_ASSERT(substitutions.size() == init_size); return {match_vec, stats}; @@ -151,7 +155,7 @@ namespace dreal stats.partial_matches++; DREAL_LOG_ERROR("Unterminated partial matching? Not sure if this should ever be reachable."); }, - [&](const auto& s) { stats.misses++; } + [&](const auto& reason) { handle_misses_reason(stats, reason); } ); DREAL_ASSERT(substitutions.size() == init_size); return {match_vec, stats}; diff --git a/src/dreal/util/pattern_matching/substitutions_map.cc b/src/dreal/util/pattern_matching/substitutions_map.cc index 76b1c7217..3936116f4 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.cc +++ b/src/dreal/util/pattern_matching/substitutions_map.cc @@ -5,34 +5,36 @@ #include "substitutions_map.h" #include +#include #include #include namespace dreal { - substitutions_map::substitutions_map() { + substitutions_map::substitutions_map(const Box& b, const size_t reserved_size): box(b) { fwd.max_load_factor(0.25); bwd.max_load_factor(0.25); - } - - substitutions_map::substitutions_map(const size_t reserved_size) : substitutions_map() { reserve(reserved_size); } + // substitutions_map::substitutions_map(const size_t reserved_size) : substitutions_map() { + // reserve(reserved_size); + // } + // "forward" takes the matched and maps it to original // "backward" takes original and maps it to matched - Box substitutions_map::apply_substitution( - const Box& b, const substitutions_map& subs, bool backward - ) { - Box new_b; - const auto& map = backward ? subs.bwd : subs.fwd; - for (const auto& [a,aP] : map) { - // if (new_b.has_variable(aP)) continue; - const auto& ba = b[a]; - new_b.Add(aP, ba.lb(), ba.ub()); - } - return new_b; - } + // Box substitutions_map::apply_substitution( + // const Box& b, const substitutions_map& subs, bool backward + // ) { + // Box new_b; + // const auto& map = backward ? subs.bwd : subs.fwd; + // for (const auto& [a,aP] : map) { + // // if (new_b.has_variable(aP)) continue; + // const auto& ba = b[a]; + // new_b.Add(aP, ba.lb(), ba.ub()); + // } + // return new_b; + // } void substitutions_map::push() { insertion_stack.emplace_back(); @@ -48,8 +50,14 @@ namespace dreal insertion_stack.pop_back(); } - bool substitutions_map::attempt_substitution(const Variable& a, const Variable& aP) { - if (a.get_type() != aP.get_type()) return false; + substitutions_map::substitution_status substitutions_map::attempt_substitution( + const Variable& a, const Variable& aP + ) { + if (a.get_type() != aP.get_type()) return TYPE_MISS; + if (box[a] != box[aP]) { + // todo: subset / superset ? + return BOX_MISS; + } const auto it_a = fwd.find(a); const auto it_aP = bwd.find(aP); @@ -60,7 +68,7 @@ namespace dreal fwd.try_emplace(a, aP); bwd.try_emplace(aP, a); insertion_stack.back().emplace_back(a, aP); - return true; + return SUCCESS; } if ( @@ -68,7 +76,7 @@ namespace dreal it_a->second.equal_to(aP) && it_aP->second.equal_to(a) ) { - return true; + return SUCCESS; } DREAL_LOG_TRACE( @@ -78,7 +86,7 @@ namespace dreal aP.get_name(), has_a ? it_a->second.get_name() : "unmapped" ); - return false; + return BIJ_MISS; } // this is literally the hottest function in the entire code rn, when we pattern match aggressively. -KS diff --git a/src/dreal/util/pattern_matching/substitutions_map.h b/src/dreal/util/pattern_matching/substitutions_map.h index b896dd0d7..cad1cb22f 100644 --- a/src/dreal/util/pattern_matching/substitutions_map.h +++ b/src/dreal/util/pattern_matching/substitutions_map.h @@ -16,13 +16,16 @@ namespace dreal std::unordered_map fwd; std::unordered_map bwd; std::vector>> insertion_stack{1}; + const Box &box; public: const std::unordered_map& get_map() const { return fwd; } const std::vector>& get_current_frame() const { return insertion_stack.back(); } - substitutions_map(); - explicit substitutions_map(size_t reserve); + // substitutions_map(); + // explicit substitutions_map(Box b); + // explicit substitutions_map(size_t reserve); + substitutions_map(const Box &b, size_t reserved_size); // "forward" takes the matched and maps it to original // "backward" takes original and maps it to matched @@ -42,22 +45,25 @@ namespace dreal return f.Substitute(esub, fsub); } - [[nodiscard]] static Box apply_substitution( - const Box& b, const substitutions_map& subs, bool backward = false - ); + // [[nodiscard]] static Box apply_substitution( + // const Box& b, const substitutions_map& subs, bool backward = false + // ); void push(); void pop(); - bool attempt_substitution(const Variable& a, const Variable& aP); + typedef enum + { + SUCCESS, TYPE_MISS, BOX_MISS, BIJ_MISS, CONST_MISS + } substitution_status; + + substitution_status attempt_substitution(const Variable& a, const Variable& aP); size_t size() const; void reserve(size_t n); - static bool verify_substitutions(const substitutions_map& subs) { return true; } // legacy - friend bool operator==(const substitutions_map& lhs, const substitutions_map& rhs); friend bool operator!=(const substitutions_map& lhs, const substitutions_map& rhs) { return !(lhs == rhs); } diff --git a/src/dreal/util/predicate_normalizer.cc b/src/dreal/util/predicate_normalizer.cc index eb9fdaf81..de7ac2a6c 100644 --- a/src/dreal/util/predicate_normalizer.cc +++ b/src/dreal/util/predicate_normalizer.cc @@ -22,7 +22,7 @@ namespace dreal { std::pair, substitutions_map>>, PatternMatchingTrie::matching_stats_t> PredicateNormalizer::FindSimilar( - const std::vector& ordered_clause, + const std::vector& ordered_clause, const Box &box, const std::chrono::duration timeout ) const { if (DREAL_LOG_DEBUG_ENABLED) { @@ -39,7 +39,7 @@ namespace dreal // Learned clauses MUST be a collection of normalized literals. DREAL_ASSERT(is_equal_to(atom) || is_less_than(atom) || is_less_than_or_equal_to(atom) || is_forall(atom)); } - return trie.find_matches(ordered_clause, timeout); + return trie.find_matches(ordered_clause, box, timeout); } // ended up being completely friggen useless lol :( diff --git a/src/dreal/util/predicate_normalizer.h b/src/dreal/util/predicate_normalizer.h index 42e520e10..47c30e9b6 100644 --- a/src/dreal/util/predicate_normalizer.h +++ b/src/dreal/util/predicate_normalizer.h @@ -35,7 +35,7 @@ namespace dreal > FindSimilar( const std::vector& ordered_clause, - std::chrono::duration timeout = std::chrono::microseconds{-1} + const Box& b, std::chrono::duration timeout = std::chrono::microseconds{-1} ) const; // useless heuristic diff --git a/src/dreal/version.h b/src/dreal/version.h index 9e5cd2fa3..a1e730a3f 100644 --- a/src/dreal/version.h +++ b/src/dreal/version.h @@ -12,6 +12,8 @@ // #define DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME // #define DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_SIZE_THRESH 32 + #define DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS // #define DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS diff --git a/test/dreal/solver/test/sat_solver_inteveral_test.cc b/test/dreal/solver/test/sat_solver_inteveral_test.cc index ffb93c924..1c87acd26 100644 --- a/test/dreal/solver/test/sat_solver_inteveral_test.cc +++ b/test/dreal/solver/test/sat_solver_inteveral_test.cc @@ -1,93 +1,93 @@ -/* - Copyright 2017 Toyota Research Institute - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -*/ -#include - -#include "dreal/solver/filter_assertion.h" - -#include - -#include "dreal/symbolic/symbolic.h" - -namespace dreal -{ - namespace - { - class SatSolverIntervalTest : public ::testing::Test - { - protected: - void SetUp() override {} - Config c; - SatSolver s{c}; - PredicateNormalizer pn; - - const Variable x_{"x", Variable::Type::CONTINUOUS}; - const Variable y_{"y", Variable::Type::CONTINUOUS}; - const Variable z_{"z", Variable::Type::CONTINUOUS}; - }; - - TEST_F(SatSolverIntervalTest, Implication7) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-3, +4})); - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-4, +3})); - EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_TRUE(s.CheckSat()); - } - - TEST_F(SatSolverIntervalTest, Implication6) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +4})); - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-4, +2})); - EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_FALSE(s.CheckSat()); - } - - TEST_F(SatSolverIntervalTest, Implication5) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, -0})); - EXPECT_TRUE(s.CheckSat()); // todo: is this true?? (incl. vs. excl. 0) - s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_FALSE(s.CheckSat()); - } - - TEST_F(SatSolverIntervalTest, Implication4) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, y_, {+0, +2})); - EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_TRUE(s.CheckSat()); - } - - TEST_F(SatSolverIntervalTest, Implication3) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); - EXPECT_TRUE(s.CheckSat()); - } - - TEST_F(SatSolverIntervalTest, Implication2) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); - EXPECT_TRUE(s.CheckSat()); - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_TRUE(s.CheckSat()); - } - - TEST_F(SatSolverIntervalTest, Implication1) { - s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); - EXPECT_TRUE(s.CheckSat()); - s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); - EXPECT_FALSE(s.CheckSat()); - } - } // namespace -} // namespace dreal +// /* +// Copyright 2017 Toyota Research Institute +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// */ +// #include +// +// #include "dreal/solver/filter_assertion.h" +// +// #include +// +// #include "dreal/symbolic/symbolic.h" +// +// namespace dreal +// { +// namespace +// { +// class SatSolverIntervalTest : public ::testing::Test +// { +// protected: +// void SetUp() override {} +// Config c; +// SatSolver s{c}; +// PredicateNormalizer pn; +// +// const Variable x_{"x", Variable::Type::CONTINUOUS}; +// const Variable y_{"y", Variable::Type::CONTINUOUS}; +// const Variable z_{"z", Variable::Type::CONTINUOUS}; +// }; +// +// TEST_F(SatSolverIntervalTest, Implication7) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-3, +4})); +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-4, +3})); +// EXPECT_TRUE(s.CheckSat()); +// s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_TRUE(s.CheckSat()); +// } +// +// TEST_F(SatSolverIntervalTest, Implication6) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +4})); +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-4, +2})); +// EXPECT_TRUE(s.CheckSat()); +// s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_FALSE(s.CheckSat()); +// } +// +// TEST_F(SatSolverIntervalTest, Implication5) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, -0})); +// EXPECT_TRUE(s.CheckSat()); // todo: is this true?? (incl. vs. excl. 0) +// s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_FALSE(s.CheckSat()); +// } +// +// TEST_F(SatSolverIntervalTest, Implication4) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, y_, {+0, +2})); +// EXPECT_TRUE(s.CheckSat()); +// s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_TRUE(s.CheckSat()); +// } +// +// TEST_F(SatSolverIntervalTest, Implication3) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_TRUE(s.CheckSat()); +// s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); +// EXPECT_TRUE(s.CheckSat()); +// } +// +// TEST_F(SatSolverIntervalTest, Implication2) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); +// EXPECT_TRUE(s.CheckSat()); +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_TRUE(s.CheckSat()); +// } +// +// TEST_F(SatSolverIntervalTest, Implication1) { +// s.AddFormula(s.MakeSatIntervalVarWithClauses(pn, x_, {+0, +2})); +// EXPECT_TRUE(s.CheckSat()); +// s.AddFormula(!s.MakeSatIntervalVarWithClauses(pn, x_, {-2, +2})); +// EXPECT_FALSE(s.CheckSat()); +// } +// } // namespace +// } // namespace dreal diff --git a/test/dreal/test/smt2/test.py b/test/dreal/test/smt2/test.py index 169c8a95b..799fa862a 100644 --- a/test/dreal/test/smt2/test.py +++ b/test/dreal/test/smt2/test.py @@ -35,24 +35,35 @@ options = sys.argv[4:] with open(expected_output_filename, "r") as myfile: - expected_output = myfile.read().strip().splitlines() + expected_output = myfile.read().strip() try: # 1. Run dReal with smt2 file - output = subprocess.check_output([dreal, smt2] + options).decode('UTF-8') - output = output.splitlines() - print(output) - # 2. Compare the output with expected output - diff_result = list( - difflib.unified_diff(output, - expected_output, - fromfile='output', - tofile='expected output', - lineterm='')) - if diff_result: + output = subprocess.check_output([dreal, smt2] + options, stderr=subprocess.STDOUT).decode('UTF-8') + # output = output.splitlines() + # print(output) + # # 2. Compare the output with expected output + # diff_result = list( + # difflib.unified_diff(output, + # expected_output, + # fromfile='output', + # tofile='expected output', + # lineterm='')) + # if diff_result: + if expected_output not in output: + print() + print() + print("OUTPUT: ") + print(output) + print('v.s.') + print(f"EXPECTED ({expected_output_filename}) ") + print(expected_output) + print() + print() + # 3. They are not the same, show the diff. - for line in diff_result: - print(line) + # for line in diff_result: + # print(line) sys.exit(1) else: # 4. They are the same. diff --git a/test/dreal/util/test/pattern_matching_test.cc b/test/dreal/util/test/pattern_matching_test.cc index 3d58f10bc..36c2b4b4a 100644 --- a/test/dreal/util/test/pattern_matching_test.cc +++ b/test/dreal/util/test/pattern_matching_test.cc @@ -67,7 +67,7 @@ namespace dreal for (const auto& miss : misses1) trie.insert(miss); for (const auto& miss : misses2) trie.insert(miss); std::set found; - for (const auto& [form, subs] : trie.find_matches(pattern).first) { + for (const auto& [form, subs] : trie.find_matches(pattern, Box{}).first) { // check substitutions are correct and injective: EXPECT_TRUE(substitutions_map::apply_substitution(form, subs, false).EqualTo(pattern)); EXPECT_TRUE(substitutions_map::apply_substitution(pattern, subs, true).EqualTo(form)); @@ -105,7 +105,7 @@ namespace dreal }; for (const auto& lit : literals) trie.insert(lit); const auto [related_clauses, stats] = trie.find_matches( - {y1 == sin(x1), y1 == atan(x1)} + {y1 == sin(x1), y1 == atan(x1)}, Box{} ); EXPECT_EQ(stats.misses, 4); EXPECT_EQ(stats.matches, 2); @@ -545,12 +545,12 @@ namespace dreal pattern.Substitute({{x1, p1}, {x2, p2}}), }; for (const auto& match : matches) { - const auto found = trie.find_matches(match).first; + const auto found = trie.find_matches(match, Box{}).first; EXPECT_EQ(found.size(), 1); std::cout << pattern << " MATCHES " << match << std::endl; } for (const auto& miss : misses) { - const auto found = trie.find_matches(miss).first; + const auto found = trie.find_matches(miss, Box{}).first; EXPECT_EQ(found.size(), 0); std::cout << pattern << " MISSES " << miss << std::endl; } From 9a660e79553008f7950b2ef26f92fba5af6bb8d1 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 22 Jul 2025 00:23:12 -0700 Subject: [PATCH 74/79] Get rid of `EST` heuristic mess. --- .../pattern_matching/pattern_matching_trie.h | 48 +---- .../pattern_matching_trie_expr.cc | 184 ------------------ .../pattern_matching_trie_form.cc | 106 ---------- test/dreal/util/test/pattern_matching_test.cc | 2 +- 4 files changed, 6 insertions(+), 334 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index 889a8b779..2f57a2631 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -26,6 +26,7 @@ namespace dreal unsigned bc_bij; unsigned bc_const; } misses; + unsigned partial_matches; unsigned matches; } matching_stats_t; @@ -53,7 +54,7 @@ namespace dreal ) const; [[nodiscard]] std::pair>, matching_stats_t> find_matches( - const Formula& f, const Box &box + const Formula& f, const Box& box ) const { substitutions_map s(box, f.GetFreeVariables().size()); return find_matches(f, s); @@ -65,7 +66,7 @@ namespace dreal ) const; [[nodiscard]] std::pair>, matching_stats_t> find_matches( - const Expression& e, const Box &b + const Expression& e, const Box& b ) const { substitutions_map s(b, e.GetVariables().size()); return find_matches(e, s); @@ -202,11 +203,9 @@ namespace dreal const e_misses_vec &misses \ ) const #define ADD_DECL(name) ExprNode& name (const Expression &e, ExprNode &parent, const std::optional &is_terminal) -#define EST_DECL(name) void name (const Expression &e, const ExprNode &parent, uint64_t &branches, const e_est_continuation_vec& partial_matches) const; #define ALL_DECLS(name) \ VISIT_DECL(name); \ - ADD_DECL(name); \ - EST_DECL(name); + ADD_DECL(name); ALL_DECLS(VisitVariable); ALL_DECLS(VisitConstant); ALL_DECLS(VisitRealConstant); @@ -233,7 +232,6 @@ namespace dreal ALL_DECLS(VisitIfThenElse); ALL_DECLS(VisitUninterpretedFunction); #undef VISIT_DECL -#undef EST_DECL #undef ADD_DECL #undef ALL_DECLS @@ -245,11 +243,9 @@ namespace dreal const f_misses_vec& misses \ ) const #define ADD_DECL(name) FormNode& name (const Formula &f, FormNode &parent, const std::optional &is_terminal) -#define EST_DECL(name) void name (const Formula &f, const FormNode &parent, uint64_t &branches, const f_est_continuation_vec& partial_matches) const; #define ALL_DECLS(name) \ VISIT_DECL(name); \ - ADD_DECL(name); \ - EST_DECL(name); + ADD_DECL(name); ALL_DECLS(VisitFalse); ALL_DECLS(VisitTrue); ALL_DECLS(VisitVariable); @@ -264,7 +260,6 @@ namespace dreal ALL_DECLS(VisitNegation); ALL_DECLS(VisitForall); #undef VISIT_DECL -#undef EST_DECL #undef ADD_DECL #undef ALL_DECLS @@ -303,16 +298,6 @@ namespace dreal const std::optional& is_terminal); FormNode& NaryOpAddHelper(const Formula& f, const FormulaKind& k, FormNode& parent, const std::optional& is_terminal); - void UnaryOpEstHelper(const Expression& f, const ExpressionKind& k, const ExprNode& parent, - uint64_t& branches, const e_est_continuation_vec& partial_matches) const; - void UnaryOpEstHelper(const Formula& f, const FormulaKind& k, const FormNode& parent, - uint64_t& branches, const f_est_continuation_vec& partial_matches) const; - void BinaryOpEstHelper(const Expression& f, const ExpressionKind& k, const ExprNode& parent, - uint64_t& branches, const e_est_continuation_vec& partial_matches) const; - void BinaryOpEstHelper(const Formula& f, const FormulaKind& k, const FormNode& parent, - uint64_t& branches, const f_est_continuation_vec& partial_matches) const; - void NaryOpEstHelper(const Formula& f, const FormulaKind& k, const FormNode& parent, - uint64_t& branches, const f_est_continuation_vec& partial_matches) const; void recMatchExpr( const Expression& e, const ExprNode& parent, substitutions_map& substitutions, @@ -329,14 +314,6 @@ namespace dreal return VisitExpression(this, e, parent, is_terminal); } - void recEstExpr( - const Expression& e, const ExprNode& parent, uint64_t& branches, - const e_est_continuation_vec& partial_matches - ) const { - // std::cout << "recEstExpr: " << e << std::endl; - VisitExpression(this, e, parent, branches, partial_matches); - } - void recMatchForm( const Formula& f, const FormNode& parent, substitutions_map& substitutions, const f_matches_vec& matches, const f_partial_matches_vec& partial_matches, const f_misses_vec& misses @@ -352,13 +329,6 @@ namespace dreal return VisitFormula(this, f, parent, is_terminal); } - void recEstForm( - const Formula& f, const FormNode& parent, uint64_t& branches, const f_est_continuation_vec& partial_matches - ) const { - // std::cout << "recEstForm: " << f << std::endl; - VisitFormula(this, f, parent, branches, partial_matches); - } - friend void drake::symbolic::VisitExpression( PatternMatchingTrie*, const Expression& e, const ExprNode& parent, substitutions_map& substitutions, @@ -368,10 +338,6 @@ namespace dreal PatternMatchingTrie*, const Expression& e, ExprNode& parent, const std::optional& is_terminal ); - friend void drake::symbolic::VisitExpression( - PatternMatchingTrie*, const Expression& e, const ExprNode& parent, - uint64_t& branches, const e_est_continuation_vec& partial_matches - ); friend void drake::symbolic::VisitFormula( PatternMatchingTrie*, const Formula& e, const FormNode& parent, substitutions_map& substitutions, @@ -381,10 +347,6 @@ namespace dreal PatternMatchingTrie*, const Formula& e, FormNode& parent, const std::optional& is_terminal ); - friend void drake::symbolic::VisitFormula( - PatternMatchingTrie*, const Formula& e, const FormNode& parent, - uint64_t& branches, const f_est_continuation_vec& partial_matches - ); }; // inline std::ostream& operator<<(std::ostream& os, const PatternMatchingTrie::matching_stats_t& stats) { diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc index e78309273..11a25f2e2 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc @@ -19,8 +19,6 @@ void PatternMatchingTrie::name ( \ const e_partial_matches_vec& partial_matches, \ const e_misses_vec &misses \ ) const -#define EST_DECL(name) \ -void PatternMatchingTrie::name (const Expression &_e, const ExprNode &parent, uint64_t &branches, const e_est_continuation_vec& partial_matches) const #define ADD_DECL(name) \ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, ExprNode &parent, const std::optional &is_terminal) @@ -29,19 +27,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::Var).emplace_back(e, is_terminal); } - EST_DECL(VisitVariable) { - const auto& e = get_variable(_e); - for (auto& node : parent.c(ExpressionKind::Var)) { - const auto& matched_e = get_variable(*node.leaf); - if (!matched_e.equal_to(e) /* confirmed non-recursive, simple one-liner */) {} - else if (!node.terminal_expression.has_value()) { - // partial match, keep going! - partial_matches(node); - } - } - branches *= parent.c(ExpressionKind::Var).size(); - } - VISIT_DECL(VisitVariable) { const auto& e = get_variable(_e); for (auto& node : parent.c(ExpressionKind::Var)) { @@ -73,17 +58,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::Constant).emplace_back(e, is_terminal); } - EST_DECL(VisitConstant) { - branches += parent.c(ExpressionKind::Constant).size(); - const auto e = get_constant_value(_e); - for (auto& node : parent.c(ExpressionKind::Constant)) { - const auto& matched_e = get_constant_value(*node.leaf); - if (e != matched_e) {} - else if (!node.terminal_expression.has_value()) - partial_matches(node); - } - } - VISIT_DECL(VisitConstant) { const auto e = get_constant_value(_e); for (auto& node : parent.c(ExpressionKind::Constant)) { @@ -101,17 +75,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::RealConstant).emplace_back(e, is_terminal); } - EST_DECL(VisitRealConstant) { - branches += parent.c(ExpressionKind::RealConstant).size(); - const auto e = to_real_constant(_e); - for (auto& node : parent.c(ExpressionKind::RealConstant)) { - const auto& matched_e = to_real_constant(*node.leaf); - if (!e->EqualTo(*matched_e) /* confirmed non-recursive, simple one-liner */) {} - else if (!node.terminal_expression.has_value()) - partial_matches(node); - } - } - VISIT_DECL(VisitRealConstant) { const auto e = to_real_constant(_e); for (auto& node : parent.c(ExpressionKind::RealConstant)) { @@ -143,40 +106,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return *stateCoeff; } - EST_DECL(VisitAddition) { - branches += parent.c(ExpressionKind::Add).size(); - const auto e = to_addition(_e); - for (auto& n1 : parent.c(ExpressionKind::Add)) { - const auto& m = to_addition(*n1.leaf); - if (e->get_constant() != m->get_constant()) continue; - if (e->get_expr_to_coeff_map().size() != m->get_expr_to_coeff_map().size()) continue; - - std::multimap e_canon_coeff_to_expr_map; - for (auto& [expr, coeff] : e->get_expr_to_coeff_map()) - e_canon_coeff_to_expr_map.emplace(coeff, expr); - - DREAL_ASSERT(!n1.terminal_expression.has_value()); - const auto ibegin = e_canon_coeff_to_expr_map.begin(); - const auto iend = e_canon_coeff_to_expr_map.end(); - std::function it_to_match_coeff, it_to_match_expr; - it_to_match_coeff = [&](const auto& it1) { - return [&, /*copy*/ it1](const auto& n) { - auto it2 = it1; - ++it2; - if (it2 == iend) partial_matches(n); - else recEstExpr(it2->first, n, branches, it_to_match_expr(it2)); - }; - }; - it_to_match_expr = [&](const auto& it) { - return [&, /*copy*/ it](const auto& n) { - DREAL_ASSERT(!n.terminal_expression.has_value()); - recEstExpr(it->second, n, branches, it_to_match_coeff(it)); - }; - }; - recEstExpr(ibegin->first, n1, branches, it_to_match_expr(ibegin)); - } - } - VISIT_DECL(VisitAddition) { const auto e = to_addition(_e); for (auto& n1 : parent.c(ExpressionKind::Add)) { @@ -228,40 +157,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return *stateExp; } - EST_DECL(VisitMultiplication) { - branches += parent.c(ExpressionKind::Mul).size(); - const auto e = to_multiplication(_e); - for (auto& n1 : parent.c(ExpressionKind::Mul)) { - const auto& m = to_multiplication(*n1.leaf); - if (e->get_constant() != m->get_constant()) continue; - if (e->get_base_to_exponent_map().size() != m->get_base_to_exponent_map().size()) continue; - - std::multimap e_canon_expo_to_base_map; - for (auto& [base, expo] : e->get_base_to_exponent_map()) - e_canon_expo_to_base_map.emplace(expo, base); - - DREAL_ASSERT(!n1.terminal_expression.has_value()); - const auto ibegin = e_canon_expo_to_base_map.begin(); - const auto iend = e_canon_expo_to_base_map.end(); - std::function it_to_match_expo, it_to_match_base; - it_to_match_expo = [&](const auto& it1) { - return [&, /*copy*/ it1](const auto& n) { - auto it2 = it1; - ++it2; - if (it2 == iend) partial_matches(n); - else recEstExpr(it2->first, n, branches, it_to_match_base(it2)); - }; - }; - it_to_match_base = [&](const auto& it1) { - return [&, /*copy*/ it1](const auto& n) { - DREAL_ASSERT(!n.terminal_expression.has_value()); - recEstExpr(it1->second, n, branches, it_to_match_expo(it1)); - }; - }; - recEstExpr(ibegin->first, n1, branches, it_to_match_base(ibegin)); - } - } - VISIT_DECL(VisitMultiplication) { const auto e = to_multiplication(_e); for (auto& n1 : parent.c(ExpressionKind::Mul)) { @@ -305,21 +200,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return n3; } - void PatternMatchingTrie::BinaryOpEstHelper( - const Expression& e, const ExpressionKind& k, - const ExprNode& parent, uint64_t& branches, const e_est_continuation_vec& partial_matches - ) const { - branches += parent.c(k).size(); - for (auto& n1 : parent.c(k)) { - recEstExpr(get_first_argument(e), n1, branches, EST_CONT_LAMBDA(n2) { - DREAL_ASSERT(!n1.leaf.has_value()); - DREAL_ASSERT(!n1.terminal_expression.has_value()); - DREAL_ASSERT(!n2.terminal_expression.has_value()); - recEstExpr(get_second_argument(e), n2, branches, partial_matches); - }); - } - } - void PatternMatchingTrie::BinaryOpMatchHelper( const Expression& _e, const ExpressionKind& k, const ExprNode& parent, substitutions_map& s1, @@ -346,18 +226,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return n2; } - void PatternMatchingTrie::UnaryOpEstHelper( - const Expression& e, const ExpressionKind& k, - const ExprNode& parent, uint64_t& branches, const e_est_continuation_vec& partial_matches - ) const { - branches += parent.c(k).size(); - for (auto& n1 : parent.c(k)) { - DREAL_ASSERT(!n1.leaf.has_value()); - DREAL_ASSERT(!n1.terminal_expression.has_value()); - recEstExpr(get_argument(e), n1, branches, partial_matches); - } - } - void PatternMatchingTrie::UnaryOpMatchHelper( const Expression& e, const ExpressionKind& k, const ExprNode& parent, substitutions_map& s1, @@ -373,109 +241,91 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } ADD_DECL(VisitDivision) { return BinaryOpAddHelper(e, ExpressionKind::Div, parent, is_terminal); } - EST_DECL(VisitDivision) { return BinaryOpEstHelper(_e, ExpressionKind::Div, parent, branches, partial_matches); } VISIT_DECL(VisitDivision) { return BinaryOpMatchHelper(_e, ExpressionKind::Div, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitLog) { return UnaryOpAddHelper(e, ExpressionKind::Log, parent, is_terminal); } - EST_DECL(VisitLog) { return UnaryOpEstHelper(_e, ExpressionKind::Log, parent, branches, partial_matches); } VISIT_DECL(VisitLog) { return UnaryOpMatchHelper(_e, ExpressionKind::Log, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitAbs) { return UnaryOpAddHelper(e, ExpressionKind::Abs, parent, is_terminal); } - EST_DECL(VisitAbs) { return UnaryOpEstHelper(_e, ExpressionKind::Abs, parent, branches, partial_matches); } VISIT_DECL(VisitAbs) { return UnaryOpMatchHelper(_e, ExpressionKind::Abs, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitExp) { return UnaryOpAddHelper(e, ExpressionKind::Exp, parent, is_terminal); } - EST_DECL(VisitExp) { return UnaryOpEstHelper(_e, ExpressionKind::Exp, parent, branches, partial_matches); } VISIT_DECL(VisitExp) { return UnaryOpMatchHelper(_e, ExpressionKind::Exp, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitSqrt) { return UnaryOpAddHelper(e, ExpressionKind::Sqrt, parent, is_terminal); } - EST_DECL(VisitSqrt) { return UnaryOpEstHelper(_e, ExpressionKind::Sqrt, parent, branches, partial_matches); } VISIT_DECL(VisitSqrt) { return UnaryOpMatchHelper(_e, ExpressionKind::Sqrt, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitPow) { return BinaryOpAddHelper(e, ExpressionKind::Pow, parent, is_terminal); } - EST_DECL(VisitPow) { return BinaryOpEstHelper(_e, ExpressionKind::Pow, parent, branches, partial_matches); } VISIT_DECL(VisitPow) { return BinaryOpMatchHelper(_e, ExpressionKind::Pow, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitSin) { return UnaryOpAddHelper(e, ExpressionKind::Sin, parent, is_terminal); } - EST_DECL(VisitSin) { return UnaryOpEstHelper(_e, ExpressionKind::Sin, parent, branches, partial_matches); } VISIT_DECL(VisitSin) { return UnaryOpMatchHelper(_e, ExpressionKind::Sin, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitCos) { return UnaryOpAddHelper(e, ExpressionKind::Cos, parent, is_terminal); } - EST_DECL(VisitCos) { return UnaryOpEstHelper(_e, ExpressionKind::Cos, parent, branches, partial_matches); } VISIT_DECL(VisitCos) { return UnaryOpMatchHelper(_e, ExpressionKind::Cos, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitTan) { return UnaryOpAddHelper(e, ExpressionKind::Tan, parent, is_terminal); } - EST_DECL(VisitTan) { return UnaryOpEstHelper(_e, ExpressionKind::Tan, parent, branches, partial_matches); } VISIT_DECL(VisitTan) { return UnaryOpMatchHelper(_e, ExpressionKind::Tan, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitAsin) { return UnaryOpAddHelper(e, ExpressionKind::Asin, parent, is_terminal); } - EST_DECL(VisitAsin) { return UnaryOpEstHelper(_e, ExpressionKind::Asin, parent, branches, partial_matches); } VISIT_DECL(VisitAsin) { return UnaryOpMatchHelper(_e, ExpressionKind::Asin, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitAcos) { return UnaryOpAddHelper(e, ExpressionKind::Acos, parent, is_terminal); } - EST_DECL(VisitAcos) { return UnaryOpEstHelper(_e, ExpressionKind::Acos, parent, branches, partial_matches); } VISIT_DECL(VisitAcos) { return UnaryOpMatchHelper(_e, ExpressionKind::Acos, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitAtan) { return UnaryOpAddHelper(e, ExpressionKind::Atan, parent, is_terminal); } - EST_DECL(VisitAtan) { return UnaryOpEstHelper(_e, ExpressionKind::Atan, parent, branches, partial_matches); } VISIT_DECL(VisitAtan) { return UnaryOpMatchHelper(_e, ExpressionKind::Atan, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitAtan2) { return BinaryOpAddHelper(e, ExpressionKind::Atan2, parent, is_terminal); } - EST_DECL(VisitAtan2) { return BinaryOpEstHelper(_e, ExpressionKind::Atan2, parent, branches, partial_matches); } VISIT_DECL(VisitAtan2) { return BinaryOpMatchHelper(_e, ExpressionKind::Atan2, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitSinh) { return UnaryOpAddHelper(e, ExpressionKind::Sinh, parent, is_terminal); } - EST_DECL(VisitSinh) { return UnaryOpEstHelper(_e, ExpressionKind::Sinh, parent, branches, partial_matches); } VISIT_DECL(VisitSinh) { return UnaryOpMatchHelper(_e, ExpressionKind::Sinh, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitCosh) { return UnaryOpAddHelper(e, ExpressionKind::Cosh, parent, is_terminal); } - EST_DECL(VisitCosh) { return UnaryOpEstHelper(_e, ExpressionKind::Cosh, parent, branches, partial_matches); } VISIT_DECL(VisitCosh) { return UnaryOpMatchHelper(_e, ExpressionKind::Cosh, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitTanh) { return UnaryOpAddHelper(e, ExpressionKind::Tanh, parent, is_terminal); } - EST_DECL(VisitTanh) { return UnaryOpEstHelper(_e, ExpressionKind::Tanh, parent, branches, partial_matches); } VISIT_DECL(VisitTanh) { return UnaryOpMatchHelper(_e, ExpressionKind::Tanh, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitMin) { return BinaryOpAddHelper(e, ExpressionKind::Min, parent, is_terminal); } - EST_DECL(VisitMin) { return BinaryOpEstHelper(_e, ExpressionKind::Min, parent, branches, partial_matches); } VISIT_DECL(VisitMin) { return BinaryOpMatchHelper(_e, ExpressionKind::Min, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitMax) { return BinaryOpAddHelper(e, ExpressionKind::Max, parent, is_terminal); } - EST_DECL(VisitMax) { return BinaryOpEstHelper(_e, ExpressionKind::Max, parent, branches, partial_matches); } VISIT_DECL(VisitMax) { return BinaryOpMatchHelper(_e, ExpressionKind::Max, parent, substitutions, matches, partial_matches, misses); } @@ -489,28 +339,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return n4; } - EST_DECL(VisitIfThenElse) { - branches += parent.c(ExpressionKind::IfThenElse).size(); - const auto e = to_if_then_else(_e); - for (auto& n1 : parent.c(ExpressionKind::IfThenElse)) { - DREAL_ASSERT(n1.switch_kind != nullptr); - recEstForm( - e->get_conditional_formula(), *n1.switch_kind, branches, - EST_CONT_LAMBDA(n2) { - DREAL_ASSERT(n2.switch_kind != nullptr); - recEstExpr( - e->get_then_expression(), *n2.switch_kind, branches, - EST_CONT_LAMBDA(n3) { - DREAL_ASSERT(!n1.leaf.has_value()); - DREAL_ASSERT(!n1.terminal_expression.has_value()); - DREAL_ASSERT(!n2.terminal_expression.has_value()); - DREAL_ASSERT(!n3.terminal_expression.has_value()); - recEstExpr(e->get_else_expression(), n3, branches, partial_matches); - }); - }); - } - } - VISIT_DECL(VisitIfThenElse) { const auto e = to_if_then_else(_e); for (auto& n1 : parent.c(ExpressionKind::IfThenElse)) { @@ -537,17 +365,6 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E return parent.c(ExpressionKind::UninterpretedFunction).emplace_back(e, is_terminal); } - EST_DECL(VisitUninterpretedFunction) { - branches += parent.c(ExpressionKind::UninterpretedFunction).size(); - const auto e = to_uninterpreted_function(_e); - for (auto& node : parent.c(ExpressionKind::UninterpretedFunction)) { - const auto& matched_e = to_uninterpreted_function(*node.leaf); - if (!e->EqualTo(*matched_e) /*confirmed non-recursive, simple one-liner*/) {} - else if (!node.terminal_expression.has_value()) - partial_matches(node); - } - } - VISIT_DECL(VisitUninterpretedFunction) { // todo: can an uninterpreted function be substituted? yeah probably... // but doesn't really make sense for dReal. @@ -563,6 +380,5 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } } #undef VISIT_DECL -#undef EST_DECL #undef ADD_DECL } diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index e8a8d0c0e..c133a0c23 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -19,8 +19,6 @@ void PatternMatchingTrie::name ( \ const f_partial_matches_vec& partial_matches, \ const f_misses_vec& misses \ ) const -#define EST_DECL(name) \ -void PatternMatchingTrie::name (const Formula &_f, const FormNode &parent, uint64_t &branches, const f_est_continuation_vec& partial_matches) const #define ADD_DECL(name) \ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, FormNode &parent, const std::optional &is_terminal) @@ -29,15 +27,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return parent.c(FormulaKind::False).emplace_back(f, is_terminal); } - EST_DECL(VisitFalse) { - branches += parent.c(FormulaKind::False).size(); - DREAL_ASSERT(parent.c(FormulaKind::False).size() == 1); // todo? idk. idk how my own code works. - for (auto& node : parent.c(FormulaKind::False)) { - if (!node.terminal_expression.has_value()) - partial_matches(node); - } - } - VISIT_DECL(VisitFalse) { DREAL_ASSERT(parent.c(FormulaKind::False).size() == 1); // todo? idk. idk how my own code works. for (auto& node : parent.c(FormulaKind::False)) { @@ -53,15 +42,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return parent.c(FormulaKind::True).emplace_back(f, is_terminal); } - EST_DECL(VisitTrue) { - branches += parent.c(FormulaKind::True).size(); - DREAL_ASSERT(parent.c(FormulaKind::True).size() == 1); // todo? idk. idk how my own code works. - for (auto& node : parent.c(FormulaKind::True)) { - if (!node.terminal_expression.has_value()) - partial_matches(node); - } - } - VISIT_DECL(VisitTrue) { DREAL_ASSERT(parent.c(FormulaKind::True).size() == 1); // todo? idk. idk how my own code works. for (auto& node : parent.c(FormulaKind::True)) { @@ -76,19 +56,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return parent.c(FormulaKind::Var).emplace_back(f, is_terminal); } - EST_DECL(VisitVariable) { - const auto& f = get_variable(_f); - for (auto& node : parent.c(FormulaKind::Var)) { - const auto& matched_f = get_variable(*node.leaf); - if (!matched_f.equal_to(f) /* confirmed non-recursive, simple one-liner */) {} - else if (!node.terminal_expression.has_value()) { - // partial match, keep going! - partial_matches(node); - } - } - branches *= parent.c(FormulaKind::Var).size(); - } - VISIT_DECL(VisitVariable) { const auto& f = get_variable(_f); for (auto& node : parent.c(FormulaKind::Var)) { @@ -128,24 +95,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return n4; } - void PatternMatchingTrie::BinaryOpEstHelper( - const Formula& f, const FormulaKind& k, - const FormNode& parent, uint64_t& branches, const f_est_continuation_vec& partial_matches - ) const { - branches += parent.c(k).size(); - for (auto& n1 : parent.c(k)) { - recEstExpr(get_lhs_expression(f), *n1.switch_kind, branches, EST_CONT_LAMBDA(n2) { - DREAL_ASSERT(!n1.leaf.has_value()); - DREAL_ASSERT(!n1.terminal_expression.has_value()); - DREAL_ASSERT(!n2.terminal_expression.has_value()); - recEstExpr(get_rhs_expression(f), n2, branches, EST_CONT_LAMBDA(n3) { - if (!n3.switch_kind->terminal_expression.has_value()) - partial_matches(*n3.switch_kind); - }); - }); - } - } - void PatternMatchingTrie::BinaryOpMatchHelper( const Formula& _f, const FormulaKind& k, const FormNode& parent, substitutions_map& s1, @@ -185,32 +134,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return *state; } - void PatternMatchingTrie::NaryOpEstHelper( - const Formula& f, const FormulaKind& k, - const FormNode& parent, uint64_t& branches, const f_est_continuation_vec& partial_matches - ) const { - branches += parent.c(k).size(); - const auto _f = to_nary(f); - for (auto& n1 : parent.c(k)) { - DREAL_ASSERT(!n1.terminal_expression.has_value()); - const auto ibegin = _f->get_operands().begin(); - const auto iend = _f->get_operands().end(); - std::function it_to_match_op = [&](const auto& it1) { - return [&, /*copy*/ it1](const auto& n2) { - if (it1 == iend) { - DREAL_ASSERT(get_operands(f).size() == 1); - return partial_matches(n2); - } - auto it2 = it1; - ++it2; - if (it2 == iend) partial_matches(n2); - else recEstForm(*it2, n2, branches, it_to_match_op(it2)); - }; - }; - recEstForm(*ibegin, n1, branches, it_to_match_op(ibegin)); - } - } - void PatternMatchingTrie::NaryOpMatchHelper( const Formula& f, const FormulaKind& k, const FormNode& parent, substitutions_map& s1, @@ -240,57 +163,45 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } ADD_DECL(VisitEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Eq, parent, is_terminal); } - EST_DECL(VisitEqualTo) { return BinaryOpEstHelper(_f, FormulaKind::Eq, parent, branches, partial_matches); } VISIT_DECL(VisitEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Eq, parent, substitutions, matches, partial_matches, misses); } // todo: Canonical-ize NEQ to NOT + EQ ? ADD_DECL(VisitNotEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Neq, parent, is_terminal); } - EST_DECL(VisitNotEqualTo) { return BinaryOpEstHelper(_f, FormulaKind::Neq, parent, branches, partial_matches); } VISIT_DECL(VisitNotEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Neq, parent, substitutions, matches, partial_matches, misses); } // todo: Canonical-ize GT/LT to just one or the other ? ADD_DECL(VisitGreaterThan) { return BinaryOpAddHelper(f, FormulaKind::Gt, parent, is_terminal); } - EST_DECL(VisitGreaterThan) { return BinaryOpEstHelper(_f, FormulaKind::Gt, parent, branches, partial_matches); } VISIT_DECL(VisitGreaterThan) { return BinaryOpMatchHelper(_f, FormulaKind::Gt, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitGreaterThanOrEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Geq, parent, is_terminal); } - EST_DECL(VisitGreaterThanOrEqualTo) { - return BinaryOpEstHelper(_f, FormulaKind::Geq, parent, branches, partial_matches); - } VISIT_DECL(VisitGreaterThanOrEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Geq, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitLessThan) { return BinaryOpAddHelper(f, FormulaKind::Lt, parent, is_terminal); } - EST_DECL(VisitLessThan) { return BinaryOpEstHelper(_f, FormulaKind::Lt, parent, branches, partial_matches); } VISIT_DECL(VisitLessThan) { return BinaryOpMatchHelper(_f, FormulaKind::Lt, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitLessThanOrEqualTo) { return BinaryOpAddHelper(f, FormulaKind::Leq, parent, is_terminal); } - EST_DECL(VisitLessThanOrEqualTo) { - return BinaryOpEstHelper(_f, FormulaKind::Leq, parent, branches, partial_matches); - } VISIT_DECL(VisitLessThanOrEqualTo) { return BinaryOpMatchHelper(_f, FormulaKind::Leq, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitConjunction) { return NaryOpAddHelper(f, FormulaKind::And, parent, is_terminal); } - EST_DECL(VisitConjunction) { return NaryOpEstHelper(_f, FormulaKind::And, parent, branches, partial_matches); } VISIT_DECL(VisitConjunction) { NaryOpMatchHelper(_f, FormulaKind::And, parent, substitutions, matches, partial_matches, misses); } ADD_DECL(VisitDisjunction) { return NaryOpAddHelper(f, FormulaKind::Or, parent, is_terminal); } - EST_DECL(VisitDisjunction) { return NaryOpEstHelper(_f, FormulaKind::Or, parent, branches, partial_matches); } VISIT_DECL(VisitDisjunction) { NaryOpMatchHelper(_f, FormulaKind::Or, parent, substitutions, matches, partial_matches, misses); } @@ -300,12 +211,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return recAddForm(get_operand(f), n1, is_terminal); } - EST_DECL(VisitNegation) { - branches += parent.c(FormulaKind::Not).size(); - auto& n1 = parent.c_leafless(FormulaKind::Not); - recEstForm(get_operand(_f), n1, branches, partial_matches); - } - VISIT_DECL(VisitNegation) { for (auto& n1 : parent.c(FormulaKind::Not)) { DREAL_ASSERT(!n1.leaf.has_value()); @@ -320,17 +225,6 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form return parent.c(FormulaKind::Forall).emplace_back(f, is_terminal); } - EST_DECL(VisitForall) { - branches += parent.c(FormulaKind::Forall).size(); - const auto f = to_forall(_f); - for (auto& node : parent.c(FormulaKind::Forall)) { - const auto& matched_f = to_forall(*node.leaf); - if (!f->EqualTo(*matched_f)) {} // recursive but whatever.. - else if (!node.terminal_expression.has_value()) - partial_matches(node); - } - } - VISIT_DECL(VisitForall) { // temporary implementation... // I haven't put much thought into this. diff --git a/test/dreal/util/test/pattern_matching_test.cc b/test/dreal/util/test/pattern_matching_test.cc index 36c2b4b4a..d05f2d2d2 100644 --- a/test/dreal/util/test/pattern_matching_test.cc +++ b/test/dreal/util/test/pattern_matching_test.cc @@ -107,7 +107,7 @@ namespace dreal const auto [related_clauses, stats] = trie.find_matches( {y1 == sin(x1), y1 == atan(x1)}, Box{} ); - EXPECT_EQ(stats.misses, 4); + EXPECT_EQ(stats.misses.bc_bij, 4); EXPECT_EQ(stats.matches, 2); EXPECT_EQ(related_clauses.size(), 2); // EXPECT_EQ(trie.estimate_branches(y1 == sin(x1)), 12); From 4bb55281c98ac48fa2395806fba2b47e3542d15f Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Tue, 22 Jul 2025 01:22:50 -0700 Subject: [PATCH 75/79] Improve pattern matching performance using alpha-aware hashing. --- .../pattern_matching/pattern_matching_trie.h | 34 ++++++++++----- .../pattern_matching_trie_expr.cc | 36 ++++++++-------- .../pattern_matching_trie_form.cc | 36 ++++++++-------- .../dreal/symbolic/symbolic_expression.cc | 4 ++ .../dreal/symbolic/symbolic_expression.h | 1 + .../symbolic/symbolic_expression_cell.cc | 41 ++++++++++++++----- .../dreal/symbolic/symbolic_expression_cell.h | 5 ++- .../dreal/symbolic/symbolic_formula.cc | 5 +++ .../dreal/symbolic/symbolic_formula.h | 1 + .../dreal/symbolic/symbolic_formula_cell.cc | 23 +++++++---- .../dreal/symbolic/symbolic_formula_cell.h | 5 ++- test/dreal/util/test/pattern_matching_test.cc | 4 +- 12 files changed, 127 insertions(+), 68 deletions(-) diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie.h b/src/dreal/util/pattern_matching/pattern_matching_trie.h index 2f57a2631..1be3fc4f8 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie.h +++ b/src/dreal/util/pattern_matching/pattern_matching_trie.h @@ -118,25 +118,39 @@ namespace dreal return *switch_kind; } - [[nodiscard]] const std::vector& c(const TKind& k) const { - const auto it = children.find(k); - if (it != children.end()) return it->second; + [[nodiscard]] const std::vector& c(const TKind& k, const size_t alpha_hash) const { + const auto it1 = children.find(k); + if (it1 != children.end()) { + const auto it2 = it1->second.find(alpha_hash); + if (it2 != it1->second.end()) { + return it2->second; + } + } const static std::vector t_empty; return t_empty; } - [[nodiscard]] std::vector& c(const TKind& k) { - return children[k]; + + [[nodiscard]] std::vector& c(const TKind& k, const size_t alpha_hash) { + return children[k][alpha_hash]; + } + + [[nodiscard]] const std::vector& c_like(const This& t) const { + return c(t.get_kind(), t.get_al_hash()); + } + + [[nodiscard]] std::vector& c_like(const This& t) { + return c(t.get_kind(), t.get_al_hash()); } - [[nodiscard]] const TrieNode& c_leafless(const TKind& k) const { - const auto& vec = c(k); + [[nodiscard]] const TrieNode& c_leafless(const TKind& k, const size_t alpha_hash) const { + const auto& vec = c(k, alpha_hash); DREAL_ASSERT(vec.size() == 1); return vec[0]; } - [[nodiscard]] TrieNode& c_leafless(const TKind& k) { - auto& vec = c(k); + [[nodiscard]] TrieNode& c_leafless(const TKind& k, const size_t alpha_hash) { + auto& vec = c(k, alpha_hash); if (vec.empty()) vec.emplace_back(); DREAL_ASSERT(vec.size() == 1); return vec[0]; @@ -160,7 +174,7 @@ namespace dreal const uint64_t id; private: - std::unordered_map> children; + std::unordered_map>> children; // template // std::unordered_map& unique_children(const TKind& kind) const { diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc index 11a25f2e2..7c52eac29 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_expr.cc @@ -24,12 +24,12 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E ADD_DECL(VisitVariable) { // todo: dedupe? - return parent.c(ExpressionKind::Var).emplace_back(e, is_terminal); + return parent.c_like(e).emplace_back(e, is_terminal); } VISIT_DECL(VisitVariable) { const auto& e = get_variable(_e); - for (auto& node : parent.c(ExpressionKind::Var)) { + for (auto& node : parent.c_like(_e)) { substitutions.push(); const auto& matched_e = get_variable(*node.leaf); @@ -55,12 +55,12 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } ADD_DECL(VisitConstant) { - return parent.c(ExpressionKind::Constant).emplace_back(e, is_terminal); + return parent.c_like(e).emplace_back(e, is_terminal); } VISIT_DECL(VisitConstant) { const auto e = get_constant_value(_e); - for (auto& node : parent.c(ExpressionKind::Constant)) { + for (auto& node : parent.c_like(_e)) { const auto& matched_e = get_constant_value(*node.leaf); if (e != matched_e) misses(substitutions_map::CONST_MISS); @@ -72,12 +72,12 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } ADD_DECL(VisitRealConstant) { - return parent.c(ExpressionKind::RealConstant).emplace_back(e, is_terminal); + return parent.c_like(e).emplace_back(e, is_terminal); } VISIT_DECL(VisitRealConstant) { const auto e = to_real_constant(_e); - for (auto& node : parent.c(ExpressionKind::RealConstant)) { + for (auto& node : parent.c_like(_e)) { const auto& matched_e = to_real_constant(*node.leaf); if (!e->EqualTo(*matched_e) /* confirmed non-recursive, simple one-liner */) misses(substitutions_map::CONST_MISS); @@ -89,7 +89,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } ADD_DECL(VisitAddition) { - auto& n1 = parent.c(ExpressionKind::Add).emplace_back(e); + auto& n1 = parent.c_like(e).emplace_back(e); ExprNode *stateCoeff = &n1, *stateExpr = nullptr; std::multimap multimap; // canonicalize for (auto& [expr, coeff] : to_addition(e)->get_expr_to_coeff_map()) { @@ -108,7 +108,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E VISIT_DECL(VisitAddition) { const auto e = to_addition(_e); - for (auto& n1 : parent.c(ExpressionKind::Add)) { + for (auto& n1 : parent.c_like(_e)) { const auto& m = to_addition(*n1.leaf); if (e->get_constant() != m->get_constant()) continue; if (e->get_expr_to_coeff_map().size() != m->get_expr_to_coeff_map().size()) continue; @@ -140,7 +140,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } ADD_DECL(VisitMultiplication) { - auto& n1 = parent.c(ExpressionKind::Mul).emplace_back(e); + auto& n1 = parent.c_like(e).emplace_back(e); ExprNode *stateExp = &n1, *stateBase = nullptr; std::multimap multimap; // canonicalize..ish for (auto& [base, expo] : to_multiplication(e)->get_base_to_exponent_map()) { @@ -159,7 +159,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E VISIT_DECL(VisitMultiplication) { const auto e = to_multiplication(_e); - for (auto& n1 : parent.c(ExpressionKind::Mul)) { + for (auto& n1 : parent.c_like(_e)) { const auto& m = to_multiplication(*n1.leaf); if (e->get_constant() != m->get_constant()) continue; if (e->get_base_to_exponent_map().size() != m->get_base_to_exponent_map().size()) continue; @@ -194,7 +194,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E const Expression& e, const ExpressionKind& k, ExprNode& parent, const std::optional& is_terminal ) { - auto& n1 = parent.c_leafless(k); + auto& n1 = parent.c_leafless(k, e.get_al_hash()); auto& n2 = recAddExpr(get_first_argument(e), n1, {}); auto& n3 = recAddExpr(get_second_argument(e), n2, is_terminal); return n3; @@ -207,7 +207,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E const e_partial_matches_vec& partial_matches, const e_misses_vec& misses ) const { - for (auto& n1 : parent.c(k)) { + for (auto& n1 : parent.c(k, _e.get_al_hash())) { recMatchExpr(get_first_argument(_e), n1, s1, matches, PM_CONT_LAMBDA(n2, s2) { DREAL_ASSERT(!n1.leaf.has_value()); DREAL_ASSERT(!n1.terminal_expression.has_value()); @@ -221,7 +221,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E const Expression& e, const ExpressionKind& k, ExprNode& parent, const std::optional& is_terminal ) { - auto& n1 = parent.c_leafless(k); + auto& n1 = parent.c_leafless(k, e.get_al_hash()); auto& n2 = recAddExpr(get_argument(e), n1, is_terminal); return n2; } @@ -233,7 +233,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E const e_partial_matches_vec& partial_matches, const e_misses_vec& misses ) const { - for (auto& n1 : parent.c(k)) { + for (auto& n1 : parent.c(k, e.get_al_hash())) { DREAL_ASSERT(!n1.leaf.has_value()); DREAL_ASSERT(!n1.terminal_expression.has_value()); recMatchExpr(get_argument(e), n1, s1, matches, partial_matches, misses); @@ -332,7 +332,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E ADD_DECL(VisitIfThenElse) { const auto ite = to_if_then_else(e); - auto& n1 = parent.c_leafless(ExpressionKind::IfThenElse); + auto& n1 = parent.c_leafless(ExpressionKind::IfThenElse, e.get_al_hash()); auto& n2 = recAddForm(ite->get_conditional_formula(), n1.init_switch_kind(), {}); auto& n3 = recAddExpr(ite->get_then_expression(), n2.init_switch_kind(), {}); auto& n4 = recAddExpr(ite->get_else_expression(), n3, is_terminal); @@ -341,7 +341,7 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E VISIT_DECL(VisitIfThenElse) { const auto e = to_if_then_else(_e); - for (auto& n1 : parent.c(ExpressionKind::IfThenElse)) { + for (auto& n1 : parent.c_like(_e)) { DREAL_ASSERT(n1.switch_kind != nullptr); recMatchForm( e->get_conditional_formula(), *n1.switch_kind, substitutions, @@ -362,14 +362,14 @@ PatternMatchingTrie::ExprNode& PatternMatchingTrie::name (const Expression &e, E } ADD_DECL(VisitUninterpretedFunction) { - return parent.c(ExpressionKind::UninterpretedFunction).emplace_back(e, is_terminal); + return parent.c_like(e).emplace_back(e, is_terminal); } VISIT_DECL(VisitUninterpretedFunction) { // todo: can an uninterpreted function be substituted? yeah probably... // but doesn't really make sense for dReal. const auto e = to_uninterpreted_function(_e); - for (auto& node : parent.c(ExpressionKind::UninterpretedFunction)) { + for (auto& node : parent.c_like(_e)) { const auto& matched_e = to_uninterpreted_function(*node.leaf); if (!e->EqualTo(*matched_e) /*confirmed non-recursive, simple one-liner*/) misses(substitutions_map::CONST_MISS); diff --git a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc index c133a0c23..bdd94c538 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_trie_form.cc @@ -23,13 +23,13 @@ void PatternMatchingTrie::name ( \ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, FormNode &parent, const std::optional &is_terminal) ADD_DECL(VisitFalse) { - DREAL_ASSERT(parent.c(FormulaKind::False).empty()); // todo? idk. idk how my own code works. - return parent.c(FormulaKind::False).emplace_back(f, is_terminal); + DREAL_ASSERT(parent.c_like(f).empty()); // todo? idk. idk how my own code works. + return parent.c_like(f).emplace_back(f, is_terminal); } VISIT_DECL(VisitFalse) { - DREAL_ASSERT(parent.c(FormulaKind::False).size() == 1); // todo? idk. idk how my own code works. - for (auto& node : parent.c(FormulaKind::False)) { + DREAL_ASSERT(parent.c_like(_f).size() == 1); // todo? idk. idk how my own code works. + for (auto& node : parent.c_like(_f)) { if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); else @@ -38,13 +38,13 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } ADD_DECL(VisitTrue) { - DREAL_ASSERT(parent.c(FormulaKind::True).empty()); // todo? idk. idk how my own code works. - return parent.c(FormulaKind::True).emplace_back(f, is_terminal); + DREAL_ASSERT(parent.c_like(f).empty()); // todo? idk. idk how my own code works. + return parent.c_like(f).emplace_back(f, is_terminal); } VISIT_DECL(VisitTrue) { - DREAL_ASSERT(parent.c(FormulaKind::True).size() == 1); // todo? idk. idk how my own code works. - for (auto& node : parent.c(FormulaKind::True)) { + DREAL_ASSERT(parent.c_like(_f).size() == 1); // todo? idk. idk how my own code works. + for (auto& node : parent.c_like(_f)) { if (!node.terminal_expression.has_value()) partial_matches(node, substitutions); else @@ -53,12 +53,12 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } ADD_DECL(VisitVariable) { - return parent.c(FormulaKind::Var).emplace_back(f, is_terminal); + return parent.c_like(f).emplace_back(f, is_terminal); } VISIT_DECL(VisitVariable) { const auto& f = get_variable(_f); - for (auto& node : parent.c(FormulaKind::Var)) { + for (auto& node : parent.c_like(_f)) { substitutions.push(); const auto& matched_f = get_variable(*node.leaf); @@ -87,7 +87,7 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form const Formula& f, const FormulaKind& k, FormNode& parent, const std::optional& is_terminal ) { - auto& n1 = parent.c_leafless(k); + auto& n1 = parent.c_leafless(k, f.get_al_hash()); auto& n2 = recAddExpr(get_lhs_expression(f), n1.init_switch_kind(), {}); auto& n3 = recAddExpr(get_rhs_expression(f), n2, {}); auto& n4 = n3.init_switch_kind(); @@ -103,7 +103,7 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form const f_misses_vec& misses ) const { e_matches_vec e_matches = PM_CONT_LAMBDA(m, s) { DREAL_UNREACHABLE(); }; - for (auto& n1 : parent.c(k)) { + for (auto& n1 : parent.c(k, _f.get_al_hash())) { recMatchExpr(get_lhs_expression(_f), *n1.switch_kind, s1, e_matches, PM_CONT_LAMBDA(n2, s2) { DREAL_ASSERT(!n1.leaf.has_value()); DREAL_ASSERT(!n1.terminal_expression.has_value()); @@ -122,7 +122,7 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form const Formula& f, const FormulaKind& k, FormNode& parent, const std::optional& is_terminal ) { - auto& n1 = parent.c_leafless(k); + auto& n1 = parent.c_leafless(k, f.get_al_hash()); FormNode* state = &n1; const auto ops = get_operands(f); size_t i = 0; @@ -142,7 +142,7 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form const f_misses_vec& misses ) const { const auto _f = to_nary(f); - for (auto& n1 : parent.c(k)) { + for (auto& n1 : parent.c(k, f.get_al_hash())) { DREAL_ASSERT(!n1.terminal_expression.has_value()); const auto ibegin = _f->get_operands().begin(); const auto iend = _f->get_operands().end(); @@ -207,12 +207,12 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form } ADD_DECL(VisitNegation) { - auto& n1 = parent.c_leafless(FormulaKind::Not); + auto& n1 = parent.c_leafless(FormulaKind::Not, f.get_al_hash()); return recAddForm(get_operand(f), n1, is_terminal); } VISIT_DECL(VisitNegation) { - for (auto& n1 : parent.c(FormulaKind::Not)) { + for (auto& n1 : parent.c_like(_f)) { DREAL_ASSERT(!n1.leaf.has_value()); DREAL_ASSERT(!n1.terminal_expression.has_value()); recMatchForm(get_operand(_f), n1, substitutions, matches, partial_matches, misses); @@ -222,14 +222,14 @@ PatternMatchingTrie::FormNode& PatternMatchingTrie::name (const Formula &f, Form ADD_DECL(VisitForall) { // temporary implementation... // I haven't put much thought into this. - return parent.c(FormulaKind::Forall).emplace_back(f, is_terminal); + return parent.c_like(f).emplace_back(f, is_terminal); } VISIT_DECL(VisitForall) { // temporary implementation... // I haven't put much thought into this. const auto f = to_forall(_f); - for (auto& node : parent.c(FormulaKind::Forall)) { + for (auto& node : parent.c_like(_f)) { const auto& matched_f = to_forall(*node.leaf); if (!f->EqualTo(*matched_f)) misses(substitutions_map::CONST_MISS); diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.cc index edbd590e4..11601b9e7 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.cc @@ -160,6 +160,10 @@ size_t Expression::get_hash() const { assert(ptr_ != nullptr); return ptr_->get_hash(); } +size_t Expression::get_al_hash() const { + assert(ptr_ != nullptr); + return ptr_->get_al_hash(); +} Expression Expression::Zero() { static const Expression kZero{new ExpressionConstant{0.0}}; diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.h b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.h index 34e04e7ca..cfa4f9716 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.h +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression.h @@ -184,6 +184,7 @@ class Expression { ExpressionKind get_kind() const; /** Returns hash value. */ size_t get_hash() const; + size_t get_al_hash() const; /** Collects variables in expression. */ const Variables& GetVariables() const; diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc index 3b4dfd39c..65cb5eccd 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc @@ -234,11 +234,12 @@ Expression ExpandPow(const Expression& base, const Expression& exponent) { } } // anonymous namespace -ExpressionCell::ExpressionCell(const ExpressionKind k, const size_t hash, +ExpressionCell::ExpressionCell(const ExpressionKind k, const size_t hash, const size_t alpha_hash, const bool is_poly, const bool include_ite, Variables variables) : kind_{k}, hash_{hash_combine(static_cast(kind_), hash)}, + alpha_hash_{hash_combine(static_cast(kind_), alpha_hash)}, is_polynomial_{is_poly}, include_ite_{include_ite}, variables_{std::move(variables)} {} @@ -250,7 +251,7 @@ const Variables& ExpressionCell::GetVariables() const { return variables_; } UnaryExpressionCell::UnaryExpressionCell(const ExpressionKind k, const Expression& e, const bool is_poly) - : ExpressionCell{k, e.get_hash(), is_poly, e.include_ite(), + : ExpressionCell{k, e.get_hash(), e.get_al_hash(), is_poly, e.include_ite(), e.GetVariables()}, e_{e} {} @@ -277,7 +278,10 @@ BinaryExpressionCell::BinaryExpressionCell(const ExpressionKind k, const Expression& e1, const Expression& e2, const bool is_poly) - : ExpressionCell{k, hash_combine(e1.get_hash(), e2), is_poly, + : ExpressionCell{k, + hash_combine(e1.get_hash(), e2.get_hash()), + hash_combine(e1.get_al_hash(), e2.get_al_hash()), + is_poly, e1.include_ite() || e2.include_ite(), e1.GetVariables() + e2.GetVariables()}, e1_{e1}, @@ -313,6 +317,7 @@ double BinaryExpressionCell::Evaluate(const Environment& env) const { ExpressionVar::ExpressionVar(const Variable& v) : ExpressionCell{ExpressionKind::Var, hash_value{}(v), + 41, true, false, {v}}, @@ -382,7 +387,7 @@ Expression ExpressionVar::Differentiate(const Variable& x) const { ostream& ExpressionVar::Display(ostream& os) const { return os << var_; } ExpressionConstant::ExpressionConstant(const double v) - : ExpressionCell{ExpressionKind::Constant, hash{}(v), true, false, + : ExpressionCell{ExpressionKind::Constant, hash{}(v), hash{}(v), true, false, Variables{}}, v_{v} { assert(!std::isnan(v)); @@ -425,7 +430,7 @@ ostream& ExpressionConstant::Display(ostream& os) const { ExpressionRealConstant::ExpressionRealConstant(const double lb, const double ub, bool use_lb_as_representative) - : ExpressionCell{ExpressionKind::RealConstant, hash{}(lb), true, + : ExpressionCell{ExpressionKind::RealConstant, hash{}(lb), hash{}(lb), true, false, Variables{}}, lb_{lb}, ub_{ub}, @@ -474,7 +479,7 @@ ostream& ExpressionRealConstant::Display(ostream& os) const { } ExpressionNaN::ExpressionNaN() - : ExpressionCell{ExpressionKind::NaN, 41, false, false, Variables{}} { + : ExpressionCell{ExpressionKind::NaN, 41, 41, false, false, Variables{}} { // ExpressionCell constructor calls hash_combine(ExpressionKind::NaN, 41) to // compute the hash of ExpressionNaN. Here 41 does not have any special // meaning. @@ -511,10 +516,18 @@ Expression ExpressionNaN::Differentiate(const Variable&) const { ostream& ExpressionNaN::Display(ostream& os) const { return os << "NaN"; } +size_t alpha_hash_map(const map &map) { + size_t seed{}; + for (const auto& [k,v] : map) + seed = hash_combine(seed, k.get_al_hash(), v); + return seed; +} + ExpressionAdd::ExpressionAdd(const double constant, map expr_to_coeff_map) : ExpressionCell{ExpressionKind::Add, hash_combine(hash{}(constant), expr_to_coeff_map), + hash_combine(hash{}(constant), alpha_hash_map(expr_to_coeff_map)), determine_polynomial(expr_to_coeff_map), determine_include_ite(expr_to_coeff_map), ExtractVariables(expr_to_coeff_map)}, @@ -769,11 +782,18 @@ ExpressionAddFactory& ExpressionAddFactory::AddMap( return *this; } +size_t alpha_hash_map(const map &map) { + size_t seed{}; + for (const auto& [k,v] : map) + seed = hash_combine(seed, k.get_al_hash(), v.get_al_hash()); + return seed; +} + ExpressionMul::ExpressionMul(const double constant, map base_to_exponent_map) : ExpressionCell{ExpressionKind::Mul, - hash_combine(hash{}(constant), - base_to_exponent_map), + hash_combine(hash{}(constant), base_to_exponent_map), + hash_combine(hash{}(constant), alpha_hash_map(base_to_exponent_map)), determine_polynomial(base_to_exponent_map), determine_include_ite(base_to_exponent_map), ExtractVariables(base_to_exponent_map)}, @@ -1998,8 +2018,8 @@ ExpressionIfThenElse::ExpressionIfThenElse(const Formula& f_cond, const Expression& e_then, const Expression& e_else) : ExpressionCell{ExpressionKind::IfThenElse, - hash_combine(hash_value{}(f_cond), e_then, - e_else), + hash_combine(hash_value{}(f_cond), e_then, e_else), + hash_combine(f_cond.get_al_hash(), e_then.get_al_hash(), e_else.get_al_hash()), false, true, ExtractVariables(f_cond, e_then, e_else)}, f_cond_{f_cond}, e_then_{e_then}, @@ -2090,6 +2110,7 @@ ostream& ExpressionIfThenElse::Display(ostream& os) const { ExpressionUninterpretedFunction::ExpressionUninterpretedFunction( const string& name, const Variables& vars) : ExpressionCell{ExpressionKind::UninterpretedFunction, + hash_combine(hash_value{}(name), vars), hash_combine(hash_value{}(name), vars), false, false, vars}, name_{name}, diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.h b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.h index 72b6c6452..84f7fd5fc 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.h +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.h @@ -30,6 +30,7 @@ class ExpressionCell { /** Returns hash value. */ size_t get_hash() const { return hash_; } + size_t get_al_hash() const { return alpha_hash_; } /** Collects variables in expression. */ const Variables& GetVariables() const; @@ -97,7 +98,7 @@ class ExpressionCell { protected: /** Constructs ExpressionCell of kind @p k with @p hash, @p is_poly, and @p * include_ite. */ - ExpressionCell(ExpressionKind k, size_t hash, bool is_poly, bool include_ite, + ExpressionCell(ExpressionKind k, size_t hash, size_t alpha_hash, bool is_poly, bool include_ite, Variables variables); /** Default destructor. */ virtual ~ExpressionCell() = default; @@ -106,7 +107,7 @@ class ExpressionCell { private: const ExpressionKind kind_{}; - const size_t hash_{}; + const size_t hash_{}, alpha_hash_{}; const bool is_polynomial_{false}; const bool include_ite_{false}; const Variables variables_; diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc index b01857610..00420fdfb 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.cc @@ -75,6 +75,11 @@ size_t Formula::get_hash() const { return ptr_->get_hash(); } +size_t Formula::get_al_hash() const { + assert(ptr_ != nullptr); + return ptr_->get_al_hash(); +} + const Variables& Formula::GetFreeVariables() const { assert(ptr_ != nullptr); return ptr_->GetFreeVariables(); diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h index 8bdf48daf..966a8cfd7 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula.h @@ -115,6 +115,7 @@ class Formula { FormulaKind get_kind() const; size_t get_hash() const; + size_t get_al_hash() const; /** Gets free variables (unquantified variables). */ diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc index 3ec85b71c..e212aab4e 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc @@ -30,10 +30,11 @@ using std::runtime_error; using std::set; using std::string; -FormulaCell::FormulaCell(const FormulaKind k, const size_t hash, +FormulaCell::FormulaCell(const FormulaKind k, const size_t hash, const size_t alpha_hash, const bool include_ite, Variables variables) : kind_{k}, hash_{hash_combine(hash, static_cast(kind_))}, + alpha_hash_{hash_combine(alpha_hash, static_cast(kind_))}, include_ite_{include_ite}, variables_{std::move(variables)} {} @@ -47,6 +48,7 @@ RelationalFormulaCell::RelationalFormulaCell(const FormulaKind k, const Expression& lhs, const Expression& rhs) : FormulaCell{k, hash_combine(lhs.get_hash(), rhs), + hash_combine(lhs.get_al_hash(), rhs.get_al_hash()), lhs.include_ite() || rhs.include_ite(), lhs.GetVariables() + rhs.GetVariables()}, e_lhs_{lhs}, @@ -72,8 +74,15 @@ bool RelationalFormulaCell::Less(const FormulaCell& f) const { return e_rhs_.Less(rel_f.e_rhs_); } +size_t alpha_hash_set(const set &set) { + size_t seed{}; + for (const auto& v : set) + seed = hash_combine(seed, v.get_al_hash()); + return seed; +} + NaryFormulaCell::NaryFormulaCell(const FormulaKind k, set formulas) - : FormulaCell{k, hash_value>{}(formulas), + : FormulaCell{k, hash_value>{}(formulas), alpha_hash_set(formulas), any_of(formulas.begin(), formulas.end(), [](const Formula& f) { return f.include_ite(); }), ExtractFreeVariables(formulas)}, @@ -123,7 +132,7 @@ ostream& NaryFormulaCell::DisplayWithOp(ostream& os, const string& op) const { } FormulaTrue::FormulaTrue() - : FormulaCell{FormulaKind::True, hash{}("True"), false, + : FormulaCell{FormulaKind::True, hash{}("True"), hash{}("True"), false, Variables{}} {} bool FormulaTrue::EqualTo(const FormulaCell& f) const { @@ -149,7 +158,7 @@ Formula FormulaTrue::Substitute(const ExpressionSubstitution&, ostream& FormulaTrue::Display(ostream& os) const { return os << "True"; } FormulaFalse::FormulaFalse() - : FormulaCell{FormulaKind::False, hash{}("False"), false, + : FormulaCell{FormulaKind::False, hash{}("False"), hash{}("False"), false, Variables{}} {} bool FormulaFalse::EqualTo(const FormulaCell& f) const { @@ -175,7 +184,7 @@ Formula FormulaFalse::Substitute(const ExpressionSubstitution&, ostream& FormulaFalse::Display(ostream& os) const { return os << "False"; } FormulaVar::FormulaVar(const Variable& v) - : FormulaCell{FormulaKind::Var, hash_value{}(v), false, {v}}, + : FormulaCell{FormulaKind::Var, hash_value{}(v), 41, false, {v}}, var_{v} { // Dummy symbolic variable (ID = 0) should not be used in constructing // symbolic formulas. @@ -500,7 +509,7 @@ ostream& FormulaOr::Display(ostream& os) const { } FormulaNot::FormulaNot(const Formula& f) - : FormulaCell{FormulaKind::Not, f.get_hash(), f.include_ite(), + : FormulaCell{FormulaKind::Not, f.get_hash(), f.get_al_hash(), f.include_ite(), f.GetFreeVariables()}, f_{f} {} @@ -537,7 +546,7 @@ ostream& FormulaNot::Display(ostream& os) const { } FormulaForall::FormulaForall(const Variables& vars, Formula f) - : FormulaCell{FormulaKind::Forall, hash_combine(vars.get_hash(), f), + : FormulaCell{FormulaKind::Forall, hash_combine(vars.get_hash(), f), hash_combine(vars.get_hash(), f), f.include_ite(), f.GetFreeVariables() - vars}, vars_{vars}, f_{std::move(f)} {} diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.h b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.h index 1041f1832..1d6eefc5e 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.h +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.h @@ -45,6 +45,7 @@ class FormulaCell { FormulaKind get_kind() const { return kind_; } /** Returns hash of formula. */ size_t get_hash() const { return hash_; } + size_t get_al_hash() const { return alpha_hash_; } /** Returns set of free variables in formula. */ const Variables& GetFreeVariables() const; /** Checks structural equality. */ @@ -73,7 +74,7 @@ class FormulaCell { protected: /** Construct FormulaCell of kind @p k with @p hash. */ - FormulaCell(FormulaKind k, size_t hash, bool include_ite, + FormulaCell(FormulaKind k, size_t hash, size_t alpha_hash, bool include_ite, Variables variables); /** Default destructor. */ virtual ~FormulaCell() = default; @@ -82,7 +83,7 @@ class FormulaCell { private: const FormulaKind kind_{}; - const size_t hash_{}; + const size_t hash_{}, alpha_hash_{}; const bool include_ite_{false}; const Variables variables_; diff --git a/test/dreal/util/test/pattern_matching_test.cc b/test/dreal/util/test/pattern_matching_test.cc index d05f2d2d2..aa02fe345 100644 --- a/test/dreal/util/test/pattern_matching_test.cc +++ b/test/dreal/util/test/pattern_matching_test.cc @@ -87,10 +87,12 @@ namespace dreal for (const auto& match : matches) { EXPECT_EQ(found.count(match), 1); std::cout << pattern << " MATCHES " << match << std::endl; + EXPECT_EQ(match.get_al_hash(), pattern.get_al_hash()); } for (const auto& miss : misses1) { EXPECT_EQ(found.count(miss), 0); std::cout << pattern << " MISSES " << miss << std::endl; + // EXPECT_NE(miss.get_al_hash(), pattern.get_al_hash()); } } @@ -107,7 +109,7 @@ namespace dreal const auto [related_clauses, stats] = trie.find_matches( {y1 == sin(x1), y1 == atan(x1)}, Box{} ); - EXPECT_EQ(stats.misses.bc_bij, 4); + EXPECT_EQ(stats.misses.bc_bij, 2); EXPECT_EQ(stats.matches, 2); EXPECT_EQ(related_clauses.size(), 2); // EXPECT_EQ(trie.estimate_branches(y1 == sin(x1)), 12); From b56bb15db6d7858da16d034e8bf3cec900d9bb9b Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 11 Aug 2025 03:26:28 -0700 Subject: [PATCH 76/79] ASPLOS circuit tweaks. --- src/dreal/version.h | 4 ++-- .../dreal/symbolic/symbolic_expression_cell.cc | 2 +- .../dreal/symbolic/symbolic_formula_cell.cc | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/dreal/version.h b/src/dreal/version.h index a1e730a3f..4a2b13228 100644 --- a/src/dreal/version.h +++ b/src/dreal/version.h @@ -12,7 +12,7 @@ // #define DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME // #define DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE -#define DREAL_EXPERIMENTAL_PATTERN_MATCH_SIZE_THRESH 32 +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_SIZE_THRESH 23 #define DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS // #define DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS @@ -24,7 +24,7 @@ // this is an *upper* limit for calculated timeout, 100 * TSCS // should be taken from data reflected in WORTH_IT_regression_*.ipynb -#define DREAL_EXPERIMENTAL_PATTERN_MATCH_TIMEOUT (std::chrono::milliseconds(500)) +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_TIMEOUT (std::chrono::milliseconds(333)) // check that options are required and mutually exclusive #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc index 65cb5eccd..7b3018d04 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_expression_cell.cc @@ -239,7 +239,7 @@ ExpressionCell::ExpressionCell(const ExpressionKind k, const size_t hash, const Variables variables) : kind_{k}, hash_{hash_combine(static_cast(kind_), hash)}, - alpha_hash_{hash_combine(static_cast(kind_), alpha_hash)}, + alpha_hash_{hash_combine(static_cast(kind_), alpha_hash, variables.size())}, is_polynomial_{is_poly}, include_ite_{include_ite}, variables_{std::move(variables)} {} diff --git a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc index e212aab4e..f94b2f5ff 100644 --- a/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc +++ b/src/third_party/com_github_robotlocomotion_drake/dreal/symbolic/symbolic_formula_cell.cc @@ -34,7 +34,7 @@ FormulaCell::FormulaCell(const FormulaKind k, const size_t hash, const size_t al const bool include_ite, Variables variables) : kind_{k}, hash_{hash_combine(hash, static_cast(kind_))}, - alpha_hash_{hash_combine(alpha_hash, static_cast(kind_))}, + alpha_hash_{hash_combine(alpha_hash, static_cast(kind_), variables.size())}, include_ite_{include_ite}, variables_{std::move(variables)} {} From cf6dc8949318ce3c77854d257e92a89ec9679bf4 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 11 Aug 2025 17:03:48 -0700 Subject: [PATCH 77/79] Tweak PM thresholds and timeouts --- src/dreal/version.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dreal/version.h b/src/dreal/version.h index 4a2b13228..298da2ccc 100644 --- a/src/dreal/version.h +++ b/src/dreal/version.h @@ -12,7 +12,7 @@ // #define DREAL_EXPERIMENTAL_PATTERN_MATCH_SOME // #define DREAL_EXPERIMENTAL_PATTERN_MATCH_NONE -#define DREAL_EXPERIMENTAL_PATTERN_MATCH_SIZE_THRESH 23 +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_SIZE_THRESH 16 #define DREAL_EXPERIMENTAL_SAT_MODEL_PARTIAL_CONSTRAINTS // #define DREAL_EXPERIMENTAL_SAT_MODEL_FULL_CONSTRAINTS @@ -24,7 +24,7 @@ // this is an *upper* limit for calculated timeout, 100 * TSCS // should be taken from data reflected in WORTH_IT_regression_*.ipynb -#define DREAL_EXPERIMENTAL_PATTERN_MATCH_TIMEOUT (std::chrono::milliseconds(333)) +#define DREAL_EXPERIMENTAL_PATTERN_MATCH_TIMEOUT (std::chrono::milliseconds(222)) // check that options are required and mutually exclusive #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL From 0eb520043af518a74858347c4dbe5767fb0dd111 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 11 Aug 2025 17:21:48 -0700 Subject: [PATCH 78/79] Speed up prints for benchmarking. --- src/dreal/solver/context_impl.cc | 18 ++++++++++-------- src/dreal/solver/sat_solver.cc | 2 +- src/dreal/solver/sat_solver_interval_logic.cc | 2 +- .../pattern_matching_heuristic.cc | 1 + 4 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index f0164c3c5..e87d515af 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -376,10 +376,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.pattern_match_ms = alcp_elapsed.count(); kunal_paper_data.pattern_matching_stats = alcp_result; - std::cerr << "P(is W.I.)=" << std::setprecision(3) << predicted_is_worth_it; - std::cerr << ".\tMatched " << alcp_result.matches << " size " << explanation.size() << " in " << alcp_elapsed.count(); - std::cerr << " ms.\tTSCS " << tscs_elapsed.count() << " ms.\t"; - std::cerr << "Fully constrained = " << is_full_constrained << std::endl; + std::cerr << std::setprecision(3); + // std::cerr << "P(is W.I.)=" << predicted_is_worth_it; + std::cerr << ".\tM " << alcp_result.matches << " s " << explanation.size() << " i " << alcp_elapsed.count(); + std::cerr << " m.\tT " << tscs_elapsed.count() << " m.\t"; + std::cerr << "F c = " << is_full_constrained << '\n'; // const double bb_lpms = 1 / tscs_elapsed.count(); // const double pm_lpms = (std::max(alcp_result.matches, 1u) - 0.999) / alcp_elapsed.count(); @@ -390,10 +391,11 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, // const bool valid_under = (actual_log2_worth_it < 1) && (predicted_is_worth_it < 0.5); // const bool underestimated = (actual_log2_worth_it > 1) && (predicted_is_worth_it < 0.5); } else { - std::cerr << "P(is W.I.)=" << std::setprecision(3) << predicted_is_worth_it; - std::cerr << ".\tAdding 1 size " << explanation.size() << " directly.\t"; - std::cerr << "TSCS " << tscs_elapsed.count() << " ms.\t"; - std::cerr << "Fully constrained = " << is_full_constrained << std::endl; + // std::cerr << std::setprecision(3); + // std::cerr << "P(is W.I.)=" << predicted_is_worth_it; + // std::cerr << ".\tA 1 s " << explanation.size() << " d.\t"; + // std::cerr << "T " << tscs_elapsed.count() << " m.\t"; + // std::cerr << "F c = " << is_full_constrained << '\n'; sat_solver->AddLearnedClauseUnboxed(explanation); } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/dreal/solver/sat_solver.cc b/src/dreal/solver/sat_solver.cc index 5e606904f..287ab8004 100644 --- a/src/dreal/solver/sat_solver.cc +++ b/src/dreal/solver/sat_solver.cc @@ -146,7 +146,7 @@ optional> SatSolver::CheckSat(const bool reque num_literals_omitted = get_partial_model(model_is); // DREAL_LOG_INFO("SatSolver::CheckSat - Shrank model by {}%", num_literals_omitted * 100.0 / cadical->vars()); } - std::cerr << "Omitted " << num_literals_omitted << " literals from model of size " << cadical->vars() << '.' << std::endl; + // std::cerr << "O " << num_literals_omitted << " l f m o s " << cadical->vars() << ".\n"; if (DREAL_EXPERIMENTAL_SAT_AUDIT_ENABLED) { if (/*model_is_fully_constrained*/ num_literals_omitted == 0) { diff --git a/src/dreal/solver/sat_solver_interval_logic.cc b/src/dreal/solver/sat_solver_interval_logic.cc index d51e36fdc..a1cff23a4 100644 --- a/src/dreal/solver/sat_solver_interval_logic.cc +++ b/src/dreal/solver/sat_solver_interval_logic.cc @@ -148,7 +148,7 @@ namespace dreal match_statistics ] = pn.FindSimilar(base_conflict, base_box, timeout); if (all_related_conflicts.empty()) { - DREAL_LOG_ERROR("Clause did not match with itself... Adding regularly."); + DREAL_LOG_INFO("Clause did not match with itself... Adding regularly."); return match_statistics; } if (match_statistics.misses.bc_box) diff --git a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc index 81b87f347..6cecb02dc 100644 --- a/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc +++ b/src/dreal/util/pattern_matching/pattern_matching_heuristic.cc @@ -21,6 +21,7 @@ namespace dreal float sigmoid(const float x) { return 1 / (1 + expf(-x)); } float PatternMatchingHeuristic::calculate(const statistics &k) { + return 0; // todo: revisit this? const float LOG2P1_assertions_size = log2(1+k.assertions_size); const float LOG2P1_box_boolean_count = log2(1+k.box_boolean_count); From 484e65f94acaa3577a2fbebcfe25103e3f653977 Mon Sep 17 00:00:00 2001 From: Kunal Sheth Date: Mon, 11 Aug 2025 18:40:52 -0700 Subject: [PATCH 79/79] Remove lemma/assertion statistics from collected data for benchmarking. --- src/dreal/solver/context_impl.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/dreal/solver/context_impl.cc b/src/dreal/solver/context_impl.cc index e87d515af..9d3b47df7 100644 --- a/src/dreal/solver/context_impl.cc +++ b/src/dreal/solver/context_impl.cc @@ -275,6 +275,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, //////////////////////////////////////////////////////////////////////////////// kunal_paper_data.assertions_size = assertions.size(); +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV const auto ranking_start1 = std::chrono::high_resolution_clock::now(); std::set assertions_set(assertions.begin(), assertions.end()); kunal_paper_data.assertions_stats = pn_.heuristic.collect_statistics(make_conjunction_SKIP_CHECKS_KUNAL_HACK(std::move(assertions_set))); @@ -284,6 +285,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, kunal_paper_data.biggest_assertion_stats = pn_.heuristic.collect_statistics(assertions[assertions.size()-1]); const auto ranking_end1 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed1 = ranking_end1 - ranking_start1; +#endif const auto tscs_start = std::chrono::high_resolution_clock::now(); const auto tscs_result = theory_solver_.CheckSat(box, assertions); @@ -325,6 +327,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, //////////////////////////////////////////////////////////////////////////////// kunal_paper_data.lemma_size = explanation.size(); +#ifdef DREAL_EXPERIMENTAL_GENERATE_HEURISTICS_CSV const auto ranking_start2 = std::chrono::high_resolution_clock::now(); // kunal_paper_data.lemma_stats = pn_.heuristic.collect_statistics(!make_conjunction_SKIP_CHECKS_KUNAL_HACK(explanation.first)); // doing individual literals doesn't cost extra because they cache hit after running the entire conjunction @@ -334,6 +337,7 @@ optional Context::Impl::CheckSatCore(const ScopedVector& stack, const float predicted_is_worth_it = PatternMatchingHeuristic::calculate(kunal_paper_data); const auto ranking_end2 = std::chrono::high_resolution_clock::now(); const std::chrono::duration ranking_elapsed2 = ranking_end2 - ranking_start2; +#endif #ifdef DREAL_EXPERIMENTAL_PATTERN_MATCH_ALL static_assert(pattern_matching_mode == 2);